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.

47 KiB

Aide memoire pour l'écriture de scripts avec le socle bash

  • Sommaire
    • I - Arborescence du socle
    • II - Variables d'environement
      • 1 - Variables globales
      • 2 - Variables de session
    • III - Utilisation du socle bash
      • 1 - Cartouche
        • 1.1 Élements du cartouche
        • 1.2 Versionnement sémantique
          • 1.2.1 Usage
          • 1.2.2 Format
          • 1.2.3 Sémantique
      • 2 - Initialisation du socle
      • 3 - Structure d'un script
      • 4 - Actions realisées au lancement d'un script
    • IV - Nomenclature
      • 1 - Fichiers temporaires
      • 2 - Nom des exécutables
    • V - Description et usage des bibliothèques
      • 1 - fct_message
      • 2 - fct_affiche_ligne
      • 3 - fct_erreur
      • 4 - fct_unique_exec
      • 5 - fct_libere_exec
      • 6 - fct_usage
      • 7 - fct_rotation
      • 8 - fctpath
      • 9 - fct_params

I - Arborescence du socle

La racine des dossiers utilisée par le Socle Bash est définie par la variable d'environement NC_EXPL_ROOT. Cette dernière est initialisée à la connexion par l'appel au script /etc/profile.d/tetalab.sh Cette arborescence est utilisée pour tous scripts Bash ainsi que les variables d'environement qui en découlent.

Sous l'arborescence ${NC_EXPL_ROOT} on trouve les dossiers suivants :

+-----------------+-----------------------------------------------------------------------------------------------+
| Dossier         |                                   Description                                                 |
+-----------------+-----------------------------------------------------------------------------------------------+
|  {Racine}/bin   | Contient les binaires (scripts Bash)                                                          |
|  {Racine}/conf  | Contient les fichiers de configuration des scripts, ainsi que du socle                        |
|  {Racine}/cpt   | Contient les fichiers de comtpe-rendus génerés par les script (purge auto, 8 jours par défaut)|
|  {Racine}/dat   | Contient les fichiers de données gérés par les scripts                                        |
|  {Racine}/hist  | Contient l'historique d'exécution des scripts (pas de purge)                                  |
|  {Racine}/lib   | Contient les bibliothèques chargées par le socle                                              |
|  {Racine}/log   | Contient les fichiers de logs d exécution des scripts (purge auto , 8 jours par défaut )      |
|  {Racine}/man   | Contient les fichiers d'aide des scripts pour l'utilitaire "man"                              |
|  {Racine}/mod   | Contient les fichiers modèles (templates) à usage des scripts                                 |
|  {Racine}/msg   | Contient les fichiers de messages des scripts utilisés par la bibliothèque "fct_erreur"       |
|  {Racine}/tmp   | Contient les fichiers temporaires des scripts                                                 |
+-----------------+-----------------------------------------------------------------------------------------------+

Note : Sous chaque dossier vous trouverez un fichier texte lisezmoi.txt decrivant l'usage du répertoire.

II - Variables d'environement

Le socle utilise deux groupes de variables. Le premier dit "global" le second "de session". Sauf si explicite, les variables globales sont définies et exportées à la connexion. Elles sont donc utilisables par tous les scripts, mais elles ne sont pas modifiables.

Les variables de session sont définies à l'execution d'un script et lui sont propres. Cependent certaines d'entre elles sont transmises aux scripts enfants:

  • SH_SESSION_ID, SH_FICLOG, SH_FICCPT, SH_RETENTION_CPT, SH_RETENTION_LOG, SH_NIV_DEBUG, SH_SILENCE, SH_AFF_SID

Les variables de session sont modifiable à 2 niveaux. De facon global dans le fichier "init.conf" ou pour un script particulier dans le fichier ${NC_EXPL_CFG}/<Nom_du_script>.conf.

La valeur définie dans "init.conf" sera utlisée sauf si elle a été surchargée dans le fichier de configuration du script.

Il y a cependant une spécificite pour SH_RETENTION_CPT et SH_RETENTION_LOG:

  • ces variables sont definies une et une seule fois lors de la première initialisation. Ce qui signinfie qu'un script qui aurait surchargé ces variables, ignorera l'initialisation de ces variable si il est appelé par un autre script.

1 - Variables globales générales

