Download : fragmentation_vxfs_en1.sh

#! /bin/ksh
#
# vim:tabstop=3:syntax=sh:
#
# ---------
## Script  : fragmentation_vxfs.sh
## Objet   : envoie un rapport de fragmentation VXFS si besoin
##----------------------------------------------------------------------------
# 0.1 31-jul-09 - Cedrick Gaillard
# 1.1 01-sep-09 - plus d'analyse sur /tmp
#               - plus d'analyse sur les FS utilises a 5% ou moins
#               - cree le repertoire $MOUNTPOINT/lost+found pour le lock fsadm
#                 si besoin.
#               - les commandes a lancer pour defragmenter accompagnent
#                 maintenant les rapports.
#               - si plusieurs FS sont a defragmenter, une liste avec toutes
#                 les commandes a lancer est affichee en premier, suivi du
#                 detail.
#               - on peut maintenant s'envoyer un mail de rapport au lieu de
#                 l'envoyer a tout le monde.
#               - reecrit plus proprement.
# 1.2 16-sep-09 - utilise bdfa si bdf.pl sort en erreur
#               - un seul bdf.pl/bdfa est lance maintenant
#               - n'analyse plus les FS utilises <= 15% d'utilisation
#               - leger changement sur l'output.
#               - n'analyse plus /tmp
# 1.5 24-sep-09 - gestion de seuils warnings et critiques.
#               - reecriture d'un partie du script awk.
# 1.6 20-oct-09 - on peut specifier des FS a analyser au lieu de tout analyser
# 1.7 03-nov-09 - correction du test de selection de l'importance des mails
#               - correction du test du % d'utilisation du FS.
# 1.8 12-avr-10 - affiche l'etat de fragmentation mme quand le FS n'est pas
#                 fragmente.
#               - legere modification du message de resume.
# 1.9 30-avr-10 - ajout de quelques commentaires.
#               - n'affiche plus que les fs a defragmenter dans le resume des
#                 commande a lancer.
#               - n'affiche plus les rapports, seulement les status.
#
#-----------------------------------------------------------------------------

SERVER_NAME=$(uname -n)
DEFRAG_COMMAND="/usr/sbin/fsadm -F vxfs -DEde -s"

TMPFILE="/var/tmp/${0##*/}.VARS.$$"

EXPEDITEUR="FRAGMENTATION REPORT<root@$(hostname)>"
DESTINATAIRE="Operator<operator@example.com>"
IMPORTANCE="Low"

# Keep it to '0', It will be automatically set to '1' if a FS needs to be defragmented.
SEND=0

# css decoration
CSS='<style type="text/css">
	<!--
	body { font-family:"Courier New",Courier,sans-serif; font-size:8pt; }
	h1   { font-size:12pt; color:darkblue; }
	.Rouge { color:#FF0000; font-weight: bold }
	.Orang { color:#FF8C00; font-weight: bold }
	.Verte { color:#00CC00; }
	-->
	</style>
'

# arguments
while [ "$#" -ne "0" ]
do
	case $1
	in
		-mail) [ -n "$2" ] && {
					DESTINATAIRE="$2"
					shift 1
				}
				shift 1
				;;
		-v)	# Permits to show status event if there is no fragmentation.
				VERBOSE=true
				shift 1
				;;
		*)		FS_TO_ANALYZE="$FS_TO_ANALYZE $1"
				shift 1
				;;
	esac
done

[ -x "/usr/bin/perl" ] && BDF="$(/usr/local/bin/bdf.pl -t vxfs 2>/dev/null |grep -v interpreter)"
[ "$?" = "0" ] || BDF="$(/usr/local/bin/bdfa -t vxfs 2>/dev/null)"
[ "$?" = "0" ] || BDF=
BDF_HEAD="$(echo "${BDF}" |head -1)"

if [ -n "$FS_TO_ANALYZE" ]
	then
		MOUNTPOINTS="$(bdf $FS_TO_ANALYZE |tail +2 |awk '{print $NF}')"
	else
		MOUNTPOINTS="$(grep " vxfs " /etc/mnttab |cut -d" " -f 2)"
