Blog Archives

Backup script for GLPI (http://www.glpi-project.org)

If you are using the great GLPI tool, you will notice that the market value of the data inside will increase rapidly. This usually also implicates that it is ‘wise’ to back this data up.

There are many ways to do so using nice plugins, even nicer gui`s and apps. I (headstrong that I am), wanted something very basic and functional, easy to configure, and that will work in an environment that has multiple GLPI installations. Answer to my question: build something for your own.

So i scripted something for Linux that will allow you to backup the entire GLPI tree (where the uploaded files reside), and the sql database.

Because we use a deduped backup storage (datadomain), i dont have to worry about duplicate data. If you need to, then add something to clean the backup store. This script doesn’t account for that 🙂

This is the script:


#!/bin/bash
# Wrote by Chris
# Goal is to easly backup glpi in a multi installation environment.

GLPI_DIR='/var/www/glpi_0805';
BACKUP_DIR='/backup/nfsloc';
LOGFILE='/var/log/backup.log';

############################################################################
#Dont change anything after this point, unless you know what you are doing #
#No guarantees, une this script at own risk                                #
############################################################################

# Do some generic stuff here
# Add checks if you like 🙂
#############################
MYSQLDUMP=`which mysqldump`;
AWK=`which awk`;
FIND=`which find`;
DATE=`date +%d.%m.%Y`;
LOGTIME=`date +"%d-%m-%Y %H:%m"`;
DBCONFIG=`find $GLPI_DIR -name "config_db.php"`;
DBNAME=`grep "dbdefault" $DBCONFIG | awk -F '=' '{ gsub(/\047/,""); gsub(/\;/,""); gsub(/ /,""); print $2;}'`;
GLPISIZE=`du -sh $GLPI_DIR`;

#
# Start working....
############################
echo -e "$LOGTIME \t## New backup started ##" >> $LOGFILE;
echo -e "$LOGTIME \tpacking: $GLPISIZE.. into $BACKUP_DIR/backup.$DATE.tar.bz2 ..." >> $LOGFILE;
tar -cjPf $BACKUP_DIR/backup.$DATE.tar.bz2 $GLPI_DIR >> $LOGFILE;
echo -e "$LOGTIME \tCreating mysqldump into $BACKUP_DIR/sqldump.$DATE.sql ..." >> $LOGFILE;
mysqldump $DBNAME > $BACKUP_DIR/sqldump.$DATE.sql;
# Go back to original working directory.
echo -e "$LOGTIME \tAll done..." >> $LOGFILE;
echo "all done! ";

exit 0;

If you want to install this script follow the following instructions:


#This is for Oracle Enterprise Linux / RedHat EL distro`s
#Your environment might be slightly different.
cd /opt
mkdir ./scripts
cd scripts
vi ./backup.sh
#insert the code above into the editor and save the lot using ':wq'
#alter the top of the script to match your environment.
chmod +x ./backup.sh
#next create a symbolic link to the cron.daily, this might be different in your linux distro (see manual pages on your distro using 'man cron').
ln -s /opt/scripts/backup.sh /etc/cron.daily/backup
#monitor the /var/log/backup.log for details

Happy backing up 🙂

(Dont forget to clean the backup dir on a regular basis if you dont have the luxury of an deduping storage)

Advertisements

Altering the Nagios daemon startup script to include NDO.

previously I wrote an article on how to create a deamon script for ndo. But when you are using Centreon the only “nice” way to do this is by altering the Nagios startupscript to include the ndo part.

Here is what i have done to make this possible.

First i wrote a function to find the PIDs for the ndo deamon process based on a specific config. In this one the config is hardcoded,
but you might also replace the $NagiosNdoConfig with $1 instead and call the function like;

getNdoPid “/usr/local/nagios/etc/yourconfig.cfg”

getNdoPid ()
{
 #Declare a var containing the correct ndo PID, there are processes being forked from ndo so we need to
 #do some awk filtering also to fetch the correct one.
 #Not that the parent process always has a parent pid "1" so we use that to filter the parent from the childs.
 ndoPID=`ps -ef | grep $NagiosNdoConf | grep "?" | awk -F ' '  '{if($3 == '1') print $2}'`
        #next we validate if we got an pid returned to us, and fill a wrapper that we will use like $? that ill convieniently call "ls" LastState.
        if [[ "$ndoPID" == '' ]]; then
            ls=1;
        else
            ls=0;
        fi
}

Next using the getNdoPid function u wrote another two functions to start and to stop the ndo daemon. I choose this method so i can include these function inside the existing start stop scripting used by nagios. In effect when you start nagios, th start case select is used which will call our ndo start script.

The ndo kill function

kill_ndo ()
{
        #Find the actual PID
        if [[ "$ndoPID" == '' ]]; then
             #No process running to kill...
             ls=0;
        else
             kill $ndoPID;
             sleep 2 #parent needs some time to kill the child processes if any
             getNdoPid
             if [[ "$ls" == '1' ]]; then
                   ls=0;
             else
                   ls=1;
             fi
        fi
}

and the start portion…
The ndo start function

start_ndo ()
{
        #always make sure ndo isnt running!
        $NagiosNdo -c $NagiosNdoConf;
        if [[ "$?" == '0' ]]; then
                ls=0;
        else
                ls=1;
        fi
}

Again i am using the ls (laststate) var to save the last state of the executed command. This is important because the state of a command can only be tested right after execution of that command. by using the ls var i make sure i am always testing the correct result. this is because the $? is also overwritten when performing an var assignment, if test etc.

Next I added a few vars for configuration, stuff like where the ndo2db bin is located, and the config file.

NagiosNdo=/usr/sbin/ndo2db;
NagiosNdoConf=/usr/local/nagios/etc/ndo2db.cfg;

naturally the NDO bin could also be found like;
NagiosNdo=`which ndo2db`;
Bu this will require the ndo2db bin to be somewhere in the path var. We are not sure this is always the case because there is no consensus on where these nagios bins should be placed. This may vary from distro to distro and from user to user. In my case, it being placed inside /user/bin this whould also work.

I also extended the functionality of the startupscript by adding new options to start, stop and restart the ndo deamon by using the nagios startupscript. This is what i did.

inside the “case” statement where the “/etc/init.d/nagios args” are tested i added some new options namely “startndo, stopndo, restartndo” and this is what it looks like.

For the option “/etc/init.d/nagios startndo”

 startndo)
                getNdoPid
                if [[ "$ls" == '1' ]]; then
                    start_ndo
                    if [[ "$ls" == '0' ]]; then
                        echo 'NDO deamon started succesfully';
                        exit 0;
                    else
                        echo 'Failed to start NDO, check your logging for more info';
                        exit 1;
                    fi
                else
                    echo "Ndo deamon allready running with PID : $ndoPID";
                    exit 1;
                fi
                ;;

