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
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
|
|
|