fi

# grep " vxfs " /etc/mnttab |cut -d" " -f 2 |while read MOUNTPOINT
for MOUNTPOINT in $MOUNTPOINTS
do
	[ -d "${MOUNTPOINT}/lost+found" ] || mkdir "${MOUNTPOINT}/lost+found"
	chown 0:0 "${MOUNTPOINT}/lost+found"
	chmod 0700 "${MOUNTPOINT}/lost+found"
	[ "$MOUNTPOINT" = "/tmp" ] && continue

	[ "$BDF" != "" ] && {
	# We do not analyze FS used less than 15%
			[ "$(echo "$BDF" |awk '{print $5 " " $10}' | grep " ${MOUNTPOINT}$" |cut -d'%' -f1)" -le "15" ] && continue
	}

	# raw state of the fragmentation
	FRAGMENTATION="$(/usr/sbin/fsadm -F vxfs -E $MOUNTPOINT)"
	[ "$?" = "0" ] || {
		echo "ERROR: wannot analyze the mountpoint: $MOUNTPOINT"
		continue
	}

	# stack states by category
	unset ACTUAL_SMALL64 ACTUAL_SMALL8 ACTUAL_BLOCKS64
	ACTUAL_SMALL64="$( echo "${FRAGMENTATION}" |fgrep "% Free blocks in extents smaller than 64 blks:" |awk '{print $NF}')"
	ACTUAL_SMALL8="$(  echo "${FRAGMENTATION}" |fgrep "% Free blocks in extents smaller than  8 blks:" |awk '{print $NF}')"
	ACTUAL_BLOCKS64="$(echo "${FRAGMENTATION}" |fgrep "% blks allocated to extents 64 blks or larger:" |awk '{print $NF}')"

	[ -z "$ACTUAL_SMALL64" -o -z "$ACTUAL_SMALL8" -o -z "$ACTUAL_BLOCKS64" ] && {
		echo "ERROR: at least one of the values is empty concerning the mountpoint: $MOUNTPOINT"
		continue
	}

	STATUS=$(echo $ACTUAL_SMALL64 $ACTUAL_SMALL8 $ACTUAL_BLOCKS64 |awk 'BEGIN { RVAL=0 } {
		CRIT_SMALL64=70  ; WARN_SMALL64=50 ;
		CRIT_SMALL8=15   ; WARN_SMALL8=5 ;
		CRIT_BLOCKS64=4 ; WARN_BLOCKS64=6 ;

		ROUGE = "<span class=\"Rouge\">CRIT" ;
		ORANG = "<span class=\"Orang\">WARN" ;
		VERTE = "<span class=\"Verte\">GOOD" ;

		MSG = sprintf("--> %% Free blocks in extents smaller than 64 blks : %5.2f%%</span>", $1) ;
		SEUIL = sprintf("<span>- WARN if &gt;%s%% / CRIT if &gt;%s%%</span>", WARN_SMALL64, CRIT_SMALL64) ;
		if( $1 > CRIT_SMALL64 ) {
			printf("%s %s %s\n", ROUGE, MSG, SEUIL ) ; RVAL=2 ;
		} else if ( $1 > WARN_SMALL64 ) {
			printf("%s %s %s\n", ORANG, MSG, SEUIL ) ; RVAL=1 ;
		} else {
			printf("%s %s\n", VERTE, MSG ) ;
		}

		MSG = sprintf("--> %% Free blocks in extents smaller than  8 blks : %5.2f%%</span>", $2) ;
		SEUIL = sprintf("<span>- WARN if &gt;%s%% / CRIT IF &gt;%s%%</span>", WARN_SMALL8, CRIT_SMALL8) ;
		if( $2 > CRIT_SMALL8 ) {
			printf("%s %s %s\n", ROUGE, MSG, SEUIL ) ; RVAL = 2 ;
		} else if( $2 > WARN_SMALL8 ) {
			printf("%s %s %s\n", ORANG, MSG, SEUIL ) ; RVAL = 1 ;
		} else {
			printf("%s %s\n", VERTE, MSG ) ;
		}

		MSG = sprintf("--> %% blks allocated to extents 64 blks or larger : %5.2f%%</span>", $3) ;
		SEUIL = sprintf("<span>- WARN if &lt;%s%% / CRIT if &lt;%s%%</span>", WARN_BLOCKS64, CRIT_BLOCKS64) ;
		if( $3 < CRIT_BLOCKS64 ) {
			printf("%s %s %s\n", ROUGE, MSG, SEUIL ) ; RVAL = 2 ;
		} else if( $3 < WARN_BLOCKS64 ) {
			printf("%s %s %s\n", ORANG, MSG, SEUIL ) ; RVAL = 1 ;
		} else {
			printf("%s %s\n", VERTE, MSG ) ;
		}
	} END { exit RVAL ; }')

	RVAL=$?
	[ "$RVAL" -ne "0" ] && {
		SEND=1
		if [ "$RVAL" -eq "1" -a "$IMPORTANCE" != "High" ]
			then
				IMPORTANCE="Normal"
			else
				IMPORTANCE="High"
		fi
	}

	if [ "$BDF" != "" ]
		then
			REPORT_BDF="${BDF_HEAD}<br/>$(echo "${BDF}" |awk -v M=${MOUNTPOINT} '{if($NF == M){print $0; break}else{next;}}')"
		else
			REPORT_BDF=
	fi

	CONTENT="${CONTENT}
		<hr/>
		<h1>Fragmentation information on the mountpoint:</h1>
		<pre>${REPORT_BDF}</pre>"
	[ "$RVAL" -ne "0" -o "$VERBOSE" = "true" ] && {
		CONTENT="${CONTENT}<pre>$STATUS</pre>"
	}