+-------------------+----------------------------+
| Nom               | Usage                      |
+-------------------+----------------------------+
| NC_EXPL_ROOT      | Racine      /opt/expl      |
| EXPL_ROOT         | Alias pour NC_EXPL_ROOT    |
| NC_EXPL_BIN       | Pointe vers {Racine}/bin   |
| NC_EXPL_CFG       | Pointe vers {Racine}/conf  |
| NC_EXPL_CPT       | Pointe vers {Racine}/cpt   |
| NC_EXPL_DAT       | Pointe vers {Racine}/dat   |
| NC_EXPL_HST       | Pointe vers {Racine}/hist  |
| NC_EXPL_LIB       | Pointe vers {Racine}/lib   |
| NC_EXPL_LOG       | Pointe vers {Racine}/log   |
| NC_EXPL_MAN       | Pointe vers {Racine}/man   |
| NC_EXPL_MOD       | Pointe vers {Racine}/mod   |
| NC_EXPL_MSG       | Pointe vers {Racine}/msg   |
| NC_EXPL_TMP       | Pointe vers {Racine}/tmp   |
| RUBYLIB           | vaut ${NC_EXPL_LIB}        |
| NC_EXPL_SRVBATCH  | Nom du serveur Batch       |
+-------------------+----------------------------+

Les variables NC_EXPL_ROOT, EXPL_ROOT et NC_EXPL_SRVBATCH sont définies dans le fichier "tetalab.sh" Les autres variables NC_* sont définies dans le fichier "profile_init.env"

2 - Variables de session

Cette liste n'est pas exhaustive, seules les principales variables sont citées.

+--------------------+-------------------------------------------------------------------------------+
| Nom                | Usage                                                                         |
+--------------------+-------------------------------------------------------------------------------+
| SH_SESSION_ID      | Numero unique d'exécution : <TimeStamp>_<PID>                                 |
| SH_SILENCE         | Active ou non l'affichage des messages via fct_message. Par defaut vaut "non" |
| SH_PROG            | Nom du script                                                                 |
| SH_LOGUSER         | Compte initial de connexion au serveur                                        |
| SH_EXECUSER        | Compte courant exécutant le script                                            |
| SH_DIR             | Dossier hébergeant le script                                                  |
| SH_PROG_VERSION    | Version du script                                                             |
| SH_FICTRC          | Pointe vers le fichier ${NC_EXPL_HST}/<Nom_du_script>.hist                    |
| SH_FICMSG          | Pointe vers le fichier ${NC_EXPL_MSG}/<Nom_du_script>.msg                     |
| SH_FICCFG          | Pointe vers le fichier ${NC_EXPL_CFG}/<Nom_du_script>.conf                    |
| SH_FICSEM          | Pointe vers le fichier /dev/shm/<Nom_du_script>.sem                           |
| SH_FICLOG          | Pointe vers le fichier ${NC_EXPL_LOG}/<Nom_du_script>.log                     |
| SH_FICCPT          | Pointe vers le fichier ${NC_EXPL_CPT}/<Nom_du_script>.cpt                     |
| SH_NIV_DEBUG       | Vaut 0 par défaut. Niveau d'affichage dans les fichiers de traces             |
| SH_RETENTION_CPT   | Vaut 8 par défaut. Duree de rétention en jours des fichiers de compte-rendus  |
| SH_RETENTION_LOG   | Vaut 8 par défaut. Duree de rétention en jours des fichiers de traces         |
+--------------------+-------------------------------------------------------------------------------+

Remarque : Les variables SH_SILENCE et SH_NIV_DEBUG sont controlées par les options "-s" et "-dbg" si la gestion des options a été activée.

III - Utilisation du socle bash

Cette partie decrit sommairmement les quelques regles d usage pour ecrire un script Bash sous le socle DTSI Ceci ne concerne pas les script Ruby qui ne sont pas pris en charge par le socle decrit ici.

1 - Cartouche

Les scripts doivent commencer par le cartouche ci-dessous :

