IUT/vdn/bin/vdn-scripts.old

#!/usr/bin/env bash 

set -eu
#set -x 

export READ=${READ:-0}
DOC=0
VDN_TRACE=${VDN_TRACE:-0}
EDIT=0
export PAUSE=${PAUSE:-0}
set +u
export FORCE_SEQUENTIAL=${FORCE_SEQUENTIAL:-0}
set -u
export PAUSE_IF_ERROR=0
export VDN_TRACE

synopsis() {
	cat << EOF
Usage : `basename $0` [-h] [-r] [-n] [-d] [-t] script1...
EOF
}

help() {
	cat << EOF

`basename $0` exécute les scripts du réseau.

`synopsis`

-h      : affiche cette aide.
-d	    : n'exécute pas le script mais affiche sa description.
-e      : édite le script.
-n      : pas de pause à l'issue du script.
-t	    : trace l'exécution des commandes effectuées (debug)
-r      : attendre la touche "Entrée" pour terminer
-s      : force l'exécution séquentielle des scripts."
-w      : attendre si erreur


Cette commande, après avoir fixé quelques variables et 
quelques fonctions appelle les scripts du réseau.

Remarque : si la variable d'environnement RUN_PARALLEL est fixée à 1 (cf.
~/.vdnrc) alors si plusieurs scripts sont précisés en arguments ils sont 
exécutés en parallèle (via tmuxinator).

EOF
}

usage() {
	synopsis
	exit 1
}

args() {
	local opt
	while getopts "dehrnpstw" opt; do
		case $opt in
			h) help; exit 0;;
			d) DOC=1;;
			e) EDIT=1;;
			r) READ=1;;
			t) VDN_TRACE=1;;
			n) PAUSE=0;;
			p) PAUSE=1;;
			w) PAUSE_IF_ERROR=1;;
			s) FORCE_SEQUENTIAL=1;;
			?) usage;;
		esac
	done
	shift $(($OPTIND - 1))
	SCRIPTS="$@"
}

realSeq() {
	# in sequential
	#export IN_PARALLEL=0
	
	set +e
	r=0

	local SYSTEMS=$(vdn-list | grep -v '^#')

	runSequential $SCRIPTS || r=$?

	set -e
	
	#if [ $r -ne 0 -a $VDN_SCRIPTS_LEVEL = 1 ]; then
	#		error "$r"
	#
	#fi
	
	#pause

	return $r
}


# main

VDN_PATH=$(readlink -f $(dirname $0)/..); . $VDN_PATH/bin/functions.sh
. $VDN_PATH/bin/functions-scripts.sh

args "$@"

export VDN_PATH

export PATH="$VDN_PATH/bin:$PATH"

export READ

. $VDN_PATH/bin/functions-scripts.sh

cd $NETWORK_DIR/scripts

if [ $DOC = 1 ]; then
	for i in $SCRIPTS; do
		. ./$i
		echo "$i $DESC"
	done
	exit
fi

if [ $EDIT = 1 ]; then
	set +u
	[ -z "$EDITOR" ] && export EDITOR="vi"
	
	set -u
	$EDITOR $SCRIPTS
	exit
fi


[ $VDN_DEBUG = 1 ] && set -x

set +u 
[ -z "$VDN_SCRIPTS_LEVEL" ] && export VDN_SCRIPTS_LEVEL=0 || :
set -u

VDN_SCRIPTS_LEVEL=$((VDN_SCRIPTS_LEVEL+1))


#if [ $VDN_SCRIPTS_LEVEL = 1 ]; then
#	if canRunParallel $SCRIPTS; then
#		nothing=0
#	fi
#fi

#echo "FORCE_SEQ:$FORCE_SEQUENTIAL"
#echo "RUN_PARALLEL=$RUN_PARALLEL"
#sleep 2
#set -x

#set -x

#export IN_PARALLEL=1

#set -x
#set +u
#echo "SCRIPTS:$SCRIPTS DISABLE_SCAN:$DISABLE_SCAN"
#set -u

if [ $VDN_SCRIPTS_LEVEL = 1 ]; then
	#echo "RESET ERRORS"
	errors=0
	success=0
fi

if canRunParallel $SCRIPTS && [ "$FORCE_SEQUENTIAL" = 0 ]; then

	# in parallel
	#echo "Run parallel ($SCRIPTS)."
	export IN_PARALLEL=1
	set +u
	
	set -u
	
	#set -x
	#parallelDisablePause
	if [ $(echo "$SCRIPTS" | wc -w) -gt 1 ]; then
		export IN_PARALLEL=1
		runParallel $SCRIPTS
		r=$?
	else
		#export IN_PARALLEL=1
		#(
		export IN_PARALLEL=0
		#p=$PAUSE
		#export PAUSE=1
		#VDN_SCRIPTS_LEVEL=$((VDN_SCRIPTS_LEVEL+1))
		#set -x
		#[ $VDN_SCRIPTS_LEVEL != 1 ] && export IN_PARALLEL=0 || :
		r=0
		realSeq $SCRIPTS || { r=$?; }
		
		#PAUSE=$p
		#[ $VDN_SCRIPTS_LEVEL = 1 ] && export IN_PARALLEL=1 || :
		#pause
		#)
		
	fi
		
else
	export IN_PARALLEL=0
	#[ $VDN_SCRIPTS_LEVEL == 1 ] && export IN_PARALLEL=0
	#export PAUSE=1
	r=0
	realSeq $SCRIPTS || { r=$?; }
fi

pause

#echo "vdn-script: return : r:$r"

exit $r