#	[ "$RVAL" -ne "0" ] && {
#		CONTENT="${CONTENT}
#			<p>lancer la commande suivante pour défragmenter si besoin:<br/>
#			${DEFRAG_COMMAND} $MOUNTPOINT
#			</p>"
#	}
#	[ "$RVAL" -ne "0" -o $VERBOSE = "true" ] && {
#		CONTENT="${CONTENT}
#			<h2>STATUS:</h2>
#			<pre>$STATUS</pre>"
#	}
#	[ "$RVAL" -ne "0" ] && {
#		CONTENT="${CONTENT}
#			<h2>RAPPORT:</h2>
#			<pre>$FRAGMENTATION</pre>"
#	}
done

# En tete
echo "From: ${EXPEDITEUR}
To: ${DESTINATAIRE}
Importance: ${IMPORTANCE}
Subject:[${SERVER_NAME}] Fragmentation report
Content-Type: text/html
<html><head>${CSS}</head><body>" > $TMPFILE

if [ "$SEND" = "1" -o "$VERBOSE" = "true" ]
	then
		# If more than one FS, commands on the header
		[ "$(echo "${CONTENT}" |grep -c "${DEFRAG_COMMAND} ")" -gt "1" ] && {
		echo "<h1> INFO: Fragmentation detected on more than one FS</h1><p>please run the following commands to optimize files access<ul>" >> $TMPFILE
			echo "${CONTENT}" |grep "${DEFRAG_COMMAND} " |sed -e "s/	//g" -e "s/^/<li>/" -e "s/$/<\/li>/" >> $TMPFILE
			echo "</ul></p>" >> $TMPFILE
		}

		FS_TO_ANALYZE=$(echo "${CONTENT}" |grep "${DEFRAG_COMMAND} " |awk '{printf $NF " "}')

		echo "<p>The following command will permit you to verify the fragmentation state: <br/>
				$0 -v -mail $DESTINATAIRE $FS_TO_ANALYZE</p>
				<p>d&eacute;tails:</p>" >> $TMPFILE

		echo "${CONTENT}" >> $TMPFILE
	else
		/bin/rm -f $TMPFILE
		exit 0
fi

# footer
echo "<p>Script: $0</p> </body></html>" >> $TMPFILE