+----------------------------------------------------------------------------------------------------+
|                                                                                                    |
|       #!/bin/bash                                                                                  |
|       ##----------------------------------------------------------------------------               |
|       ## Script         : <Nom_du_script>                                                          |
|       ## Module Puppet  : <Nom_du_module_hebergeant_le_script>                                     |
|       ## Auteur         : <Auteur ayant cree le script>                                            |
|       ## Date           : <Derniere_date_d_actualisation_au_format_JJ-MM-AAAA>                     |
|       ## Version        : <Version>                                                                |
|       ## Objet          : <Resume de la fonction>                                                  |
|       ##                                                                                           |
|       # ----------------------------------------------------------------------------               |
|       # Mise a jour :                                                                              |
|       # <Version>  <Date>   - <Auteur>           - <Action> : <Description>                        |
|       # 0.0.1  08-06-2016   - Toto Laricot       - Cre : Creation                                  |
|       # 0.0.2  08-09-2016   - Titi Alapeti       - Ano : Ce truc est faux                          |
|       # ----------------------------------------------------------------------------               |
|       # Dependance :                                                                               |
|       # @DEP: <Nom_du_script>:<Version[-|+]>                                                       |
|       # ----------------------------------------------------------------------------               |
|       # Liste des options et arguments                                                             |
|       # @OPT: <type>:<nom>:<var>:<nb_arg>:<def_val>:<OptE>:<OptI>:<ctl_val>  # <Commentaire>       |
|       # @OPT: <type>:...                                                     # <Commentaire>       |
|       # @ARG: <type>:<var>:<nb_arg>:<def_val>:<ctl_val>                      # <Commentaire>       |
|       ##----------------------------------------------------------------------------               |
|       ##                                                                                           |
|       ## Syntaxes :                                                                                |
|       ## --------                                                                                  |
|       ##                                                                                           |
|       ##     prompt> <Nom_du_script> <Liste_des_arguments_et_options>                              |
|       ##                                                                                           |
|       ##             <Opt1> : <Description>                                                        |
|       ##                                                                                           |
|       ## Fonctionnement :                                                                          |
|       ## --------------                                                                            |
|       ##                                                                                           |
|       ##     <Que fait le script dans les details et comment ca marche......>                      |
|       ##                                                                                           |
|       ##----------------------------------------------------------------------------               |
|       .                                                                                            |
|       .                                                                                            |
|       .                                                                                            |
|                                                                                                    |
+----------------------------------------------------------------------------------------------------+

Note : Les lignes commençant par 2 "#" sont utilisees pour generer l'aide, leur maintient est donc nécéssaire pour garantir la fiabilité de l'information. Ce sont ces lignes, qui sont lues lors de l'utilisation de l'option par defaut "-h".

1.1 Elements du cartouche

1.1.1 Meta-données

: peut prendre les valeurs suivantes -> cre, ano, evo, typo

  • cre : Création du script.
  • evo : Évolution du script -> Ajout de nouvelles fonctionnalités, Amélioration du code.
  • ano : Correction du code suite à un comportement inattendu.
  • typo : Ajout de commentaires, de texte ou corrections gramaticales sans influence sur le code.

:

: Format x.y.z Pour le suivi des versions on utilisera le versionnement sémantique (voir paragraphe III-1.2).

1.1.2 Paragraphe

  • Mise a jour : Ce paragraphe est utilisé pour suivre l'evolution des versions. La dernière version en vigueur doit être reportée dans le premier paragraphe.

  • Dependance : Permêt de définir la liste ainsi que la version des scripts qui sont appelés. Dans le cas d'un changement cela permêt de connaître les scripts qui sont impactés. Pour le moment aucun script n'exploite cette méta-donnée qui est presente pour un future usage.

  • Liste des options : La déclaration des options n'est pas obligatoire.

Si aucune déclaration n'est présente alors la bibliothèque params.lib ne fait aucune action. Dans ce cas les options par défaut -h, -log, -hist, -cpt, -s et -dbg ne seront pas disponible.

Si le script ne nécessite pas d'option mais que l'on souhaite disposer des options par défaut, il faudra déclarer une option bidon. ex: "# @OPT: f:bidon::::::"

Si la déclaration existe alors le socle gèrera les paramètres en entrée du script, ainsi que les options par défaut -h, -log, -hist, -cpt, -s et -dbg. Ces mots clé sont reservés et ne peuvent pas être utilisé par le script.

La déclaration est réalisée dans le paragraphe "Liste des options et arguments". Chaque option est identifiée par l'entête de ligne "# @OPT:" suivi de la description.

La description consiste en une liste de paramètres séparés par ":" :::<nb_arg>:<def_val>:::<ctl_val>

L'ordre des paramètre est figé et tous doivent etre présents.

8 champs sont obligatoires, soit 7 caracteres ":" (on ne compte pas le caracatere ":" suivant @OPT). Exemple de déclaration valide : # @OPT: fb:h::0::: # @OPT: fb:s::0::: # @OPT: f:dbg:SH_NIV_DEBUG:0/1::: # @OPT: fb:log::0::: # @OPT: f:hist:SH_ARG_HIST:0/1:10:: # @OPT: oM:i:G_INSTANCE:1/1:ALL:dbid: # @OPT: oM:pr:G_PR_NOM:1/1:sq,t,l:

  • : Propriété de l'attribu défini par l'aggrégation des lettres suivantes:

    • f -> Option falcultative
    • b -> Booléen
    • o -> Option obligatoire
    • M -> Argument transformé en majuscule
  • : nom de l'option (sans le tiret). Attention le nom de l'option est sensible à la casse.

  • : nom de la variable dans laquelle sera stockée le(s) argument(s) si plusieurs arguments alors un tableau sera initialisé <var[n]> L'index [n] commence à zero. Le nombre d'arguments éffectivement passés a la commande est "${#[]}". La valeur max de l'index [n] est "${#[]} - 1".

  • <nb_arg> : nombre d'arguments attendus de la forme "min/max", "min/", "max" ou "" si vide ou "0" alors l'option est booléene. la forme "min/" considere le nombre max non determiné (infini)

  • <def_val> : Valeur par défaut assignée à Fonctionne si <nb_arg> vaut 0/1 1/1

  • : Liste des options mutellement exclusives séparées par une virgule.

  • : Liste des options inclusives séparées par une virgule.