for the “/etc/init.d/nagios stopndo” option

stopndo)
                getNdoPid
                if [[ "$ls" == '1' ]]; then
                     echo "$ls";
                     exit 1;
                else
                     kill_ndo
                     sleep 2 #it needs some time to kill the childs (that get ppid 1 when the parent quits)
                     getNdoPid
                     if [[ "$ls" == '1' ]]; then
                         echo "Ndo stopped succesfully";
                         exit 0;
                     else
                         echo "Unable to kill ndo, please review you logging";
                         exit 1;
                     fi
                fi
                ;;

And a restart option “/etc/init.d/nagios restartndo”

restartndo)
                $0 stopndo
                $0 startndo
                ;;

To include the start and stop options in the nagios start and stop process all you need to do is add the start and or stop options in there.
Here is an example

 start)
                echo -n "Starting nagios:"
                $NagiosBin -v $NagiosCfgFile > /dev/null 2>&1;
                if [ $? -eq 0 ]; then
                        su - $NagiosUser -c "touch $NagiosVarDir/nagios.log $NagiosRetentionFile"
                        rm -f $NagiosCommandFile
                        touch $NagiosRunFile
                        chown $NagiosUser:$NagiosGroup $NagiosRunFile
                        $NagiosBin -d $NagiosCfgFile
                        if [ -d $NagiosLockDir ]; then touch $NagiosLockDir/$NagiosLockFile; fi
                        #chmod 777 $NagiosCommandFile
                        start_ndo
                        echo " done."
                        exit 0
                else
                        echo "CONFIG ERROR!  Start aborted.  Check your Nagios configuration."
                        exit 1
                fi
                ;;