cat $TMPFILE |sendmail -t

/bin/rm -f $TMPFILE

Download : quotasets.sh

#!/bin/ksh -a

# MUST BE RUN FROM THE MOUNTROOT OF THE FS
# for example : from /nfsint1/export02

# USERS must be in the subdirectory users
# for example : /nfsint1/export02/users

V_TEMPFILE=/tmp/quotaset

DEFS_QUOTA=50000
DEFH_QUOTA=55000
DEFS_INODE=5000
DEFH_INODE=5500
V_DATE=$(date +"%d-%m-%Y_%Hh%Mm%S")

if [ -f "$1" ]
	then
		# Important
		cp /dev/null ${V_TEMPFILE}

		function fct_quotaset {
			echo "INFO: working on user $u_user"

			while read a FS b c d SQ e f HQ g h i SI j k HI
			do
				[ "$FS" != "$(pwd)" ] && {
					echo "$a $FS $b $c $d $SQ $e $f $HQ $g $h $i $SI $j $k $HI" >>${V_TEMPFILE}
					continue
				}

				softquota=$(echo $SQ |cut -d"," -f1)
				if [ "$softquota" = "0" ]
					then
						realuse=$(du -ks users/${u_user} |awk '{print $1}')
						if [ "$realuse" -le "$DEFS_QUOTA" ]
							then
								echo "INFO: ${u_user} uses ${realuse}ko space"
								cp $1 quota-bck/${u_user}.${V_DATE}
								softquota=$DEFS_QUOTA
							else
								echo "WARNING: ${u_user} exceeds the default QUOTA, can't set IT (${realuse}ko)"
						fi
				elif [ "$softquota" -gt "$DEFS_QUOTA" ]
					then
						echo "WARNING: the quota defined for $u_user exceeds the standard ($softquota > $DEFS_QUOTA)"
				fi
				hardquota=$(echo $HQ |cut -d")" -f1)
				[ "$hardquota" = "0" ] && {
					[ "$realuse" -le "$DEFS_QUOTA" ] && {
						hardquota=$DEFH_QUOTA
					}
				}

				softinode=$(echo $SI |cut -d"," -f1)
				[ "$softinode" = "0" ] && {
					softinode=$DEFS_INODE
				}
				hardinode=$(echo $HI |cut -d")" -f1)
				[ "$hardinode" = "0" ] && {
					hardinode=$DEFH_INODE
				}

				echo "$a $FS $b $c $d ${softquota}, $e $f ${hardquota}) $g $h $i ${softinode}, $j $k ${hardinode})" >>${V_TEMPFILE}
			done < $1

			cat ${V_TEMPFILE} > quota-bck/${u_user}.new
			cat ${V_TEMPFILE} > $1
		}

		fct_quotaset $1
	else
		# WANT a backup
		[ ! -d "quota-bck" ] && {
			mkdir quota-bck
		}

		[ ! -f "quotas" ] && {
			echo "ERROR: no quotas file found !"
			exit 1
		}

		[ ! -d "users" ] && {
			echo "ERROR: no 'users' dir found !"
			exit 1
		}

		for v_user in users/*
		do
			[ ! -d "$v_user" ] && continue
			u_user="${v_user##*/}"

			[ "$u_user" = "TT_DB" ] && continue

			id ${u_user} >/dev/null 2>&1
			[ "$?" -ne "0" ] && {
				echo "ERROR: user $u_user does not exists in this system, you should maybe delete the '$v_user' directory"
				continue
			}

			EDITOR="${0}" edquota $u_user
		done
fi

Download : MULTI_PROCESS.sh