Lors de l'initialisation les marqueurs "@OPT" sont lues et analysées. Le résultat est comparé aux arguments et options sousmis au script et les variables suivantes son initialisées ...

  • SH_OPTION_ : Initialisée à "1" (Vrai) ou "0" (Faux) selon que l'option est respectivement utilisée ou non. Il existe toujours une variable par option déclarée. Ceci concerne aussi les options par défaut géré par la bibliothèque params.lib

  • SH_ARG_ : Cette variable existe uniquement si le champ est null et si le type n'est pas booleen. Par défaut elle est initialisée à null ou avec la valeur <def_val> Si le champ est renseigné, alors SH_ARG_ est remplacée pas . Si l'option associée peut prendre plusieurs arguments, alors les variables SH_ARG_ ou sont des tableaux dont l'index commence a zéro. La taille du tableau peut etre récuperée via ${#SH_ARG_[*]} ou ${#[*]}.

Les option -h, -s, -log [id], -hist [N] et -dbg N sont prises en charge automatiquement. Ces noms sont donc reservées.

Les options par défaut réalisent les actions suivantes :

-h        : Affiche l aide du script (Ligne du cartouche qui commence par "##")
-s        : Mode silence. Plus d'affichage sur le terminal. 
            Initialise la variable SH_SILENCE a "oui"