#Stop portion
stop)
                echo -n "Stopping nagios: "

                pid_nagios
                killproc_nagios nagios
                kill_ndo
                # now we have to wait for nagios to exit and remove its
                # own NagiosRunFile, otherwise a following "start" could
                # happen, and then the exiting nagios will remove the
                # new NagiosRunFile, allowing multiple nagios daemons
                # to (sooner or later) run - John Sellens
                #echo -n 'Waiting for nagios to exit .'
                for i in 1 2 3 4 5 6 7 8 9 10 ; do
                    if status_nagios > /dev/null; then
                        echo -n '.'
                        sleep 1
                    else
                        break
                    fi
                done
                if status_nagios > /dev/null; then
                    echo ''
                    echo 'Warning - nagios did not exit in a timely manner'
                else
                    echo 'done.'
                fi

                rm -f $NagiosStatusFile $NagiosRunFile $NagiosLockDir/$NagiosLockFile $NagiosCommandFile
                ;;

        status)
                pid_nagios
                printstatus_nagios nagios
                ;;

Now when i start and stop nagios using the centreon “start / stop / reload” options my ndo daemon is also started / stopped. Ps. This manual uses Nagios 3.0 and Centreon 2.2

This is what a restart looks like 😉

[root@UX127 var]# service nagios restartndo
Ndo stopped succesfully
NDO deamon started succesfully

Rgrds,

wait in Bash..

This is an alternative for sleep [i]n[/i]

function wait(){
    BOGUS=`read -n1 -t1 any_key`
    BOGUS=''
}

If you have sleep available, you rather use sleep then this method! i.e.

$N=1;
while :
do
    echo "$N"
    sleep 1
    let N=$N+1;
done

NRPE – Check_memory script

this script is intended to “mime” the NSClient++ checkMem option on linux. Most check_mem scripts i have found where rather “minimal” so i ended up writing my own one. Feel free to test, use, alter, redis or what ever with it 🙂

Here is a new version. Improvements.

– Var footprints reduced to a bare minimum.
– Free command is now only executed once.
– Corrected the swap validation that was using the wrong vars.
– Added small corrections like adding ; within “ execs to mark end of command etc.

Here you go 🙂

    #!/bin/bash
#
#
# @Type 	: Bash
# @Date 	: 19-05-2009
# @Author 	: Chris Gralike
# @Category	: Nagios Monitoring/SLA
# @Category	: MemoryCheck Linux, All memory spaces
# @Company	: AMIS Services BV.
# @License	: GNU_Public
# @ToDo		: See Comments in script. Suggestions are welcome... 
##

## You are free to alter, modify and distribute the content of this file
 # This file is offered "as is", and we offer no guarantee on functionality
 # and or outcome of this check. Neither can the author nor AMIS be
 # responsible for any damages caE by this script. 
 #
 # Have fun with it, and we hope it proves usefull
 # Script is based on precentage orientated monitoring / SLAs
 ##

#Get Options
while getopts 'u:v:w:x:y:z:hpef' OPT; do
  case $OPT in
    u) U=$OPTARG;;
    v) V=$OPTARG;;
    w) W=$OPTARG;;
    x) X=$OPTARG;;
    y) Y=$OPTARG;;
    z) Z=$OPTARG;;
    e)  E="yes";;
    f)  FR="yes";;
    p)  P="yes";;
    h)  H="yes";;
    *)  unknown="yes";;
  esac
done
#Help Output
USAGE="
	usage: $0 [ -option [value]]
	
	[options:]
		-h		->	Show this help page
		-p		->	Show performance options
		-e		->	Warn/Crit based on usage precentage, warn/crit based on usage orientation
		-f		->	Warn/Crit based on free precantage, warn/crit based on free space orientation
		-u [valeu]	->	Physical warning treshold (in %)
		-v [value]	->	Physical critical treshold (in %)
		-w [value]	->	Virtual waring treshold (in %)	
		-x [value]	->	Virtual critical treshold (in%)
		-y [value]	->	Swap warning value (in%)
		-z [value]	->	Swap critical value (in%)