#!/bin/ksh
# vim:tabstop=3:syntax=sh:foldmethod=marker
#
# ---------
## Programme : if_error
## Version   : 1.6
## Objet     : paralellise le lancement d'un script au travers d'une fenetre
##             dtterm et analyse le code retour.
## Author    : Cedrick GAILLARD
## Email     : mobidyc @ gmail.com
##----------------------------------------------------------------------------
# 0.1 00-mar-09 - Creation
# 0.9 17-avr-09 - ajout de la limite de process lances en parallelisation.
#               - ajout de la possibilite de paralelliser un proramme donne en
#                 ligne de commande.
#               - possibilite de variabiliser un composant du script donne en
#                 ligne de commande.
#               - possibilite de ne pas exporter la variable ARGUMENT_TO_WORK.
#               - ajout de l'usage et d'exemples.
#               - ajout de controle d'erreurs.
#               - garde maintenant un log de tout ce qui se passe concernant
#                 l'argument concerne en cas d'erreur.
#               - ajout d'un resume des erreurs en fin de programme.
# 1.0 24-avr-09 - suppression du downtime nagios, mis dans le script d'arret.
# 1.1 11-jun-09 - Modification d'un message d'erreur
# 1.2 18-jun-09 - si limite n'est pas specifie, positionnement par defaut a 10
#                 ajout d'un parseur qui recherche les RVAL dans le script a
#               - modification du repertoire ou sont deposes les fichier .RVAL
#               - lancer pour les afficher avant le lancement du script.
# 1.3 09-sep-09 - ajout du chemin complet vers le binaire ps.
# 1.5 13-sep-10 - utilise maintenant le shell courant en tache de fond pour
#                 travailler, plus besoin d'exporter un DISPLAY.
#                 ajout de l'argument --dtterm pour utiliser dtterm.
# 1.6 09-mar-11 - modification du check display si ddterm n'est pas utilisé.
#
#-----------------------------------------------------------------------------

Usage () { #{{{
cat <<EOF
Usage:
   ${0} (-h | --help) (--dtterm) -e PROGRAM (-l LIMIT) (-n) [-f FILE ] [Argument1 ( ... ArgumentX ... )]"

   -h             Display usage
   --help         Display usage
   -e PROGRAM     Paralellize the program PROGRAM
   -l LIMIT       limit the paralellization to this value
   -n             Does not export the \$ARGUMENT_TO_WORK variable to PROGRAM
   --dtterm       use dtterm windows instead of the terminal
   -x VAR_NAME    Substitue each VAR_NAME occurences by arguments
   -f FILE        FILE contains an argument list

PROGRAM must be only one program, eventually followed by args.
   in that case, you must quote it.

Utility:
   ${0} will run multiple forks of PROGRAM. there will be as many fork as arguments, each fork can use
        the \$ARGUMENT_TO_WORK variable, which is the current argument.

   The first utility for this script was to paralellize a script, which takes a server name in argument,
   establish a connection to this server an run some commands, need a complete log and a resume in case
   of errors.
   but this script can deserve you a lot of other needs.

Example:
   6 forks and a maximum of 4 simultaneous run of xterm, each xterm will have the current argument in title

   # ${0} -l 4 -e "xterm -title FOOBAR -e sleep 2" -x FOOBAR A B C D E F

Example:
    # SERVER_LIST="machineA machineB machineB.dev.par.emea.cib"
    # ${0} -l 2 -e "ssh -o StrictHostKeyChecking=no FOOBAR uname -n" -x FOOBAR \$SERVER_LIST
    machineB : En erreur
    machineA : finished
    machineB.dev.par.emea.cib : Fait!

    Resume des erreurs :
    machineB : Erreur, Rval = 255 - voir le fichier /var/tmp/machineB.255.RVAL

    # cat machineB.RVAL
    ssh: machineB: node name or service name not known
    255

Example:
   using the --dtterm permits you oo interact with each telnet session
   SERVER_LIST="machineA machineB machineB.dev.par.emea.cib"
   # ${0} --dtterm -e "telnet TOTOTO-lc.adm" -x TOTOTO -l 4 \$SERVER_LIST
EOF
} #}}}

#SIZE="-geometry 100x10"
export SIZE=

