##---------------------------------------------------------------------------- ## Script : params.lib ## Module Puppet : gnc-script_core_dtsi ## Auteur : Emmanuel Confrere ## Date : 05-07-2017 ## Version : 2.2.2 ## 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 ! ##---------------------------------------------------------------------------- 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 " 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=`echo ${SH_PROG}|sed "s/\.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 les lignes de l entete du script qui commence par "# ARG:" L_PARAM_ARGS=`grep -E "^# *@ARG:" ${L_PROG}|head -1|sed "s/# *@ARG: *\([^ #]*\).*$/\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` L_VAR=`echo ${L_PARAM_ARGS}|cut -d: -f2` # -- 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 [ -n "${L_DEFARG}" ] && L_PARAM_ARGS_DEF=1 || L_PARAM_ARGS_DEF=0 # -- initialisation de la valeur par defaut [ -n "${L_VAR}" -a -n "${L_DEFARG}" ] && eval ${L_VAR}=\"${L_DEFARG}\" [ -z "${L_VAR}" -a -n "${L_DEFARG}" ] && eval SH_ARGS=\"${L_DEFARG}\" # -- 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]=" La declaration de l option \"${L_OPT_NOM[${L_IDX}]}\" ne comporte pas le nopmbre 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]=" Declaration dupliquee de l option : ${L_OPT_NOM[${L_IDX}]}" L_ERREUR=2 else eval ${L_TMP}=${L_IDX} fi # -- Valeur par defaut pour les parametres non booleen L_VAR=`echo ${L_PARAM}|cut -d: -f3` L_DEFARG=`echo ${L_PARAM}|cut -d: -f5` if [ `echo ${L_PARAM}|cut -d: -f1|grep -c "b"` -eq 0 -a -n "${L_DEFARG}" ] then if [ -z "${L_VAR}" ] then eval SH_ARG_${L_OPT_NOM[${L_IDX}]}=\"${L_DEFARG}\" else eval ${L_VAR}=\"${L_DEFARG}\" fi 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]=" L option ${L_TMP} declaree dans la liste d exclusion de l option ${L_OPT_NOM[${L_IDX}]} est inconnu" 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]=" L option ${L_TMP} declaree dans la liste d inclusion de l option ${L_OPT_NOM[${L_IDX}]} est inconnu" 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 suivante 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 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 suivante 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 argument passe. 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 exclusive" 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 inconnu 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 vrix 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 return 0 } typeset -Ffx fct_params