-log [id] : Affiche le dernier journal ou le journal "id" (identifiant de session d'execution).
-cpt [id] : Affiche le dernier compte-rendu ou le Compte-rendu "id" (identifiant de session d'execution).
-hist [N] : Affiche l historique des "N" dernieres executions (N=10 par dafaut)
-dbg N    : Activation du mode debug au niveau "N". Active les messages geres par la librairie fct_message
            dont l'option -debug est utilisee.
  • Arguments : La declaration des argument du script n est pas obligatoire

            Attention : Si aucune option "@OPT:" n est declaree alors il n y auras pas de prise en charge des arguments.
                        Si votre script ne necessite pas d option, mais qu il presente des arguments, alors il faudras declarer
                        une option bidon :"# @OPT: f:bidon::::::"
    
            La declaration est realise dans le paragraphe "Liste des options et arguments".
            Elle est identifiee par l entete de ligne "# @ARG:" suivi de la description.
            Il ne peut y avoir qu une ligne de description pour les arguments.
            (Si plusieurs lignes avec le marqueur @ARG existe, alors seul la premiere et prise en compte)
    
            La description consiste en une liste de parametres separes par ":"
                    <type>:<var>:<nb_arg>:<def_val>:<ctl_val>
    
            L ordre des parametres est fige et tous doivent etre presents.
    
            <type>   : Propriete de l attribu defini par l agregation des lettres suivantes
                       f    -> Argument falcultative
                       o    -> Argument obligatoire
                       M    -> Argument transforme en majuscule
    
            <var>    : nom de la variable dans laquelle sera stockee le(s) argument(s)
                       si plusieurs arguments alors un tableau sera initialise <var[n]>
                       L index [n] commence a zero. 
                       Le nombre d arguments effectivement passes a la commande est "${#<var>[*]}".
                       L valeur max de l index [n] est "${#<var>[*]} - 1".
    
                       Si <var> n est pas renseigne alors la variable SH_ARGS[] est initialisee
    
            <nb_arg> : nombre d arguments attendus de la forme "min/max", "min/", "max" ou "".
                       si vide alors on considere que le nombre d arguments est a minima de 1.
                       la forme "min/" considere le nombre est a minima de "min".
    
            <def_val>: Valeur par defaut assignee a <var>
                       Fonctionne si <nb_arg> vaut 0/1 1/1
    

ATTENTION Si le caractere "&" est present dans la valeur d un argument, alors cette valeur doit etre encadree par une simple cote et le caractere "&" doit etre proteger par un anti-slash "".

Le cas echeans le shell generera un fils qui tentera l execution d'un script portant le nom de la valeur de l argument.

1.2 Versionnement semantique 1.2.1 Usage L idee de l utilisation du versionnement semantique est de definir clairement les intentions d un changement dans un code pour les clients de ce dernier. Ceci permet de fiabiliser la mise en place de dependances et de determiner les impacts d un changement.

1.2.2 Format
      Le format utilise est le suivant x.y.z
      x est l identifiant de version majeure.
      y est l identifiant de version mineure.
      z est l identifiant de version de correction.
    
1.2.3 Semantique
      - Version majeure X : Il vaut "0" lors du developpement, le script est considere non valide et ne 
                            devrait pas etre appele par d autre script. Une fois le script valide la version 
                            doit etre 1.0.0 (premiere version stable).
                            Il doit etre incremente si des changements dans le code n assure plus la compatibilite
                            ascendante. Les identifiants de version mineure et de correction doivent etre remis 
                            a zero quand l identifiant de version majeure est incremente.

      - Version mineur y : Doit etre incremente lors de l ajout de nouvelle fonctionnalite ou d amelioration
                           du code qui n on t pas d impact sur la compatibilite ascendante. L identifiant de 
                           version de correction doit être remis a zero lorsque l identifiant de version mineure
                           est incremente.

      - Version de correction z : Doit être incremente si seules des corrections retro-compatibles sont introduites. 
                                  Une correction est definie comme un changement interne qui corrige un comportement incorrect.
                                  Il peut etre incremente lors de correction typographique ou grammaticale.


  2 - Initialisation du socle.
      Par defaut les librairies du socle sont chargees a la connexion. Mais pour qu elles puissent etre operationnelles
      il faut initialiser les variables de session.
      Ceci est realise en sourcant le fichier "${NC_EXPL_CFG}/init.conf" au debut du script :

      Rem : L analyse des options et arguments est aussi realise par "${NC_EXPL_CFG}/init.conf".

      +----------------------------------------------------------------------------------------------------+
      |                                                                                                    |
      |       #!/bin/bash                                                                                  |
      |       ##----------------------------------------------------------------------------               |
      |       .                                                                                            |
      |                                   <CARTOUCHE>                                                      |
      |       .                                                                                            |
      |       ##----------------------------------------------------------------------------               |
      |       #-----------------------------------------------------------------------------               |
      |       #                 Initialisation de l environement                                           |
      |       #-----------------------------------------------------------------------------               |
      |       if [ ! -f ${NC_EXPL_CFG}/init.conf ]                                                         |
      |       then                                                                                         |
      |           echo "Fichier d initialisation du socle \${NC_EXPL_CFG}/init.conf n existe pas !"        |
      |           echo "Arret du script par securite"                                                      |
      |           exit 250                                                                                 |
      |       else                                                                                         |
      |           . ${NC_EXPL_CFG}/init.conf                                                               |
      |       fi                                                                                           |
      |       .                                                                                            |
      |       .                                                                                            |
      |                                                                                                    |
      +----------------------------------------------------------------------------------------------------+

  3 - Structure d un script
      Voici les elements qui devraient etre present a minima dans les script Bash. Ceci est recommande pour
      assurer une homogeneite dans l ensemble du socle.

      +----------------------------------------------------------------------------------------------------+
      |                                                                                                    |
      |       #!/bin/bash                                                                                  |
      |       ##----------------------------------------------------------------------------               |
      |       .                                                                                            |
      |                                   <CARTOUCHE>                                                      |
      |       .                                                                                            |
      |       ##----------------------------------------------------------------------------               |
      |       #-----------------------------------------------------------------------------               |
      |       #                 Initialisation de l environement                                           |
      |       #-----------------------------------------------------------------------------               |
      |       if [ ! -f ${NC_EXPL_CFG}/init.conf ]                                                         |
      |       then                                                                                         |
      |           echo "Fichier d initialisation du socle \${NC_EXPL_CFG}/init.conf n existe pas !"        |
      |           echo "Arret du script par securite"                                                      |
      |           exit 250                                                                                 |
      |       else                                                                                         |
      |           . ${NC_EXPL_CFG}/init.conf                                                               |
      |       fi                                                                                           |
      |                                                                                                    |
      |       #-----------------------------------------------------------------------------               |
      |       #                          Definition des fonctions                                          |
      |       #-----------------------------------------------------------------------------               |
      |       #                                                                                            |
      |       function fct_un                                                                              |
      |       { ...  <Code fonction>                                                                       |
      |       }                                                                                            |
      |                                                                                                    |
      |       #-----------------------------------------------------------------------------               |
      |       function fct_deux                                                                            |
      |       { ...                                                                                        |
      |       }                                                                                            |
      |                                                                                                    |
      |       #-----------------------------------------------------------------------------               |
      |       #                             Programme principal                         MAIN               |
      |       #-----------------------------------------------------------------------------               |
      |       #                                                                                            |
      |       fct_message "${SH_PROG}"                                                                     |
      |       fct_message "version ${SH_PROG_VERSION}"                                                     |
      |                                                                                                    |
      |       # -- Initialisation des variables par defaut                                                 |
      |       # -- ---------------------------------------                                                 |
      |       G_VAR1=${G_AVR1:="Valeur par defaut"}           # <Comentaire>                               |
      |       ...                                                                                          |
      |                                                                                                    |
      |       # -- Control de coherence des options                                                        |
      |       # -- --------------------------------                                                        |
      |                                                                                                    |
      |       # -- Traitement                                                                              |
      |       # -- ----------                                                                              |
      |                                                                                                    |
      |       < ... Code du script ...>                                                                    |
      |                                                                                                    |
      |       fct_erreur 0                                                                                 |
      |                                                                                                    |
      +----------------------------------------------------------------------------------------------------+

      Note : La construction /G_VAR1=${G_AVR1:="Valeur par defaut"}/ permet de definir une variable avec une
             valeur par defaut, qui peut etre surchargee dans le fichier de configuration {NC_EXPL_CFG}/<Nom_du_script>.conf

             Concernant les fonctions /fct_message/ et /fct_erreur/ voir le chapitre V.

  4 - Actions realisees au lancement d un script
      Le script commence par le chargement de la configuration ". ${NC_EXPL_CFG}/init.conf"
      un certain nombre d action sont effectuees par defaut en plus de l initialisation des variables de session.

      - Initialisation des variables de session (Cf. II.3)

      - Generation d'un numero de session unique sous la varable ${SH_SESSION_ID}

      - Chargement du fichier ${SH_FICCFG}
      
      - Rotation des fichiers ${SH_FICLOG} et ${SH_FICCPT} selon les retentions respective ${SH_RETENTION_LOG} et ${SH_RETENTION_CPT}
      
      - Purge des fichiers temporaires (${NC_EXP_ROOT}/tmp) anterieurs selon la retentions ${SH_RETENTION_LOG}
        et suppression des fichiers generes par le script utilsant le socle dans ${NC_EXP_ROOT}/log et ${NC_EXP_ROOT}/cpt
      
      - Ecriture dans le fichier ${SH_FICTRC} de la date de debut execution, ainsi que des arguments passes au script
      
      - Initialisation du fichier ${SH_FICLOG} a vide

      - Analyse des parametres passes au script
        Cette analyse ne fonctionne que si les options ont ete declarees dans l entete du script (Cf. III.1.1.2)
IV - Nomenclature
1 - Fichier temporaire
Les fichiers temporaires doivent etre ecrits dans le repertoire ${NC_EXPL_TMP}.
Les noms des fichiers temporaires sont de le forme : _${SH_SESSION_ID}.tmp
De cette facon il seront geres par le socle (Suppresion automatique)
  2 - Nom des executables ( fichiers du dossier {racine}/bin )
      Les noms des fichiers doit etre de la forme :
        <pre>_<descr>
        <pre>_<descr>.<language>
        <pre>_<app_source>_<app_dest>[_<libre>].<language>
        <app>_<descr>.<language>

      <pre>      est une des valeurs suivantes : "sys", "dba", "exp", "ctl", "aud", "int"

                 - "sys" : Scrit d administration systeme.
                 - "dba" : Script d administration base de donnees
                 Ces scripts peuvent presenter des risques et doivent faire 
                 l objet d une attention particuliere lors de leurs execution.

                 - "exp" : Script d exploitation devolue principalement au traitement reccurent
                 Ces scripts sont reserves a l'exploitation courante. Il peuvent 
                 modifier le systeme dans le cadres de traitements reccurents.
                 Leurs execution est de risque modere, comme respecter une date d execution.
                 Il sont reserves a l exploitation systeme uniquement. Dans le cas d un traitement
                 reccurrent pour le compte d une application le nom doit etre de la forme <app>_<descr>.<language>

                 - "int" : Script dedier aux interfaces entre applications
                 Ces script doivent fair l objet d une attention particuliere car il peuvent modifier
                 les donnees applicative et peuvent etre contraint par des conditions d execution.

                 - "ctl" : Script de controle (devolu principalement a icinga)
                 - "aud" : Script d audit ne modifiant pas le systeme.
                 Ces scripts peuvent etre executes sans aucun risque.

      <descr>    est libre, doit refleter si possible la fonction du script.
      
      <language> est une des valeurs suivantes :
                  - "rb"            : Script Ruby.
                  - "sh"            : Script Bash.
                  - Pas d extention : Script C
      
      <app>      est le nom de  application a laquelle le script est dedie.
                 Ces scripts sont reserves a une application particuliere, 
                 dans le cadres de l exploitation reccurente de l'application.
V - Description et usage des Librairies
1 - fct_message
--- -----------
    Syntaxe  : fct_message [-cpt] [-hist] [-nolog] [-debug N] [-color Couleur] "<Message a ecrire>"
    Usage    : Cette fonction est a utiliser en remplacement de la commande "echo".
               Elle ajoute l horadatage au message et gere la ventilation des ecritures dans les differents fichiers de traces.

    Fonction : Par defaut le message est affiche sur le terminal et est ecrit dans le fichier journal ${NC_EXPL_LOG}/<nom_du_script>.log
               Les options modifient la destination de l ecriture :
               - cpt     : Ecrit en plus du journal dans le fichier de compte-rendu ${NC_EXPL_CPT}/<nom_du_script>.cpt
               - hist    : Ecrit uniquement dans le fichier d historique des executions ${NC_EXPL_TRC}/<nom_du_script>.hist
               - nolog   : inhibe l ecritutre dans le fichier journal
               - debug N : N'affiche pas le message sur le terminal mais uniquement dans le fichier journal, a condition
                           que le script soit execute en mode debug de niveau equivalent a "N" via l'option "-dbg N".
                           Par defaut le niveau de debug est 0, ainsi si "N" vaut zero alors le message est ecrit 
                           uniquement dans le fichier journal.
               - color   : Affiche le message en couleur. Les couleurs reconues sont : vert,rouge,bleu,cyan,jaune,orange,blanc et noir


2 - fct_affiche_ligne
--- -----------------

   Syntaxe  : fct_affiche_ligne [entete|pied] <elements>
   Usage    : Affiche un tableau sur la sortie standard et dans le fichier compte-rendu ${NC_EXPL_ROOT}/<script>.cpt
              
   Fonction : 3 etapes sont necessaires pour creer un tableau :
              - Definition du tableau
              - Affichage des elements
              - Fermeture du tableau

              Ces etapes doivent imperativement etre suivies et dans cet ordre.
              Il n est pas possible d imbriquer des tableaux.

              - Definition
                Elle realise par l appel de la fonction fct_affiche_ligne avec l argument entete la forme est alors la suivante :

                fct_affiche_ligne entete "{Titre}" "{Colonne_1},{Taille_1}" "{Colonne_2},{Taille_2}" "{Colonne_3},{Taille_3}" "{Colonne_4},{Taille_4}" ...

                ou bien
                fct_affiche_ligne entete "{Titre}" "Groupe1({Colonne_1},{Taille_1}:{Colonne_2},{Taille_2})" "{Colonne_3},{Taille_3}" "{Colonne_4},{Taille_4}" "Groupe2({Colonne_4},{Taille_4}:...)"

              - Affichage des elements

                fct_affiche_ligne "<Element1>" "<Element2>" ...

              - Fermeture du tableau
                Cette action permet de liberer les variables de session qui ont ete crees

                fct_affiche_ligne pied

              Exemple ...
                 
                +
                |    fct_affiche_ligne entete "Un tableau" "C1,10" "C2,10" "c3,10"
                |    fct_affiche_ligne A B C
                |    fct_affiche_ligne 1 "" 3
                |    fct_affiche_ligne pied
                |
                + 
                |    --------------------------------------
                |                 Un tableau
                |    --------------------------------------
                |         C1     |     C2     |     c3
                |    --------------------------------------
                |    A           |B           |C
                |    1           |            |3
                |    --------------------------------------
                + 
                
                +
                |    fct_affiche_ligne entete "Un Autre tableau" "C1,10" "G1(C2,20:C3,10:C4,3)" "C5,15"
                |    fct_affiche_ligne A B C D E
                |    fct_affiche_ligne 1 "" 3 3 4
                |    fct_affiche_ligne pied
                |
                +                  
                |    ------------------------------------------------------------------------
                |                                Un Autre tableau
                |    ------------------------------------------------------------------------
                |                |                   G1                    |
                |         C1     |-----------------------------------------|       C5
                |                |          C2          |     C3     | C4  |
                |    ------------------------------------------------------------------------
                |    A           |B                     |C           |D    |E                
                |    1           |                      |3           |3    |4                
                |    ------------------------------------------------------------------------
                +

3 - fct_erreur
--- ----------

   Syntaxe  : fct_erreur <N>
   Usage    : Gestion des erreurs d un script
              
   Fonction : Cette fonction doit etre appelee pour sortir d un script du socle.
              Elle affiche le message d erreur associe au code qui est lu dans le fichier ${NC_EXPL_MSG}/<script>.msg
              Elle execute eventuellement une fonction rattachee, specifiee dans ce meme fichier.
              Elle ferme les fichiers de traces, supprime les fichiers temporaires, libere les semaphores et 
              renvoi un code retour au script appelant.

              N est un entier positif dont les valeurs suivantes sont reservees :

              0   : Fin normale du script
              250 : <lib:fct_erreur> Appel de la librairie sans le numero d erreur (<N> non renseigne !)
              251 : <lib:fct_erreur> La description de l erreur <N> n existe pas dans le fichier <script>.msg
              252 : <lib:fct_erreur> Le fichier <script>.msg n existe pas
              253 : <lib:fct_erreur> La description de l erreur dans le fichier <script>.msg est incorrecte
              254 : <lib:fct_params> Erreur a ete remontee par la librairie 
              255 : <lib:fct_erreur> Appel de la librairie avec un numero d erreur >= 250
              256 : reserve pur un futur usage



              Le fichier <script>.msg contient les descriptions des codes erreur.
              Un code par ligne de la forme :
              <NumErreur> | <type> | <action> | <message> ou <fonction>

              <NumErreur> : Entier positif identifiant l erreur

              <type>      : prend les valeurs erreur, alert ou info
                            colorise le message en fonction du type respectivement
                            rouge, orange et bleu 

              <action>    : Action a realiser (continu,stop,exec)
                            - continu : Affiche le message puis rend la main au script
                            - stop    : Affiche le message puis sort en erreur
                            - exec    : execute la fonction puis rend la main au script

              <fonction>  : Fonction a executer
                            Ce champs peut contenir des variables qui seront valorisees.
              
              <message>   : Message a afficher (dans les traces et sur la sortie standard)
                            Ce champs peut contenir des variables qui seront valorisees.

4 - fct_unique_exec
--- ---------------

   Syntaxe  : fct_unique_exec [<nom>] [<Occurences>]
   Usage    : Empeche l execution multiple d un code par la l'acquisition de semaphore
              
   Fonction : 


5 - fct_libere_exec
--- ---------------

   Syntaxe  : fct_libere_exec [<nom>]
   Usage    : Libere les semaphores
              
   Fonction : 


6 - fct_usage
--- ---------

   Syntaxe  : fct_usage
   Usage    : Affiche l aide du script.
              Ce sont les lignes du cartouche commencant par "##"
              
   Fonction : Cette fonction est uniquement a usage interne du socle. 
              Elle est integree a la fonction fct_params.

7 - fct_rotation
--- ------------

   Syntaxe  : 
   Usage    : 
              
   Fonction : 


8 - fctpath
--- -------

   Syntaxe  : 
   Usage    : 
              
   Fonction :

9 - fct_params


   Syntaxe  : fct_params
   Usage    : Gestion des options et arguments du script
              
   Fonction : Cette fonction est uniquement a usage interne du socle.
              Elle est appelee a l initialisation des variables de session lors du chargement du fichier ${NC_EXPL_CFG}/init.conf
              Cette fonction extrait les lignes de declaration "# OPT:" et les compare au arguments sousmis au script
              Pour plus d information voir le paragraphe III-1.1.2  
V - Deploiement via puppet
1 - Script avec Hiera
--- -----------------
Exemple :

script_core_dtsi::file_bin_bash: 'aud_process_swap.sh': source: 'puppet:///modules/script_core_dtsi/bin/aud_process_swap.sh'

2 - Fichier de conf avec Hiera
--- --------------------------

Exemple :

script_core_dtsi::file_conf_bash: aud_process_swap.conf: source: 'puppet:///modules/script_core_dtsi/conf/aud_process_swap.conf'

3 - Fichier de conf construit depuis un script avec Hiera
--- -----------------------------------------------------

Exemple :

script_core_dtsi::file_conf_hiera::aud_process_swap: directives1: "conf1"

4 - fichier de message  avec Hiera
--- ------------------------------

Exemple :

script_core_dtsi::msg_errors_hiera::aud_process_swap: 1: 'erreur | stop | message N 1' 2: 'alert | continu | message N 2'

5 - Fichier modele avec Hiera
--- --------------------------

Exemple :

script_core_dtsi::file_mod: aud_process_swap.mod: source: 'puppet:///modules/script_core_dtsi/mod/aud_process_swap.mod'

6 - Fichier SQL avec Hiera
--- ----------------------

Exemple :

script_core_dtsi::is_bdd: true

script_core_dtsi::file_sql: aud_process_swap.sql: source: 'puppet:///modules/script_core_dtsi/sql/aud_process_swap.sql'