[ -z "$1" ] && { #{{{
	echo "${0} (-h | --help) (--dtterm) -e PROGRAM (-l LIMIT) (-n) [-f FILE ] [Argument1 ( ... ArgumentX ... )]"
	echo 

	echo "to mass run a script on multiple servers :"
	echo "$0 -l 10 -e '${0%/*}/stop_server.sh' -f /tmp/server_liste.txt"
	echo "$0 -l 10 -e '${0%/*}/stop_server.sh' Server1 [ Server2 ... ServerX ]"
	echo "$0 -l 10 -e '${0%/*}/stop_server.sh' Server1 [ Server2 ... ServerX ]"
	echo "$0 -l 10 -e '${0%/*}/restart_server.sh' Serveur1 [ Serveur2 ... ServeurX ]"
	echo "$0       -e '${0%/*}/restart_server.sh' Serveur1 [ Serveur2 ... ServeurX ]"
	echo "$0       -e '${0%/*}/mass_downtime.sh' Serveur1 [ Serveur2 ... ServeurX ]"
	echo
	echo "To display detailed help :"
	echo "$0 -h"
} #}}}

stop_prg () { #{{{
	[ -n "$SERV_ERR" ] && {
		echo
		echo "Errors detected :"

		for SERV_IN_ERR in $SERV_ERR
		do
			Serv="${SERV_IN_ERR%:*}"
			Rval="${SERV_IN_ERR#*:}"

			if [ "$Rval" = "BAD" ]
				then
					echo "$Serv : Unknown error"
			elif [ -n "$(echo $Rval |sed 's/[0-9]//g')" ]
				then
					echo "$Serv : look at the ${TMPRVAL}/${Serv}.RVAL file"
				else
					echo "$Serv : ERROR: Rval=$Rval - look at the ${TMPRVAL}/${Serv}.${Rval}.RVAL file"
			fi
		done
	}

	if [ "$DEBUG" = "true" ]
		then
			echo "Logs: $TMPDIR"
		else
			rm -rf "$TMPDIR"
	fi

	exit
} #}}}

trap stop_prg 1 2 3 11 13 15
DEBUG=

echo -- " --> Analysing arguments"
while [ "$#" -ne "0" ] #{{{
do
	case $1
	in
		-e)	COMMANDS=$2
				shift 2
				;;
		-h|--help) \
				Usage
				exit
				;;
		-l)	LIMIT=$2
				shift 2
				;;
		-n)	VAR_EXPORT=false
				shift
				;;
		--dtterm)	V_WINTERM=true
					shift
				;;
		-x)	VAR_TO_USE=$2
				shift 2
				;;
		-f)	ARGUMENTS="$ARGUMENTS $(< $2)"
				shift 2
				;;
		*)		ARGUMENTS="$ARGUMENTS $1"
				shift
				;;
	esac
done #}}}
echo -- " --> End of analysing arguments"

RACINE="$(cd ${0%/*} && pwd)" || {
	echo "ERROR: can't get my racine directory"
	exit 1
}

[ -z "$DISPLAY" -a "$V_WINTERM" = "true" ] && {
	echo "ERREUR : your DISPLAY is not set"
	exit 1
}

DTTERM="/usr/dt/bin/dtterm"
V_DATE="$(date +%Y%m%d-%Hh%Ms%S)"

cd $RACINE

# default simultaneous limit
[ -z "$LIMIT" -o "$LIMIT" -lt "1" ] && LIMIT="10"

TMPDIR="/var/tmp/${0##*/}.${RANDOM}.${$}"
[ -d "${TMPDIR}" ] && {
	echo "ERROR : The temporary folder alreacy exists : ${TMPDIR}"
	exit 1
}
mkdir -p "${TMPDIR}"

TMPRVAL="/var/tmp"
[ -d "${TMPRVAL}" ] || mkdir -p "${TMPRVAL}"

# if PROGRAM has defined RVAL in header, we display them
egrep "^# RVAL - [0-9]*[0-9]  - " "$(echo ${COMMANDS} |awk '{print $1}')" 2>/dev/null
echo

[ -z "$COMMANDS" ] && {
	echo "no command found to execute!"
	exit 1
}