"
#Show usage if requested
if [ "$H" = "yes" -o $# -lt 1 ]; then
	echo "$USAGE"
	exit 0
fi
#Check if all the thresholds are defined.
if [ "$W" = "" -o "$X" = "" -o "$U" = "" -o "$V" = "" -o "$Y" = "" -o "$Z" = "" ]; then
	echo "All the [u,v,w,x,y,z] options should be defined! \r\n"
	exit 0
fi
#Check if all the thresholds are integers
# if syntax is $0 -e -u 10 -v 10 -w 10 -x 10 -y 10 -z 10 -p things are allright
# if syntax is $0 -e -u 10 -v 10 -w 10 -x 10 -y 10 -z -p A bunch of errors arise because " " is not equal too ""
# and failes the check above.
# This typo needs to be fixed someday...
#Check the orientation
if [ "$E" = "yes" -a "$FR" = "yes" ]; then
	echo "You cant use both the free, as E orientation for the tresholds. Please select -e or -f as orientation"
	exit 0
elif [ "$E" = "yes" ]; then
	# Check the critical / warning thresholds
	if [ "$W" -gt "$X" -o "$U" -gt "$V" -o "$Y" -gt "$Z" ]; then
		echo "Warning: Warning > Critical while using usage orientation!"
	fi	

elif [ "$FR" = "yes" ]; then
	# Check the warning / Critical thresholds
	if [ "$W" -lt "$X" -o "$U" -lt "$V" -o "$Y" -lt "$Z" ]; then
                echo "Warning: Warning < Critical while using free space orientation!"
        fi
else
	echo "Please define an orientation using either the -e or the -f option"
	exit 0;
fi

#Get physiscal numbers 
FRE=`free -m`

PT=`echo "$FRE" | grep Mem | awk '{ print $2; exit;}';`
PU=`echo "$FRE" | grep Mem | awk '{ print $3; exit;}';`
FP=$(($PT-$PU));
#Get virtual memory numbers
VU=`echo "$FRE" | grep buffers/cache | awk '{ print $3; exit;}';`
VF=`echo "$FRE" | grep buffers/cache | awk '{ print $4; exit;}';`
VT=$(($VU+$VF));
#Get Swapped memory numbers
ST=`echo "$FRE" | grep Swap | awk '{ print $2; exit;}';`
SU=`echo "$FRE" | grep Swap | awk '{ print $3; exit;}';`
SF=$(($ST-$SU));

#still needs to be done in an nice syntax.
#Start validating our numbers.
if [ "$E" = "yes" ]; then
	#calculate E precentages
	PPF=`echo "scale=5; (100/$PT)*$PU" | bc -l | awk -F '.' '{ print $1; exit; }'`
	VPF=`echo "scale=5; (100/$VT)*$VU" | bc -l | awk -F '.' '{ print $1; exit; }'`
	SPF=`echo "scale=5; (100/$ST)*$SU" | bc -l | awk -F '.' '{ print $1; exit; }'`
	#still needs to be done in an nice syntax.
	if [ "$P" = "yes" ]; then
        	#not sure about the syntax...
		PD="|Ph=$PPF%;$U;$V; Vi=$VPF%;$W;$X; Sw=$SPF%;$Y;$Z;"
	else
        	PD=""
	fi

	MSG="Ph:$PU/$PT($PPF%), Vi:$VU/$VT($VPF%), Sw:$SU/$ST($SPF%) $PD"

	#Validate Physical Memory
	if [ "$PPF" -gt "$U" -a "$PPF" -gt "$V" ]; then
		NPE=2
	elif [ "$PPF" -gt "$U" -a "$PPF" -lt "$V" ]; then
		NPE=1
	elif [ "$PPF" -lt "$U" -a "$PPF" -lt "$V" ]; then
		NPE=0
	else
		#unknown crit and warn the same?
		NPE=3
	fi 
	#Validate Virtual Memory
	if [ "$VPF" -gt "$W" -a "$VPF" -gt "$X" ]; then
       	        NVE=2
        elif [ "$VPF" -gt "$W" -a "$VPF" -lt "$X" ]; then
       		NVE=1
   	elif [ "$VPF" -lt "$W" -a "$VPF" -lt "$X" ]; then
               	NVE=0
       	else
               	#unknown crit and warn the same?
               	NVE=3
       	fi
	#Validate Swap memory
	if [ "$SPF" -gt "$W" -a "$SPF" -gt "$X" ]; then
                NSE=2
        elif [ "$SPF" -gt "$W" -a "$SPF" -lt "$X" ]; then
                NSE=1
        elif [ "$SPF" -lt "$W" -a "$SPF" -lt "$X" ]; then
                NSE=0
        else
                #unknown crit and warn the same?
                NSE=3
        fi
	#We only want to see the most critical,...
	if [ "$NPE" -eq "2" -o "$NVE" -eq "2" -o "$NSE" -eq "2" ]; then
		echo "Critical - $MSG"
		exit 2
	elif [ "$NPE" -eq "1" -o "$NVE" -eq "1" -o "$NSE" -eq "1" ]; then
		echo "Warning - $MSG"
		exit 1
	elif [ "$NPE" -eq "0" -a "$NVE" -eq "0" -a "$NSE" -eq "0" ]; then
                echo "Ok - $MSG"
                exit 0
	else
		echo "Unknown - $MSG"
		exit 3
	fi
elif [ "$FR" = "yes" ]; then
	#calculate free precentages
	PPF=`echo "scale=5; (100/$PT)*$FP" | bc -l | awk -F '.' '{ print $1; exit; }'`
	VPF=`echo "scale=5; (100/$VT)*$VF" | bc -l | awk -F '.' '{ print $1; exit; }'`
	SPF=`echo "scale=5; (100/$ST)*$SF" | bc -l | awk -F '.' '{ print $1; exit; }'`
	
	#still needs to be done in an nice syntax.
	if [ "$P" = "yes" ]; then
			#not sure about the syntax...
			PD="|Ph=$PPF%;$U;$V; Vi=$VPF%;$W;$X; Sw=$SPF%;$Y;$Z;"
	else
			PD=""
	fi

	MSG="Ph:$FP/$PT($PPF%), Vi:$VF/$VT($VPF%), Sw:$SF/$ST($SPF%) $PD"

        #Validate Physical Memory
        if [ "$PPF" -lt "$U" -a "$PPF" -lt "$V" ]; then
                NPE=2
        elif [ "$PPF" -lt "$U" -a "$PPF" -gt "$V" ]; then
                NPE=1
        elif [ "$PPF" -gt "$U" -a "$PPF" -gt "$V" ]; then
                NPE=0
        else
                #unknown crit and warn the same?
                NPE=3
        fi
        #Validate Virtual Memory
        if [ "$VPF" -lt "$W" -a "$VPF" -lt "$X" ]; then
                NVE=2
        elif [ "$VPF" -lt "$W" -a "$VPF" -gt "$X" ]; then
                NVE=1
        elif [ "$VPF" -gt "$W" -a "$VPF" -gt "$X" ]; then
                NVE=0
        else
                #unknown crit and warn the same?
                NVE=3
        fi
        #Validate Swap memory
        if [ "$SPF" -lt "$W" -a "$SPF" -lt "$X" ]; then
                NSE=2
        elif [ "$SPF" -lt "$W" -a "$SPF" -gt "$X" ]; then
                NSE=1
        elif [ "$SPF" -gt "$W" -a "$SPF" -gt "$X" ]; then
                NSE=0
        else
                #unknown crit and warn the same?
                NSE=3
        fi
        #We only want to see the most critical,...
        if [ "$NPE" -eq "2" -o "$NVE" -eq "2" -o "$NSE" -eq "2" ]; then
                echo "Critical - $MSG"
                exit 2
        elif [ "$NPE" -eq "1" -o "$NVE" -eq "1" -o "$NSE" -eq "1" ]; then
                echo "Warning - $MSG"
                exit 1
        elif [ "$NPE" -eq "0" -a "$NVE" -eq "0" -a "$NSE" -eq "0" ]; then
                echo "Ok - $MSG"
                exit 0
        else
		 echo "Unknown - $MSG"
                exit 3
        fi
else
	echo "Something is very off..... please review all the settings, or report this as a bug"
	exit 3
fi

Rgrds Chris

Ndo Utils startup script for usage with chkconfig.

Is functional, there is a bug in the start portion that i still need to fix. But it will start the deamon correctly and if you use the “service ndodaemon rewrite-lock” the status and stop functions will also work correctly.


#!/bin/sh
#
# chkconfig: 345 90 01
# description: Nagios NDO Utils Deamon
# ./etc/init.d/ndodaemon

prefix=/usr/sbin
Bin=ndo2db
NdoBin=$prefix/$Bin
NdoUsr=root
NdoConf=/usr/local/nagios/etc/ndo2db.cfg
RunFile=/usr/local/nagios/var/ndo2db.lock

#check if ndobin exists
if [ ! -f $NdoBin ]; then
echo "NDO Binairy doesnt exist!"
exit 1
fi

#check if ndoConfig exists
if [ ! -f $NdoConf ]; then
echo "NDO Config file not found!"
exit 1
fi

case $1 in

start)
if test -f $RunFile; then
echo "NDO Deamon allready started"
exit 1
else
echo -n "Starting the NDO Deamon:"
$NdoBin -c $NdoConf & > /dev/null 2>&1;

