L'ensemble des scripts et bibliothèques bash utilisés pour maintenir l'infrastructure du Tetalab. Ce socle Bash est une version légère et adaptée du socle Bash essentiellement développé par Emmanuel Confrère, éminent DBA Calédonien.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 

602 lines
28 KiB

##----------------------------------------------------------------------------
## Script : params.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 26-11-2017
## Version : 3.0.1
## Objet : Gere les options passees a un script
## qui ont ete declare dans l entete de ce dernier
##
## Fonction : fct_param
##
## Detail : Cette fonction est appele par le chargement de init.conf
## Elle analyse traite les parametres passes a la commande en correlation
## avec ceux declares dans l entete du script.
##
## Cette fonction prend en charge les option -h -s, -dbg N, -hist [N], -log [Sid], -cpt [Sid]
## qui n on t pas besoins d etre declare.
##
## -h : Affiche l aide du script
## -s : mode silence (Pas d affichage sur la console)
## -dbg N : Passe mode debug de niveau N
## -hist : Affiche l historique des N dernieres execution (N vaut 1 par defaut)
## -log : Affiche le dernier journal d execution ou celui specifier par le numero de session d'execution
## -cpt : Affiche le dernier compte-rendus ou celui specifier par le numero de session d'execution
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 22-08-2016 - Emmanuel Confrere - Cre : Creation
# 1.0.1 23-08-2016 - Emmanuel Confrere - Ano : Expension des variables imcomptible en version Bash 3.2.25 sur deploiement
# 1.1.0 24-08-2016 - Emmanuel Confrere - Evo : Ajout de la gestion des arguments sans option
# 1.1.1 24-08-2016 - Emmanuel Confrere - Ano : Changement des variable du socle NC_EXPL_ -> NC_EXPL
# 1.1.2 24-08-2016 - Emmanuel Confrere - Ano : libelle des erreurs 11 et 10
# 1.1.3 24-08-2016 - Emmanuel Confrere - Ano : Libelle de l erreur 11 erronee
# 1.1.4 24-08-2016 - Emmanuel Confrere - Evo : Ajout de la diponibilite d un compte rendu
# Ajout de l option par defaut cpt
# 1.1.5 25-08-2016 - Emmanuel Confrere - Ano : Option -hist : ne pas affiche la session en cours
# 2.0.0 29-08-2016 - Emmanuel Confrere - Evo : Les booleen sont desorme traduit par 0 ou 1 (Faux ou Vraix)
# 2.0.1 11-10-2016 - Emmanuel Confrere - Evo : Ajout de commentaire dans le code
# 2.0.2 17-11-2016 - Emmanuel Confrere - Ano : Comportement de la gestion des arguments incoherent.
# 2.1.0 21-11-2016 - Emmanuel Confrere - Evo : Ajout d un controle : Liste de valeurs determinees pour les arguments d une option
# ou pour les arguments du script (valeur separee par une virgule ou un espace)
# 2.1.1 30-03-2017 - Emmanuel Confrere - Ano : Interpretation des arguments par Bash ! Cf. DBA-2455
# 2.2.0 13-04-2017 - Emmanuel Confrere - Evo : Prise en compte de la journalisation du compte d execution dans l historique
# 2.2.1 13-04-2017 - Emmanuel Confrere - Ano : Prise en compte de la journalisation avec l option -log
# Compatibilite ascendente n etait pas assuree.
# 2.2.2 05-07-2017 - Emmanuel Confrere - Ano : Lorsque des option possede une inclusion la librairie entre dans une boucle infinie !
# 3.0.0 26-07-2018 - Emmanuel Confrere - Evo : Changement conceptuel sur la gestion des valeurs par defaut
# Correction de l analyse des arguments declare par "@ARG:", seul la derniere declaration
# est prise en compte.
# Les variables SH_ARGS et SH_ARG_<option> ou leur representant defini dans la declaration
# des option et argument (@ARG: et @OPT:) peuvent etre surcharge dans le fichier de configuration.
# 3.0.1 26-11-2017 - Doug Le Tough - Ano : La construction de L_PARMF ne permet pas de differencier les differentes execution d'un meme script
# 3.1.0 19-02-2018 - Doug Le Tough - Evo : Creation automatique et systematique du repertoire temporaire ${SH_TMPDIR} consitue de ${NC_EXPL_TMP}/${SH_SESSION_ID}
##----------------------------------------------------------------------------
function fct_mk_tmp_dir
{
mkdir -p ${SH_TMP_DIR}
RET_VAL=$?
if [ ! ${RET_VAL} -eq 0 ]; then
fct_message "Erreur lors de la creation du repertoire temporaire" -color rouge
fct_erreur 254
fi
}
function fct_params
{
local L_PROG=${SH_DIR}/${SH_PROG} # Nom absolu du script
local L_IDX=0 # Index de position de l option dans la declaration
local L_IDX2=0 # Index de position de l option dans la declaration
local L_PARAM="" # Ligne de declaration
local L_PARAM_ARGS="" # Ligne de declaration pour un argument sans option
local L_PARAM_ARGS_DEF=0 # Detection d un arguments de script defini par defaut (0=non, 1=oui)
local L_PARAM_ARGS_CTL="" # Liste des valeurs possible pour les arguments du scripts
local L_PARMF="" # Fichier contenant l extraction de la declaration
local L_OPT_OBLIGATOIRE="" # Liste des options obligatoire separees par " "
local L_VAR="" # Nom de la variable contenant les argument
local L_VAL="" # Valeur de l argument
local L_DEFARG="" # Valeur par defaut d un argument
local L_OPTSET=0 # Map binaire des option positionnees
local L_OPTEXCLUDE="" # Map binaire des option mutuellement execlusive
local L_OPTINCLUDE=0 # Tableau de map binaire qui pour chaque option fourni la liste des options inclusive
local L_OPTINC=0 # Map binaire des options pocedant une liste d inclusion
local L_OPTINCONNU="" # Liste des options non reconnu
local L_OPTARGS_CTL="" # Liste des valeurs possible pour les arguments d une option
local L_OPTDEF=0 # detection d une valeur par defaut pour une option (0=non, 1=oui)
local L_NB_MINARG=0 # Nombre d argument obligatoire
local L_NB_MAXARG=0 # Nombre d argument max
local L_NB_ARG=0 # Indexe
local L_OPTMAJ="non" # Option de mise en majuscule des arguments
local L_TMP="" # Variable temporaire a tout faire ;-)
local L_ERREUR=0 # Detection des erreurs
local L_ERREUR_MSG="" # Table de libelle d erreur
local L_OPT_NOM="" # Tableau des option declare
local L_UORI="" # Utilisateur a l origine de la demande d execution du script
local L_UEXE="" # Utilisateur sous lequel s execute le script
# -- Le srcipt doit etre defini, pour lire la declaration des options !!
# -- Il s agit d une securite au cas ou "init.conf" n aurais pas ete sourcee
if [ -z "${L_PROG}" ]
then
fct_message -color rouge "<lib:fct_params> Le nom du script Bash n est pas defini"
fct_erreur 254
fi
# -- Extraction des options de la declaration
# -- ----------------------------------------
# -- Definition d un fichier tempon ( ${L_PARMF} ) pour acceuillir l entete du script contenant la declaration
# -- des options. Comme ce fichier va etre parcouru souvent, on le charge en RAM disque de preference ( sur /dev/shm).
# -- Le nom du fichier tempon sera le nom du script suffixee par ".parms" en lieu et place de ".sh"
L_PARMF="${SH_PROG%*.sh}_${SH_SESSION_ID}.parms"
[ -d /dev/shm ] && L_PARMF="/dev/shm/${L_PARMF}" || L_PARMF="/tmp/${L_PARMF}"
> ${L_PARMF}
# -- Extraction de la declaration des arguments du script et affectation de la valeur par defaut
# -- Il s agit de recuperer la dernier ligne de l entete du script qui commence par "# ARG:"
L_PARAM_ARGS=`grep -E "^# *@ARG:" ${L_PROG}|head -1|sed "s/# *@ARG: *\([^ #]*\).*$/\1/"|tail -1`
if [ -n "${L_PARAM_ARGS}" ]
then
# -- Un arguments a ete declare on initialise la valeur par defaut
L_DEFARG=`echo ${L_PARAM_ARGS}|cut -d: -f4` # Valeur par defaut de l arguments
L_VAR=`echo ${L_PARAM_ARGS}|cut -d: -f2` # Nom de la variable acceuillant la valeur de l argument
L_VAR=${L_VAR:="SH_ARGS"} # Nom par defaut de la variable acceuillant la valeur de l argument
# -- detection d une valeur par defaut pour l argument du script
# -- La variable L_PARAM_ARGS_DEF sera utilise pour ecraser le parametre par defaut si ce dernier a ete soumis au script
if [ -n "${L_DEFARG}" ] && L_PARAM_ARGS_DEF=1 || L_PARAM_ARGS_DEF=0
then
L_PARAM_ARGS_DEF=1
# -- initialisation de la valeur par defaut, si cela n a pas ete effectuer dans le fichier de conf du script
eval ${L_VAR}=\$\{${L_VAR}:=\"${L_DEFARG}\"\}
else
L_PARAM_ARGS_DEF=0
fi
# -- On recupere la liste des valeurs possibles pour les arguments du script
L_PARAM_ARGS_CTL=`echo ${L_PARAM_ARGS}|cut -d: -f5`
fi
# -- Extraction de la declaration des options de l entete du script, et chargement dans le fichier tampon
L_IDX=0
grep -E "^# *@OPT:" ${L_PROG}|sed "s/# *@OPT: *\([^ #]*\).*$/\1/" > ${L_PARMF}
# -- Si aucun parametre n est declare dans l entete du script alors on laise le script gere lui meme les parametres d entree
# -- Cette partie de code est temporaire le temps qe les scripts existant adopte cette librairie. Le probleme c est
# -- que les options par defaut (-h,-s ...) ne seront pas gere pour un scripts qui n a pas d option, pour contourner ce probleme
# -- Il faut declarer une oprion bidon dans l entete du script
# -- On compte le nombre d option declaree :
L_IDX=`wc -l ${L_PARMF}|awk '{print $1}'`
if [ ${L_IDX} -eq 0 ]
then
# Pas d option declaree, on supprime le fichier tempon et on sort
[ -f ${L_PARMF} -a -n "${L_PARMF}" ] && rm -f ${L_PARMF}
return 0
fi
# -- Ajouter a cette liste les options pris en charge par defaut
# -- -h, -s, -dbg, -log et -hist
for L_PARAM in "fb:h::0::::" "fb:s::0::::" "fn:dbg:SH_NIV_DEBUG:1::::" "fb:log:SH_ARG_LOG:0/1::::" "fn:hist:SH_ARG_HIST:0/1:10:::" "fb:cpt:SH_ARG_CPT:0/1::::"
do
echo "${L_PARAM}" >> ${L_PARMF}
done
# -- Initialisation des variables
# -- On parcours la liste des options declarees qui a ete extraite precedement.
# -- Puis on initialise les variables qui servirons de comparaison par la suite
# -- avec les options soumis au script...
L_IDX=0
while read L_PARAM
do
L_OPT_LIGNE[${L_IDX}]=${L_PARAM} # -- Ligne de parametre d une option
L_OPT_NOM[${L_IDX}]=`echo ${L_PARAM}|cut -d: -f2` # -- Nom de l option en cours de taritement
eval SH_OPTION_${L_OPT_NOM[${L_IDX}]}=0 # -- Par defaut on intialise l indicateur d utilisation d une option a faux (0)
# -- On verifie que la declaration comporte bien 7 ou 8 champs
L_TMP=`echo ${L_PARAM}|sed 's/[^:]//g'`
if [ ${#L_TMP} -lt 6 -o ${#L_TMP} -gt 7 ]
then
L_ERREUR_MSG[1]="<lib:fct_params> La declaration de l option \"${L_OPT_NOM[${L_IDX}]}\" ne comporte pas le nombre de champs requis (7 ou 8)"
L_ERREUR=1
else
[ `echo ${L_PARAM}|cut -d: -f1|grep -c "o"` -eq 1 ] && L_OPT_OBLIGATOIRE="${L_OPT_OBLIGATOIRE}${L_OPT_NOM[${L_IDX}]}:${L_IDX} "
# -- On controle que la declarartion est bien unique
L_TMP=L_POS_${L_OPT_NOM[${L_IDX}]}
if [ -n "${!L_TMP}" ]
then
L_ERREUR_MSG[2]="<lib:fct_params> Declaration dupliquee de l option : ${L_OPT_NOM[${L_IDX}]}"
L_ERREUR=2
else
eval ${L_TMP}=${L_IDX}
fi
# -- Affectation de la valeur par defaut pour les parametres non booleen, ayant defini une valeur par defaut
L_DEFARG=`echo ${L_PARAM}|cut -d: -f5` # valeur par defaut
if [ `echo ${L_PARAM}|cut -d: -f1|grep -c "b"` -eq 0 -a -n "${L_DEFARG}" ]
then
L_VAR=`echo ${L_PARAM}|cut -d: -f3` # Nom de la variable acceuillant la valeur de l argument
L_VAR=${L_VAR:="SH_ARG_${L_OPT_NOM[${L_IDX}]}"} # Nom par defaut de la variable acceuillant la valeur de l argument
eval ${L_VAR}=\$\{${L_VAR}:=\"${L_DEFARG}\"\} # Valorisation, si cela n a pas ete effectuer dans le fichier de conf du script
fi
fi
((L_IDX++))
done < ${L_PARMF}
# -- Le fichier tempon ${L_PARMF} n est plus utile
[ -f ${L_PARMF} -a -n "${L_PARMF}" ] && rm -f ${L_PARMF}
# -- Calcul des exclusions et inclusion
# -- ----------------------------------
L_IDX=0
while [ ${L_IDX} -le ${#L_OPT_NOM[*]} ]
do
# -- Option mutuellement exclusive
L_PARAM=`echo ${L_OPT_LIGNE[${L_IDX}]}|cut -d: -f6|sed 's/,/ /g'`
if [ -n "${L_PARAM}" ]
then
# -- Une liste d exclusion a ete defini pour cette option
# -- On contruit un Bitmap listant les options incompatibles
for L_TMP in ${L_PARAM}
do
eval L_IDX2=\${L_POS_${L_TMP}}
if [ -z "${L_IDX2}" ]
then
L_ERREUR_MSG[3]="<lib:fct_params> L option ${L_TMP} declaree dans la liste d exclusion de l option ${L_OPT_NOM[${L_IDX}]} est inconnue"
L_ERREUR=3
else
L_OPTEXCLUDE="${L_OPTEXCLUDE} ${L_OPT_NOM[${L_IDX}]},${L_TMP}:$(( 2 ** ${L_IDX2} + 2 ** ${L_IDX} ))"
fi
done
fi
# -- Option inclusive
L_PARAM=`echo ${L_OPT_LIGNE[${L_IDX}]}|cut -d: -f7|sed 's/,/ /g'`
if [ -n "${L_PARAM}" ]
then
# -- Une liste d inclusion a ete defini pour cette option
# -- On contruit un Bitmap listant les options obligatoire qui doivent etre position avec l option L_IDX
# -- Map des option qui declare une inclusion
L_OPTINC=$(( 2 ** ${L_IDX} + ${L_OPTINC} ))
L_VAL=0
for L_TMP in ${L_PARAM}
do
eval L_IDX2=\${L_POS_${L_TMP}}
if [ -z "${L_IDX2}" ]
then
L_ERREUR_MSG[4]="<lib:fct_params> L option ${L_TMP} declaree dans la liste d inclusion de l option ${L_OPT_NOM[${L_IDX}]} est inconnue"
L_ERREUR=4
else
L_VAL=$(( 2 ** ${L_IDX2} + ${L_VAL} ))
fi
done
L_PARAM=`echo ${L_PARAM}|sed 's/ /,/g'`
L_OPTINCLUDE[${L_IDX}]="${L_PARAM}:${L_VAL}"
fi
(( L_IDX++ ))
done
# -- Analyse des options et argument sousmis au script
# -- -------------------------------------------------
# -- Si une erreur a ete detecte dans les declaration ont ne fait pas l analyse
if (( ! ${L_ERREUR} ))
then
# -- Aucune option sousmise ?
# -- si oui, on verifie l existance d option obligatoire puis on sort...
if [ ${#} -eq 0 -a ${#L_OPT_OBLIGATOIRE} -gt 0 ]
then
L_ERREUR_MSG[5]="Au moins une des options suivantes est requise : `echo ${L_OPT_OBLIGATOIRE}|sed 's/:[0-9]*//g'`"
L_ERREUR=5
fi
# -- Pas d erreur detecte dans la declarartion des options. On peut continuer ...
while [ ${#} -gt 0 ]
do
# -- Des options ont ete utilisees ...
# -- Lecture de la ligne de commande
if [ ${1:0:1} = "-" ]
then
# -- Nous sommes en presence d une option
# -- L option a t elle ete declaree ?
if [ `echo ${L_OPT_NOM[*]}|grep -cw ${1:1}` -eq 0 ]
then
# -- L option n a pas ete declare dans l entete du script
L_OPTINCONNU="${L_OPTINCONNU}${1:1} "
shift
continue
fi
eval L_IDX=\${L_POS_${1:1}}
L_OPTSET=$(( ${L_OPTSET} + 2 ** ${L_IDX} ))
eval SH_OPTION_${L_OPT_NOM[${L_IDX}]}=1
# -- Recuperation des arguments de l option
# -- Nombre d argument pour cette option ?
L_NB_ARG=0
L_NB_MINARG=`echo ${L_OPT_LIGNE[${L_IDX}]}|cut -d: -f4`
if [ `echo ${L_NB_MINARG}|grep -c "/"` -eq 0 ]
then
# -- Seul le nombre max d argument a ete renseigne ( ou pas si L_NB_MINARG est vide )
[ -z "${L_NB_MINARG}" ] && L_NB_MAXARG=-1 || L_NB_MAXARG=$(( ${L_NB_MINARG} - 1 ))
L_NB_MINARG=0
else
# -- le nombre de agument est declare sous la forme "min/max"
L_NB_MAXARG=$(( ${L_NB_MINARG#*/} - 1 ))
# -- Si la forme declare est "nim/" alors L_NB_MAXARG vaut -1
# -- dans ce cas on considere le nombre d argument infini (999999)
(( ! ${L_NB_MAXARG} + 1 )) && L_NB_MAXARG=999999
L_NB_MINARG=${L_NB_MINARG%/*}
fi
# -- Existe t-il une liste de valeurs possible pour les argument de cette option ?
L_OPTARGS_CTL=`echo ${L_OPT_LIGNE[${L_IDX}]}|cut -d: -f8`
# -- Les argument doivent il etre transforme en majuscule ?
[ `echo ${L_OPT_LIGNE[${L_IDX}]}|cut -d: -f1|grep -c "M"` -eq 1 ] && L_OPTMAJ="oui" || L_OPTMAJ="non"
# -- Recuparation du nom de la variable qui va contenir les argument
L_VAR=`echo ${L_OPT_LIGNE[${L_IDX}]}|cut -d: -f3`
[ -z "${L_VAR}" ] && L_VAR="SH_ARG_${L_OPT_NOM[${L_IDX}]}"
# -- Lecture des arguments ...
while [ ${L_NB_ARG} -le ${L_NB_MAXARG} ]
do
[ "${L_OPTMAJ}" = "oui" ] && L_VAL=`echo ${2}|tr a-z A-Z` || L_VAL="$2"
if [ "${L_VAL:0:1}" = "-" -o -z "${L_VAL}" ]
then
# -- Option suivante ou fin de ligne !!
if [ ${L_NB_ARG} -lt ${L_NB_MINARG} ]
then
L_ERREUR_MSG[6]="L option \"${L_OPT_NOM[${L_IDX}]}\" attend ${L_NB_MINARG} argument(s) a minima"
L_ERREUR=6
fi
break
else
# -- Ici on pourrais valider la concordance des types ...
# -- Control de la valeur si une liste de valeurs possible a ete defini pour cette option
if (( ${#L_OPTARGS_CTL} ))
then
# -- Une liste a ete defini, la valeur de l argument courant est-elle presente ?
if (( ! `echo "${L_OPTARGS_CTL}"|grep -cw "${L_VAL}"` ))
then
# -- la valeur n est pas presente dans la liste !!
L_ERREUR_MSG[12]="L argument \"${L_VAL}\" n est pas valide pour l option ${L_OPT_NOM[${L_IDX}]} (Argument attendu : ${L_OPTARGS_CTL})\n"
L_ERREUR=12
fi
fi
# -- Valorisation de la variable d accueil
if [ ${L_NB_MAXARG} -eq 0 ]
then
# -- Un seul argument est attendu
eval ${L_VAR}=\"${L_VAL}\"
else
# -- Plusieurs arguments sont attendu ... On initialise un tableau
eval ${L_VAR}[${L_NB_ARG}]=\"${L_VAL}\"
fi
shift
fi
((L_NB_ARG++))
done
else
# -- Nous somme en presence d un argument
# -- On verifier que l argument a ete declare
if (( ${#L_PARAM_ARGS} ))
then
# -- Nom de la variable d acceuille des arguments
L_VAR=`echo ${L_PARAM_ARGS}|cut -d: -f2`
[ -z "${L_VAR}" ] && L_VAR="SH_ARGS"
# -- Les argument doivent il etre transforme en majuscule ?
[ `echo ${L_PARAM_ARGS}|cut -d: -f1|grep -c "M"` -eq 1 ] && L_VAL=`echo ${1}|tr a-z A-Z` || L_VAL=$1
# -- la valeur de l argument est-elle presente dans la liste des valeurs possible (si cette liste a ete defini)
if (( ${#L_PARAM_ARGS_CTL} ))
then
if (( ! `echo "${L_PARAM_ARGS_CTL}"|grep -cw "${L_VAL}"` ))
then
# -- la valeur n est pas presente dans la liste !!
L_ERREUR_MSG[12]="L argument \"${L_VAL}\" n est pas valide pour ce script (Argument attendu : ${L_PARAM_ARGS_CTL})\n"
L_ERREUR=12
fi
fi
# -- Initialisation de la variable d acceuille en fonction de la taille courante du tableau
# -- Taille courante du tableau accueillant les arguments moins l arguments par defaut ( On ecrase l argument positionne par defaut )
eval L_NB_ARG=\$\(\( \${#${L_VAR}[*]} - ${L_PARAM_ARGS_DEF} \)\)
(( ${L_PARAM_ARGS_DEF} )) && (( L_PARAM_ARGS_DEF-- ))
# -- Si pas encore initialise alors la taille est 0
(( ${L_NB_ARG} )) && eval ${L_VAR}[${L_NB_ARG}]=${L_VAL} || eval ${L_VAR}=${L_VAL}
else
# -- Pas de declaration !!
(( ! ${#L_ERREUR_MSG[11]} )) && L_ERREUR_MSG[11]="L argument suivant a ete dectecte sans declaration : "
L_ERREUR_MSG[11]="${L_ERREUR_MSG[11]}\"${1}\" "
L_ERREUR=11
fi
fi
shift
done
fi
# -- Controle des options et arguments obligatoires
# -- ----------------------------------------------
if (( ! ${L_ERREUR} ))
then
# -- Option obligatoire ...
for L_TMP in ${L_OPT_OBLIGATOIRE}
do
if [ $(( ${L_OPTSET} & 2**${L_TMP#*:} )) -eq 0 ]
then
# -- L option obligatoire L_TMP n a pas ete positionnee
# -- On controle que cette option n est pas une exclusion d une option obligatoire positionnee
L_PARAM=`echo ${L_OPT_LIGNE[${L_TMP#*:}]}|cut -d: -f6|sed 's/,/ /g'`
L_VAR=0
if [ -n "${L_PARAM}" ]
then
# -- L option L_TMP pocede une liste d exclusion
for L_IDX2 in ${L_PARAM}
do
eval L_IDX=\${L_POS_${L_IDX2}}
(( !${L_VAR} )) && L_VAR=$(( ${L_OPTSET} & 2**${L_IDX} ))
done
fi
# -- Si L_VAR est null alors l option L_TMP aurais du etre positionnee
if [ ${L_VAR} -eq 0 ]
then
[ -z "${L_ERREUR_MSG[7]}" ] && L_ERREUR_MSG[7]="Les options suivantes sont requises : "
L_ERREUR_MSG[7]="${L_ERREUR_MSG[7]}${L_TMP%:*} "
L_ERREUR=7
fi
fi
done
# -- Arguments declare ? ...
if (( ${#L_PARAM_ARGS} ))
then
# -- Nom de la variable d acceuille des arguments
L_VAR=`echo ${L_PARAM_ARGS}|cut -d: -f2`
[ -z "${L_VAR}" ] && L_VAR="SH_ARGS"
# -- Nombre d argument attendu ...
L_NB_MAXARG=`echo ${L_PARAM_ARGS}|cut -d: -f3`
# -- Si le nombres d argument n est pas defini alors par defaut on considere qu il peut etre infini
[ -z "${L_NB_MAXARG}" ] && L_NB_MAXARG=999999
if [ `echo ${L_NB_MAXARG}|grep -c "/"` -eq 0 ]
then
# -- On n a pas trouve le separateur "/" donc pas de minima defini
# -- l argument est il obligatoire ?
L_TMP=`echo ${L_PARAM_ARGS}|cut -d: -f1|grep -c "o"`
(( ${L_TMP} )) && L_NB_MINARG=1 || L_NB_MINARG=0
else
L_NB_MINARG=${L_NB_MAXARG%/*}
L_NB_MAXARG=${L_NB_MAXARG#*/}
# -- Si L_NB_MAXARG n est pas defini alors on considere qu il peut etre infini
[ -z "${L_NB_MAXARG}" ] && L_NB_MAXARG=999999
fi
[ ${L_NB_MAXARG} -lt 1 ] && L_NB_MAXARG=1
# -- Nombre d argument soumis ... ( Taille du tableau d arguments )
eval L_NB_ARG=\${#${L_VAR}[*]}
if [ ${L_NB_ARG} -lt ${L_NB_MINARG} ]
then
L_ERREUR_MSG[13]="Le script ${SH_PROG} attend a minima ${L_NB_MINARG} argument(s)"
L_ERREUR=13
fi
if [ ${L_NB_ARG} -gt ${L_NB_MAXARG} ]
then
L_ERREUR_MSG[14]="Trop d arguments passes. Le script ${SH_PROG} attend au maximun ${L_NB_MAXARG} argument(s)"
L_ERREUR=14
fi
fi
fi
# -- Controle des exclusion
# -- ----------------------
for L_TMP in ${L_OPTEXCLUDE}
do
if [ $(( ${L_OPTSET} & ${L_TMP#*:} )) -eq ${L_TMP#*:} ]
then
L_ERREUR_MSG[8]="Les options ${L_TMP%:*} sont mutuellement exclusives"
L_ERREUR=8
(( L_ERREUR_NB++ ))
fi
done
# -- Controle des inclusion
# -- ----------------------
if [ $(( ${L_OPTSET} & ${L_OPTINC} )) -ne 0 ]
then
# -- Une option exigeant une inclusion a ete positionne
L_IDX=0
while [ ${L_IDX} -le ${#L_OPT_NOM[*]} ]
do
if [ $(( (2 ** ${L_IDX}) & ${L_OPTSET} & ${L_OPTINC} )) -ne 0 ]
then
# -- L option L_IDX a ete positionne est pocedent une liste d inclusion
if [ $(( ${L_OPTSET} & ${L_OPTINCLUDE[${L_IDX}]#*:} )) -ne ${L_OPTINCLUDE[${L_IDX}]#*:} ]
then
L_ERREUR_MSG[9]="L option ${L_OPT_NOM[${L_IDX}]} exige l usage de(s) (l) option(s) ${L_OPTINCLUDE[${L_IDX}]%:*}"
L_ERREUR=9
fi
fi
(( L_IDX++ ))
done
fi
# -- Controle des option inconnu
# -- ---------------------------
if [ -n "${L_OPTINCONNU}" ]
then
L_ERREUR_MSG[10]="Option inconnue(s) detectee(s) : ${L_OPTINCONNU}"
L_ERREUR=10
fi
# -- Nettoyage
# -- ---------
# -- Suppression des variables tempon
for L_PARAM in ${L_OPT_NOM[*]}
do
eval unset L_POS_${L_PARAM}
done
# -- Gestion des options par defaut : -h -log -hist -s, -cpt et -dbg
# -- ---------------------------------------------------------------
# -- L option dbg n a pas de traitement particulier elle n apparaitras donc pas ci-dessous.
# -- Creation d un masque binaire pour determiner les options positionnee
L_VAL="${SH_OPTION_h}${SH_OPTION_log}${SH_OPTION_hist}${SH_OPTION_s}${SH_OPTION_cpt}"
if [ ${L_VAL} -ne 0 ]
then
if (( 2#${L_VAL} & 2#00010 )) # -- Comparaison binaire bit a bit vrai si l option -s est positionnee
then
# -- Option s
SH_SILENCE="oui"
fi
# -- Une option gere par defaut a ete positionnee
if (( 2#${L_VAL} & 2#10000 ))
then
# -- Option h : affichage de l aide
fct_usage "${SH_DIR}/${SH_PROG}"
fct_erreur 0
fi
if (( 2#${L_VAL} & 2#01000 ))
then
# -- Option log
# -- Recherche du dernier journal
[ -z "${SH_ARG_LOG}" ] && SH_ARG_LOG=`tail -4 ${SH_FICTRC}|grep "fin"|cut -d: -f6|sed 's/(//;s/)//;s/ *//g'`
L_VAR=`ls ${NC_EXPL_LOG}|grep -c ${SH_ARG_LOG}`
if (( ${L_VAR} ))
then
view ${NC_EXPL_LOG}/*${SH_ARG_LOG}*
else
fct_message -color rouge "Le journal d execution de la session ${SH_ARG_LOG} du script ${SH_PROG} n existe plus"
fi
fct_erreur 0
fi
if (( 2#${L_VAL} & 2#00001 ))
then
# -- Option cpt
# -- Recherche du dernier compte-rendu
[ -z "${SH_ARG_CPT}" ] && SH_ARG_CPT=`tail -4 ${SH_FICTRC}|grep "fin"|cut -d: -f4|sed 's/(//;s/)//;s/ *//g'`
L_VAR=`ls ${NC_EXPL_CPT}|grep -c ${SH_ARG_CPT}`
if (( ${L_VAR} ))
then
view ${NC_EXPL_CPT}/*${SH_ARG_CPT}*
else
fct_message -color rouge "Le compte-rendu de la session ${SH_ARG_CPT} du script ${SH_PROG} n existe plus"
fi
fct_erreur 0
fi
if (( 2#${L_VAL} & 2#00100 ))
then
# -- Option hist
fct_affiche_ligne entete "Historique des ${SH_ARG_HIST} dernieres executions du script ${SH_PROG}" "Date,18" "Utilisateur(Origine,20:Exec,20)" "Session,16" "Log,3" "Cpt,3" "Code,5" "Parametre,50"
SH_ARG_HIST=$(( ${SH_ARG_HIST} * 3 ))
tail -${SH_ARG_HIST} ${SH_FICTRC}|grep "Parametre" | while read L_VAL
do
G_TMP=`echo ${L_VAL}|sed 's/ Parametre .*$/:/;s/[^:]//g'` # Pour assurer la compatibilite ascendante
G_TMP=$(( 7 - ${#G_TMP} )) # Nombre de champs 6 ou 8 ?
L_PARAM=`echo ${L_VAL}|cut -d: -f$(( 8 - ${G_TMP} ))-`
(( ${G_TMP} )) && L_UORI='' || L_UORI=`echo ${L_VAL}|cut -d: -f4`
(( ${G_TMP} )) && L_UEXE='' || L_UEXE=`echo ${L_VAL}|cut -d: -f5`
L_IDX=`echo ${L_VAL}|cut -d: -f$(( 6 - ${G_TMP}))|sed 's/(//;s/)//'`
L_IDX2=`echo ${L_VAL}|cut -d: -f$1-3`
L_VAR=`ls ${NC_EXPL_LOG}|grep -c ${L_IDX}`
L_PARMF=`ls ${NC_EXPL_CPT}|grep -c ${L_IDX}`
(( ${L_VAR} )) && L_VAR="X" || L_VAR=""
(( ${L_PARMF} )) && L_PARMF="X" || L_PARMF=""
L_TMP=`grep ${L_IDX} ${SH_FICTRC}|grep "fin"|cut -d- -f2`
# -- Si L_TMP est vide, alors il s agit de la session en cours, on n affiche pas le resultat !
[ -n "${L_TMP}" ] && fct_affiche_ligne "${L_IDX2}" "${L_UORI}" "${L_UEXE}" "${L_IDX}" "${L_VAR}" "${L_PARMF}" "${L_TMP}" "${L_PARAM}"
done
fct_affiche_ligne pied
fct_erreur 0
fct_erreur 0
fi
fi
# -- Sortie
# -- ------
if (( ${L_ERREUR} ))
then
L_IDX=14
while (( ${L_IDX} ))
do
[ -n "${L_ERREUR_MSG[${L_IDX}]}" ] && fct_message -color rouge "${L_ERREUR_MSG[${L_IDX}]}"
(( L_IDX-- ))
done
fct_erreur 254
fi
fct_mk_tmp_dir
return 0
}
typeset -Ffx fct_params