run_thread () { #{{{
	ARGUMENT_TO_WORK=$1
	[ "$VAR_EXPORT" != "false" ] && export ARGUMENT_TO_WORK

	if [ -n "$VAR_TO_USE" ]
		then
			COMMAND="$(echo "$COMMANDS" |sed "s@$VAR_TO_USE@$ARGUMENT_TO_WORK@g")"
		else
			COMMAND="$COMMANDS"
	fi

	echo "#! /bin/ksh" > "${TMPDIR}/${ARGUMENT_TO_WORK}.sh"
	echo "$COMMAND"   >> "${TMPDIR}/${ARGUMENT_TO_WORK}.sh"
	echo "echo \$?"   >> "${TMPDIR}/${ARGUMENT_TO_WORK}.sh"
	echo "exit"       >> "${TMPDIR}/${ARGUMENT_TO_WORK}.sh"
	chmod +x "${TMPDIR}/${ARGUMENT_TO_WORK}.sh"

	cp /dev/null ${TMPRVAL}/${ARGUMENT_TO_WORK}.RVAL
	if [ "$V_WINTERM" = "true" ]
		then
			${DTTERM} -kshMode $SIZE \
				-title ${ARGUMENT_TO_WORK} \
				-l -lf ${TMPRVAL}/${ARGUMENT_TO_WORK}.RVAL -geometry 100x10 \
				-e ${TMPDIR}/${ARGUMENT_TO_WORK}.sh &
		else
			(exec ${TMPDIR}/${ARGUMENT_TO_WORK}.sh ${ARGUMENT_TO_WORK}) > ${TMPRVAL}/${ARGUMENT_TO_WORK}.RVAL 2>&1 &
	fi

	PIDS="$PIDS $ARGUMENT_TO_WORK:$! "
	CURRENT="$(( $CURRENT + 1 ))"
} #}}}