if [ $? -eq 0 ]; then
for i in 1 2 3 4 5 6 7 8 9 10 ; do
echo -n ".";
sleep 1
done
P=`ps -C $Bin -o pid | grep -P [0-9]`

echo "Done."
exit 0
else
echo "Failed to start the deamon, check the config file!"
exit 1
fi
fi
;;

stop)
if test -f $RunFile; then
#make sure we have both services!
`ps -C $Bin -o pid | grep -P [0-9] > $RunFile`
#Get first PID
ndo1PID=`head -n 1 $RunFile`;
#Get 2nd PID
ndo2PID=`tail -n 1 $RunFile`;
echo $ndo1PID
echo $ndo2PID
#need to make this a bit more logic, but it works for the moment....
kill $ndo1PID > /dev/null 2>&1;
kill $ndo2PID > /dev/null 2>&1;
rm $RunFile > /dev/null
if [ $? -eq 0 ]; then
echo "Done."
exit 0;
else
echo "Failed."
exit 1
fi
else
echo "No NDO deamon to stop!"
exit 1;
fi

;;

rewrite-lock)
ps -C $Bin -o pid | grep -P [0-9] > $RunFile
;;

status)
if test -f $RunFile; then
#We have a runfile, so we check based on PID
ndo1PID=`head -n 1 $RunFile`;
ndo2PID=`tail -n 1 $RunFile`;
#Process Parent NDO deamon
if [ $ndo1PID > 0 ]; then
ps -p $ndo1PID > /dev/null 2>&1;
if [ $? -eq 0 ]; then
Status1="NDO Parent (PID $ndo1PID) is alive!"
else
Status1="NDO Parent (PID $ndo1PID) not alive, remove lock file then check for orphan processes then restart deamon."
fi
else
Status1="NDO Parent (PID $ndo1PID) not alive!"
fi

if [ $ndo2PID > 0 ]; then
ps -p $ndo2PID > /dev/null 2>&1;
if [ $? -eq 0 ]; then
Status2="NDO Child (PID $ndo2PID) is alive!"
else
Status2="NDO Child (PID $ndo2PID) not alive!"
fi
else
Status2="NDO child (PID $ndo2PID) not alive!"
fi
echo $Status1
echo $Status2
exit 0
else
#We dont have a Runfile so lets see if someone started it manually.
ps -C $Bin > /dev/null 2>&1;
if [ $? -eq 0 ]; then
echo "NDO process seems to be manually started!"
exit 1
else
echo "NDO Deamon is not running."
exit 1
fi
fi
;;

*)
echo "Usage: $0 {start|stop|status|rewrite-lock}"
exit 1
;;
esac