check_thread () { #{{{
	SHIFT_TO_DO=0
	for PID in ${PIDS}
	do
		# If the PID is still running, go next
		[ -n "$(/bin/ps -e -o pid |grep "^[ ]*${PID#*:}$")" ] && continue

		# from here, the process is finished, we can restart another
		[ -n "$1" ] && {
			run_thread $1
			shift 1
			SHIFT_TO_DO=$(( $SHIFT_TO_DO + 1 ))
		}

		INDEX="$(( $INDEX + 1 ))"
		CURRENT="$(( $CURRENT - 1 ))"

		RVAL="$(tail -1 ${TMPRVAL}/${PID%:*}.RVAL)"
		[ "$V_WINTERM" = "true" ] && RVAL="$(echo "$RVAL" |awk '{print $1}' |sed 's///')"

		if [ "$RVAL" = "0" ]
			then
				echo "${PID%:*} (${INDEX}/${NBR_ARGS} - $(echo "${INDEX} ${OPER}" |/usr/bin/bc)%) : finished"
				rm -f ${TMPRVAL}/${PID%:*}.RVAL
			else
				mv "${TMPRVAL}/${PID%:*}.RVAL" "${TMPRVAL}/${PID%:*}.${RVAL}.RVAL"
				echo "${PID%:*} (${INDEX}/${NBR_ARGS} - $(echo "${INDEX} ${OPER}" |/usr/bin/bc)%) : ERROR: Rval=$RVAL - take a look at the ${TMPRVAL}/${PID%:*}.${RVAL}.RVAL file"
				SERV_ERR="$SERV_ERR ${PID%:*}:${RVAL}"
		fi

		PIDS="$(echo "${PIDS}" |sed -e "s@\<${PID}\>@@" -e 's@  @ @g')"
	done
} #}}}

set -- $ARGUMENTS

NBR_ARGS=${#}
if [ "$NBR_ARGS" -eq "100" ]
	then
		OPER=""
elif [ "$NBR_ARGS" -lt "100" ]
	then
		OPER="* $(echo "scale=2 ; 100 / ${NBR_ARGS}" |bc -l)"
	else
		OPER="/ $(echo "scale=2 ; ${NBR_ARGS} / 100" |bc -l)"
fi
INDEX=0
CURRENT=0
LOOP=0

echo -- " --> We have ${NBR_ARGS} Args to run"
echo -- " --> LIMIT defined to ${LIMIT}"

while [ : ]
do
	[ "${#}" -ne "0" -a "$CURRENT" -le "$LIMIT" ] && {
		run_thread $1
		shift 1
	}

	NBR_PIDS=$(echo "${PIDS}" |wc -w)
	[ "${NBR_PIDS}" -eq "0" ] && break

	[ "${#}" -eq "0" ] && /usr/bin/perl -e 'select(undef,undef,undef,.1)'
	[ "$CURRENT" -eq "${LIMIT}" ] && /usr/bin/perl -e 'select(undef,undef,undef,.1)'

	[ "${#}" -gt "${LIMIT}" -a "${NBR_PIDS}" -lt "$(echo "${LIMIT} / 2" |/usr/bin/bc)" ] && {
		while [ "${#}" -ne "0" -a "$CURRENT" -lt "$LIMIT" ]
		do
			run_thread $1
			shift 1
		done
	}

	check_thread ${*}

	[ "$SHIFT_TO_DO" -gt "0" ] && shift $SHIFT_TO_DO
done

stop_prg

Download : stop_server.sh

#!/bin/ksh
# ce programme est cense etre lance par le programme multi_remote.sh
#
# codes retour:
# RVAL - 150  -  I didn't received the server name
# RVAL - 200  -  you must modify the nagios downtime end time
# RVAL - 170  -  the first disk sync is failed
# RVAL - 172  -  the second disk sync is failed
# RVAL - 212  -  ping HS

[ -z "$ARGUMENT_TO_WORK" ] && {
	echo "ERROR : the ARGUMENT_TO_WORK variable is not set"
	exit 150
}

/usr/sbin/ping $ARGUMENT_TO_WORK 2 >/dev/null 2>&1
if [ "$?" = "0" ]
	then
		/usr/bin/ssh -q -o PreferredAuthentications=publickey -o StrictHostKeyChecking=no -n ${ARGUMENT_TO_WORK} "PATH=\$PATH:/bin:/sbin:/usr/bin:/usr/sbin
				export PATH
				case \`uname -s\`
				in
					SunOS)	eeprom \"auto-boot?\"=true || exit 4
								sync || exit 170
								sync || exit 172
								init 5 2>&1 || exit 3 ;;
					Linux)	shutdown -h now 2>&1 || exit 3 ;;
					HP-UX)	cd /
								setboot -b on
								/usr/sbin/shutdown -h -y now |while read line
								do
									echo \"\${line}\"
									[ -n \"\$(echo \"x\${line}\" |grep \"xTransition to run-level 0 is complete\")\" ] && exit 0
								done
								;;
					*)	echo \"\`uname -s\` non supporte\"
						exit 1
						;;
				esac
				"
		REMOTE_VAL=$?

		exit $REMOTE_VAL
	else
		echo "ERROR: can't ping $ARGUMENT_TO_WORK"
		exit 212
fi

# ./MULTI_PROC.sh -e './stop_server.sh' -f /tmp/server_liste.txt

# ./MULTI_PROCESS.dev.sh -e './test_ssh_cnx.sh' -f /tmp/list_of_3_servers.txt
--  --> Analysing arguments
--  --> End of analysing arguments
# RVAL - 150  -  I didn't received the server name
# RVAL - 212  -  ping HS

--  --> We have 3 Args to run
--  --> LIMIT defined to 10
machine_1 (1/3 - 33.33%) : ERROR: Rval=212 - take a look at the /var/tmp/machine_1.212.RVAL file
machine_3 (2/3 - 66.66%) : ERROR: Rval=212 - take a look at the /var/tmp/machine_3.212.RVAL file
machine_2 (3/3 - 99.99%) : finished

Errors detected :
machine_1 : ERROR: Rval=212 - look at the /var/tmp/machine_1.212.RVAL file
machine_3 : ERROR: Rval=212 - look at the /var/tmp/machine_3.212.RVAL file
#