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.

802 lines
43 KiB

4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
  1. # Historique
  2. Le **socle Bash** est **une version allégée** d'un ensemble de bibliothèques et fonctions
  3. écrit en grande partie par **Emmanuel Confrère**, émminent DBA Calédonien qui nous a
  4. autorisé à l'utiliser au sein du Tetalab, et dont l'utilité est d'assurer la cohérence
  5. des scripts qui s'appuient dessus.
  6. Ce **socle Bash** est fiable et robuste. Il peut sans aucun doute être utilisé en production
  7. à la condition que l'ensemble des conseils listés dans la documentation soient respectés.
  8. Entre autres fonctionalités ce **socle Bash** permet aux scripts qui s'appuient dessus:
  9. * La gestion de l'historique d'exécution
  10. * La gestion des logs
  11. * La gestion des fichiers temporaires
  12. * La gestion des options et arguments
  13. * La gestion des erreurs
  14. * La standadisation de l'affichage
  15. * etc
  16. # Installation
  17. L'installlation du script bash est simple et nécessite les droits **root**.
  18. * Éditez le fichier de configuration **./conf/install_init.conf** de manière à ce
  19. que les variables qui y sont définies correspondent à vos besoins.
  20. # La variable d'environnement qui définira l'emplacement
  21. # de l'ensemble du socle Bash
  22. NC_EXPL_ROOT=/opt/tetalab
  23. export NC_EXPL_ROOT
  24. # Le repertoire d'installation des fichiers de profiles système
  25. PROFILE_DIR=/etc/profile.d
  26. # Le nom du fichier de profile système à créer
  27. PROFILE_FILE=tetalab.sh
  28. # Utilisateur administrateur de l'infrastructure
  29. ADMIN_USER=asr
  30. # Groupe des utilisateurs habilités à utiliser le socle
  31. ADMIN_GROUP=asr
  32. * Lancez l'installation en tant qu'utilisateur **root** (ou sudo):
  33. sudo ./install.sh
  34. # Documentation
  35. * **Sommaire**
  36. * I - **Arborescence du socle**
  37. * II - **Variables d'environement**
  38. * 1 - Variables globales
  39. * 2 - Variables de session
  40. * III - **Utilisation du socle bash**
  41. * 1 - Cartouche
  42. * 1.1 Élements du cartouche
  43. * 1.2 Versionnement sémantique
  44. * 1.2.1 Usage
  45. * 1.2.2 Format
  46. * 1.2.3 Sémantique
  47. * 2 - Initialisation du socle
  48. * 3 - Structure d'un script
  49. * 4 - Actions realisées au lancement d'un script
  50. * IV - **Nomenclature**
  51. * 1 - Fichiers temporaires
  52. * 2 - Nom des exécutables
  53. * V - **Description et usage des bibliothèques**
  54. * 1 - fct\_message
  55. * 2 - fct\_affiche\_ligne
  56. * 3 - fct\_erreur
  57. * 4 - fct\_unique\_exec
  58. * 5 - fct\_libere\_exec
  59. * 6 - fct\_usage
  60. * 7 - fct\_rotation
  61. * 8 - fctpath
  62. * 9 - fct\_params
  63. ## I - Arborescence du socle
  64. La racine des dossiers utilisée par le **socle Bash** est définie par la variable d'environement **NC\_EXPL\_ROOT**.
  65. Cette dernière est initialisée à la connexion par l'appel au **fichier de profile** (voir installation)
  66. Cette arborescence ainsi que les variables d'environement qui en découlent sont utilisées par tous scripts Bash
  67. Sous l'arborescence **${NC\_EXPL\_ROOT}** on trouve les dossiers suivants :
  68. +-----------------+-----------------------------------------------------------------------------------------------+
  69. | Dossier | Description |
  70. +-----------------+-----------------------------------------------------------------------------------------------+
  71. | {Racine}/bin | Contient les binaires (scripts Bash) |
  72. | {Racine}/conf | Contient les fichiers de configuration des scripts, ainsi que du socle |
  73. | {Racine}/cpt | Contient les fichiers de comtpe-rendus génerés par les script (purge auto, 8 jours par défaut)|
  74. | {Racine}/dat | Contient les fichiers de données gérés par les scripts |
  75. | {Racine}/hist | Contient l'historique d'exécution des scripts (pas de purge) |
  76. | {Racine}/lib | Contient les bibliothèques chargées par le socle |
  77. | {Racine}/log | Contient les fichiers de logs d exécution des scripts (purge auto , 8 jours par défaut ) |
  78. | {Racine}/man | Contient les fichiers d'aide des scripts pour l'utilitaire "man" |
  79. | {Racine}/mod | Contient les fichiers modèles (templates) à usage des scripts |
  80. | {Racine}/msg | Contient les fichiers de messages des scripts utilisés par la bibliothèque "fct_erreur" |
  81. | {Racine}/tmp | Contient les fichiers temporaires des scripts |
  82. +-----------------+-----------------------------------------------------------------------------------------------+
  83. **Note:** Sous chaque dossier vous trouverez un fichier texte lisezmoi.txt decrivant l'usage du répertoire.
  84. ## II - Variables d'environement
  85. Le socle utilise deux groupes de variables. Le premier dit "global" le second "de session".
  86. Sauf si explicite, les variables globales sont définies et exportées à la connexion. Elles sont donc utilisables
  87. par tous les scripts, mais elles ne sont pas modifiables.
  88. Les variables de session sont définies à l'execution d'un script et lui sont propres.
  89. Cependent certaines d'entre elles sont transmises aux scripts enfants:
  90. * SH\_SESSION\_ID
  91. * SH\_FICLOG
  92. * SH\_FICCPT
  93. * SH\_RETENTION\_CPT
  94. * SH\_RETENTION\_LOG
  95. * SH\_NIV\_DEBUG
  96. * SH\_SILENCE
  97. * SH\_AFF\_SID
  98. Les variables de session sont modifiable à 2 niveaux. De facon globale dans le fichier **init.conf** ou pour un script
  99. particulier dans le fichier **${NC_EXPL_CFG}/<Nom_du_script>.conf**.
  100. La valeur définie dans **init.conf** sera utlisée sauf si elle a été surchargée dans le fichier de configuration du
  101. script.
  102. Il y a cependant une spécificite pour **SH_RETENTION_CPT** et **SH_RETENTION_LOG**:
  103. ces variables sont définies une et une seule fois lors de la première initialisation. Ce qui signifie qu'un
  104. script qui aurait surchargé ces variables ignorera l'initialisation de ces variables si il est appelé par un
  105. autre script.
  106. ### 1 - Variables globales générales
  107. +-------------------+----------------------------+
  108. | Nom | Usage |
  109. +-------------------+----------------------------+
  110. | NC_EXPL_ROOT | Racine /opt/expl |
  111. | EXPL_ROOT | Alias pour NC_EXPL_ROOT |
  112. | NC_EXPL_BIN | Pointe vers {Racine}/bin |
  113. | NC_EXPL_CFG | Pointe vers {Racine}/conf |
  114. | NC_EXPL_CPT | Pointe vers {Racine}/cpt |
  115. | NC_EXPL_DAT | Pointe vers {Racine}/dat |
  116. | NC_EXPL_HST | Pointe vers {Racine}/hist |
  117. | NC_EXPL_LIB | Pointe vers {Racine}/lib |
  118. | NC_EXPL_LOG | Pointe vers {Racine}/log |
  119. | NC_EXPL_MAN | Pointe vers {Racine}/man |
  120. | NC_EXPL_MOD | Pointe vers {Racine}/mod |
  121. | NC_EXPL_MSG | Pointe vers {Racine}/msg |
  122. | NC_EXPL_TMP | Pointe vers {Racine}/tmp |
  123. | RUBYLIB | vaut ${NC_EXPL_LIB} |
  124. | NC_EXPL_SRVBATCH | Nom du serveur Batch |
  125. +-------------------+----------------------------+
  126. Les variables **NC\_EXPL\_ROOT**, **EXPL\_ROOT** et **NC\_EXPL\_SRVBATCH** sont
  127. définies dans **le fichier de profile** (voir installation)
  128. Les autres variables **NC\_\*** sont définies dans le fichier **profile\_init.env**
  129. ### 2 - Variables de session
  130. Cette liste n'est pas exhaustive, seules les principales variables sont citées.
  131. +--------------------+-------------------------------------------------------------------------------+
  132. | Nom | Usage |
  133. +--------------------+-------------------------------------------------------------------------------+
  134. | SH_SESSION_ID | Numero unique d'exécution : <TimeStamp>_<PID> |
  135. | SH_SILENCE | Active ou non l'affichage des messages via fct_message. Par defaut vaut "non" |
  136. | SH_PROG | Nom du script |
  137. | SH_LOGUSER | Compte initial de connexion au serveur |
  138. | SH_EXECUSER | Compte courant exécutant le script |
  139. | SH_DIR | Dossier hébergeant le script |
  140. | SH_PROG_VERSION | Version du script |
  141. | SH_FICTRC | Pointe vers le fichier ${NC_EXPL_HST}/<Nom_du_script>.hist |
  142. | SH_FICMSG | Pointe vers le fichier ${NC_EXPL_MSG}/<Nom_du_script>.msg |
  143. | SH_FICCFG | Pointe vers le fichier ${NC_EXPL_CFG}/<Nom_du_script>.conf |
  144. | SH_FICSEM | Pointe vers le fichier /dev/shm/<Nom_du_script>.sem |
  145. | SH_FICLOG | Pointe vers le fichier ${NC_EXPL_LOG}/<Nom_du_script>.log |
  146. | SH_FICCPT | Pointe vers le fichier ${NC_EXPL_CPT}/<Nom_du_script>.cpt |
  147. | SH_NIV_DEBUG | Vaut 0 par défaut. Niveau d'affichage dans les fichiers de traces |
  148. | SH_RETENTION_CPT | Vaut 8 par défaut. Duree de rétention en jours des fichiers de compte-rendus |
  149. | SH_RETENTION_LOG | Vaut 8 par défaut. Duree de rétention en jours des fichiers de traces |
  150. | SH_TMP_DIR | Le nom du répertoire temporaire pour la session ($NC_EXPL_TMP/$SH_SESSION_ID) |
  151. +--------------------+-------------------------------------------------------------------------------+
  152. Remarques :
  153. * Les variables **SH\_SILENCE** et **SH\_NIV\_DEBUG** sont controlées par les options "**-s**" et "**-dbg**"
  154. si la gestion des options a été activée.
  155. * Le répertoire SH\_TMP\_DIR est systématiquement créé au début du script la bibliothèque params.lib.
  156. * Le répertoire SH\_TMP\_DIR est également détruit à la fin du script (voir erreur.lib).
  157. ## III - Utilisation du socle bash
  158. Cette partie décrit sommairement les quelques règles d'usage pour écrire un script Bash avec le socle.
  159. ### 1 - Cartouche
  160. Les scripts doivent commencer par le cartouche ci-dessous :
  161. +----------------------------------------------------------------------------------------------------+
  162. | |
  163. | #!/bin/bash |
  164. | ##---------------------------------------------------------------------------- |
  165. | ## Script : <Nom_du_script> |
  166. | ## Module Puppet : <Nom_du_module_hebergeant_le_script> |
  167. | ## Auteur : <Auteur ayant cree le script> |
  168. | ## Date : <Derniere_date_d_actualisation_au_format_JJ-MM-AAAA> |
  169. | ## Version : <Version> |
  170. | ## Objet : <Resume de la fonction> |
  171. | ## |
  172. | # ---------------------------------------------------------------------------- |
  173. | # Mise a jour : |
  174. | # <Version> <Date> - <Auteur> - <Action> : <Description> |
  175. | # 0.0.1 08-06-2016 - Toto Laricot - Cre : Creation |
  176. | # 0.0.2 08-09-2016 - Titi Alapeti - Ano : Ce truc est faux |
  177. | # ---------------------------------------------------------------------------- |
  178. | # Dependance : |
  179. | # @DEP: <Nom_du_script>:<Version[-|+]> |
  180. | # ---------------------------------------------------------------------------- |
  181. | # Liste des options et arguments |
  182. | # @OPT: <type>:<nom>:<var>:<nb_arg>:<def_val>:<OptE>:<OptI>:<ctl_val> # <Commentaire> |
  183. | # @OPT: <type>:... # <Commentaire> |
  184. | # @ARG: <type>:<var>:<nb_arg>:<def_val>:<ctl_val> # <Commentaire> |
  185. | ##---------------------------------------------------------------------------- |
  186. | ## |
  187. | ## Syntaxes : |
  188. | ## -------- |
  189. | ## |
  190. | ## prompt> <Nom_du_script> <Liste_des_arguments_et_options> |
  191. | ## |
  192. | ## <Opt1> : <Description> |
  193. | ## |
  194. | ## Fonctionnement : |
  195. | ## -------------- |
  196. | ## |
  197. | ## <Que fait le script dans les details et comment ca marche......> |
  198. | ## |
  199. | ##---------------------------------------------------------------------------- |
  200. +----------------------------------------------------------------------------------------------------+
  201. **Note:** Les lignes commençant par 2 "#" sont utilisées pour générer l'aide, leur maintient est donc nécéssaire
  202. pour garantir la fiabilité de l'information. Ce sont ces lignes qui sont lues lors de l'utilisation de
  203. l'option par defaut "**-h**".
  204. #### 1.1 Elements du cartouche
  205. ##### 1.1.1 Meta-données
  206. * **&lt;Action&gt;**: peut prendre les valeurs suivantes:
  207. cre : Création du script.
  208. evo : Évolution du script -> Ajout de nouvelles fonctionnalités, Amélioration du code.
  209. ano : Correction du code suite à un comportement inattendu.
  210. typo : Ajout de commentaires, de texte ou corrections gramaticales sans influence sur le code.
  211. * **&lt;Auteur&gt;**: &lt;Prenom&gt; &lt;Nom&gt;
  212. * **&lt;Version&gt;**; : Format x.y.z
  213. Pour le suivi des versions on utilisera le versionnement sémantique (voir paragraphe III-1.2).
  214. ##### 1.1.2 Paragraphe
  215. * **Mise à jour**: Ce paragraphe est utilisé pour suivre l'evolution des versions. La dernière version en
  216. vigueur doit être reportée dans le premier paragraphe.
  217. * **Dépendance**: Permet de définir la liste ainsi que la version des scripts qui sont appelés.
  218. Dans le cas d'un changement cela permet de connaître les scripts qui sont impactés.
  219. Pour le moment aucun script n'exploite cette méta-donnée qui est presente pour un future usage.
  220. * **Liste des options**: La déclaration des options n'est pas obligatoire.
  221. Si aucune déclaration n'est présente alors la bibliothèque params.lib ne fait aucune action.
  222. Dans ce cas les options par défaut **-h**, **-log**, **-hist**, **-cpt**, **-s** et **-dbg** ne
  223. seront pas disponibles.
  224. Si le script ne nécessite pas d'option mais que l'on souhaite disposer des options par défaut, il
  225. faudra déclarer une option bidon.
  226. # @OPT: f:bidon::::::
  227. Si la déclaration existe alors le socle gèrera les paramètres en entrée du script, ainsi que
  228. les options par défaut **-h**, **-log**, **-hist**, **-cpt**, **-s** et **-dbg**.
  229. **Ces mots clé sont reservés et ne peuvent pas être utilisés par le script.**
  230. La déclaration est réalisée dans le paragraphe "Liste des options et arguments". Chaque
  231. option est identifiée par l'entête de ligne "# @OPT:" suivi de la description.
  232. La description consiste en une liste de paramètres séparés par ":"
  233. <type>:<nom>:<var>:<nb_arg>:<def_val>:<OptE>:<OptI>:<ctl_val>
  234. L'ordre des paramètres est figé et tous doivent etre présents.
  235. **8 champs sont obligatoires**, soit 7 caractères ":" (on ne compte pas le caracatère ":" suivant @OPT).
  236. Exemple de déclaration valide :
  237. # @OPT: fb:h::0:::
  238. # @OPT: fb:s::0:::
  239. # @OPT: f:dbg:SH_NIV_DEBUG:0/1:::
  240. # @OPT: fb:log::0:::
  241. # @OPT: f:hist:SH_ARG_HIST:0/1:10::
  242. # @OPT: oM:i:G_INSTANCE:1/1:ALL:dbid:
  243. # @OPT: oM:pr:G_PR_NOM:1/1:sq,t,l:
  244. * **&lt;type&gt;**: Propriété de l'attribu défini par l'aggrégation des lettres suivantes:
  245. f -> Option falcultative
  246. b -> Booléen
  247. o -> Option obligatoire
  248. M -> Argument transformé en majuscule
  249. * **&lt;nom&gt;**: nom de l'option (sans le tiret). Attention le nom de l'option est sensible à la casse.
  250. * **&lt;var&gt;**: nom de la variable dans laquelle sera stockée le(s) argument(s)
  251. si plusieurs arguments alors un tableau sera initialisé **&lt;var[n]&gt;**
  252. L'index [n] commence à zero.
  253. Le nombre d'arguments effectivement passés à la commande est **${#&lt;var&gt;[\*]}**.
  254. La valeur max de l'index [n] est **${#&lt;var&gt;[\*]} - 1**.
  255. * **&lt;nb\_arg&gt;**: nombre d'arguments attendus de la forme "**min/max**", "**min/**", "**max**" ou ""
  256. si vide ou "0" alors l'option est booléene.
  257. la forme "**min/**" considère le nombre max non determiné (infini)
  258. * **&lt;def\_val&gt;**: Valeur par défaut assignée à **&lt;var&gt;**
  259. Fonctionne si **&lt;nb\_arg&gt;** vaut 0/1 1/1
  260. * **&lt;OptE&gt;**: Liste des options mutellement exclusives séparées par une virgule.
  261. * **&lt;OptI&gt;**: Liste des options inclusives séparées par une virgule.
  262. Lors de l'initialisation les marqueurs "**@OPT**" sont lues et analysées.
  263. Le résultat est comparé aux arguments et options sousmis au script et les variables suivantes sont initialisées ...
  264. * **SH\_OPTION\_&lt;nom&gt;**: Initialisée à "1" (Vrai) ou "0" (Faux) selon que l'option est respectivement utilisée ou non.
  265. Il existe toujours une variable par option déclarée. Ceci concerne aussi les options par défaut gérées par la bibliothèque **params.lib**.
  266. * **SH\_ARG\_&lt;nom&gt;**: Cette variable existe uniquement si le champ **&lt;var&gt;** est null et si le type n'est pas booléen.
  267. Par défaut elle est initialisée à **null** ou avec la valeur **&lt;def\_val&gt;**
  268. Si le champs **&lt;var&gt;** est renseigné, alors **SH\_ARG\_&lt;nom&gt;** est remplacée pas **&lt;var&gt;**.
  269. Si l'option associée peut prendre plusieurs arguments, alors les variables **SH\_ARG\_&lt;nom&gt;** ou **&lt;var&gt;**
  270. sont des tableaux dont l'index commence a zéro. La taille du tableau peut etre récuperée via
  271. **${#SH\_ARG\_&lt;nom&gt;[\*]}** ou **${#&lt;var&gt;[\*]}**.
  272. Les options **-h**, **-s**, **-log [id]**, **-hist [N]** et **-dbg N** sont prises en charge automatiquement. Ces noms sont donc reservées.
  273. Les options par défaut réalisent les actions suivantes :
  274. -h : Affiche l'aide du script (Ligne du cartouche qui commence par "##")
  275. -s : Mode silence. Plus d'affichage sur le terminal.
  276. Initialise la variable SH_SILENCE a "oui"
  277. -log [id] : Affiche le dernier journal ou le journal "id" (identifiant de session d'exécution).
  278. -cpt [id] : Affiche le dernier compte-rendu ou le Compte-rendu "id" (identifiant de session d'execution).
  279. -hist [N] : Affiche l'historique des "N" dernières executions (N=10 par défaut)
  280. -dbg N : Activation du mode debug au niveau "N". Active les messages gérés par la bibliothèque fct_message
  281. dont l'option -debug est utilisée.
  282. * **Arguments**: La déclaration des arguments du script n'est pas obligatoire
  283. **Attention: Si aucune option "@OPT:" n'est déclarée alors il n y aura pas de prise en charge des arguments.**
  284. Si votre script ne nécessite pas d'option, mais qu'il presente des arguments, il faudra alors déclarer une
  285. option bidon :
  286. # @OPT: f:bidon::::::
  287. La déclaration est réalisé dans le paragraphe "**Liste des options et arguments**".
  288. Elle est identifiée par l'entête de ligne "**# @ARG:**" suivi de la description.
  289. Il ne peut y avoir qu'une ligne de description pour les arguments. (Si plusieurs lignes avec le
  290. marqueur **@ARG** existent, alors seule la premiere est prise en compte).
  291. La description consiste en une liste de paramètres séparés par ":"
  292. <type>:<var>:<nb_arg>:<def_val>:<ctl_val>
  293. L'ordre des paramètres est figé et tous doivent être présents.
  294. * **&lt;type&gt;**: Propriété de l'attribu défini par l'aggrégation des lettres suivantes:
  295. f -> Argument falcultative
  296. o -> Argument obligatoire
  297. M -> Argument transforme en majuscule
  298. * **&lt;var&gt;**: nom de la variable dans laquelle sera stockée le(s) argument(s)
  299. si plusieurs arguments alors un tableau sera initialisé **&lt;var[n]&gt;**
  300. L'index [n] commence à zero.
  301. Le nombre d'arguments effectivement passés à la commande est **${#&lt;var&gt;[\*]}**.
  302. La valeur max de l'index [n] est **${#&lt;var&gt;[\*]} - 1**.
  303. Si **&lt;var&gt;** n'est pas renseigné alors la variable **SH\_ARGS[]** est initialisée
  304. * **&lt;nb\_arg&gt;**: nombre d'arguments attendus de la forme "**min/max**", "**min/**", "**max**" ou "".
  305. si vide alors on considère que le nombre d'arguments est a minima de 1.
  306. la forme "**min/**" considère le nombre est a minima de "**min**".
  307. * **&lt;def\_val&gt;**: Valeur par défaut assignée à **&lt;var&gt;**
  308. Fonctionne si **&lt;nb\_arg&gt;** vaut 0/1 1/1
  309. **Attention: Si le caractère "**&**" est présent dans la valeur d'un argument, alors cette valeur doit être encadrée
  310. par une simple quote et le caractère "&" doit être protégé par un anti-slash "\".**
  311. si le caractère "**&**" n'est pas protégé le shell génèrera un fils qui tentera l'execution d'un script portant
  312. le nom de la valeur de l'argument ! Effet de bord garanti !
  313. #### 1.2 Versionnement sémantique
  314. ##### 1.2.1 Usage
  315. L'idée de l'utilisation du versionnement sémantique est de définir clairement les intentions
  316. d'un changement dans un code pour les clients de ce dernier. Ceci permet de fiabiliser la mise en
  317. place de dépendances et de déterminer les impacts d'un changement.
  318. ##### 1.2.2 Format
  319. Le format utilisé est le suivant: **X.Y.Z**
  320. * X est l'identifiant de **version majeure**.
  321. * Y est l'identifiant de **version mineure**.
  322. * Z est l'identifiant de **version de correction**.
  323. ##### 1.2.3 Sémantique
  324. * **Version majeure X**: Il vaut "0" lors du développement, le script est considéré non valide et ne
  325. devrait pas être appelé par d'autres scripts. Une fois le script valide la version doit etre 1.0.0
  326. (première version stable).
  327. Il doit etre incrementé si des changements dans le code n'assure plus la compatibilité ascendante.
  328. Les identifiants de version mineure et de correction doivent etre remis à zero quand l'identifiant
  329. de version majeure est incrementé.
  330. * **Version mineure Y**: Doit être incrementé lors de l'ajout de nouvelles fonctionnalités ou d'amélioration
  331. du code qui n'ont pas d'impact sur la compatibilité ascendante. L'identifiant de version de correction doit
  332. être remis a zero lorsque l'identifiant de version mineure est incrementé.
  333. * **Version de correction Z**: Doit être incrementé si seules des corrections rétro-compatibles sont introduites.
  334. Une correction est définie comme un changement interne qui corrige un comportement incorrect.
  335. Il peut être incrementé lors de correction typographique ou grammaticale.
  336. ### 2 - Initialisation du socle
  337. Par défaut les bibliothèques du socle sont chargées à la connexion. Mais pour qu'elles puissent être operationnelles
  338. il faut initialiser les variables de session.
  339. Ceci est réalisé en sourcant le fichier "**${NC\_EXPL\_CFG}/init.conf**" au debut du script :
  340. Remarque: L'analyse des options et arguments est aussi réalisée par "**${NC\_EXPL\_CFG}/init.conf**".
  341. +----------------------------------------------------------------------------------------------------+
  342. | |
  343. | #!/bin/bash |
  344. | ##---------------------------------------------------------------------------- |
  345. | . |
  346. | <CARTOUCHE> |
  347. | . |
  348. | ##---------------------------------------------------------------------------- |
  349. | #----------------------------------------------------------------------------- |
  350. | # Initialisation de l environement |
  351. | #----------------------------------------------------------------------------- |
  352. | if [ ! -f ${NC_EXPL_CFG}/init.conf ] |
  353. | then |
  354. | echo "Fichier d initialisation du socle ${NC_EXPL_CFG}/init.conf n existe pas !" |
  355. | echo "Arret du script par securite" |
  356. | exit 250 |
  357. | else |
  358. | . ${NC_EXPL_CFG}/init.conf |
  359. | fi |
  360. +----------------------------------------------------------------------------------------------------+
  361. ### 3 - Structure d'un script
  362. Voici les éléments qui devraient être présents a minima dans les script Bash. Ceci est recommandé pour
  363. assurer une homogénéite dans l'ensemble du socle.
  364. #!/bin/bash
  365. ##----------------------------------------------------------------------------
  366. .
  367. <CARTOUCHE>
  368. .
  369. ##----------------------------------------------------------------------------
  370. #-----------------------------------------------------------------------------
  371. # Initialisation de l environement
  372. #-----------------------------------------------------------------------------
  373. if [ ! -f ${NC_EXPL_CFG}/init.conf ]
  374. then
  375. echo "Fichier d initialisation du socle ${NC_EXPL_CFG}/init.conf n existe pas !"
  376. echo "Arret du script par securite"
  377. exit 250
  378. else
  379. . ${NC_EXPL_CFG}/init.conf
  380. fi
  381. #-----------------------------------------------------------------------------
  382. # Definition des fonctions
  383. #-----------------------------------------------------------------------------
  384. #
  385. function fct_un
  386. { ...
  387. }
  388. #-----------------------------------------------------------------------------
  389. function fct_deux
  390. { ...
  391. }
  392. #-----------------------------------------------------------------------------
  393. # Programme principal MAIN
  394. #-----------------------------------------------------------------------------
  395. #
  396. fct_message "${SH_PROG}"
  397. fct_message "version ${SH_PROG_VERSION}"
  398. # -- Initialisation des variables par defaut
  399. # -- ---------------------------------------
  400. G_VAR1=${G_AVR1:="Valeur par defaut"} # <Comentaire>
  401. ...
  402. # -- Contrôle de cohérence des options
  403. # -- --------------------------------
  404. # -- Traitement
  405. # -- ----------
  406. ...
  407. fct_erreur 0
  408. **Note**: La construction **G\_VAR1=${G\_AVR1:="Valeur par défaut"}** permet de définir une variable avec une
  409. valeur par défaut, qui peut être surchargée dans le fichier de configuration **${NC\_EXPL\_CFG}/&lt;Nom\_du\_script&gt;.conf**
  410. Concernant les fonctions **fct\_message** et **fct\_erreur** voir le chapitre V.
  411. ### 4 - Actions réalisées au lancement d'un script
  412. Le script commence par le chargement de la configuration "**. ${NC\_EXPL\_CFG}/init.conf**"
  413. un certain nombre d'actions sont effectuées par défaut en plus de l'initialisation des variables de session.
  414. * Initialisation des variables de session (Cf. II.3)
  415. * Génération d'un numéro de session unique sous la varable **${SH\_SESSION\_ID}**
  416. * Chargement du fichier **${SH\_FICCFG}**
  417. * Rotation des fichiers **${SH\_FICLOG}** et **${SH\_FICCPT}** selon les rétentions respective **${SH\_RETENTION\_LOG}** et **${SH\_RETENTION\_CPT}**
  418. * Purge des fichiers temporaires (${NC\_EXP\_ROOT}/tmp) antérieurs selon la retentions **${SH\_RETENTION\_LOG}** et
  419. suppression des fichiers générés par le script utilsant le socle dans **${NC\_EXP\_ROOT}/log** et **${NC\_EXP\_ROOT}/cpt**
  420. * Ecriture dans le fichier **${SH\_FICTRC}** de la date de début exécution ainsi que les arguments passés au script
  421. * Initialisation du fichier **${SH\_FICLOG}** à vide
  422. * Analyse des paramètres passés au script
  423. Cette analyse ne fonctionne que si les options ont été déclarées dans l'entête du script (Cf. III.1.1.2)
  424. ## IV - Nomenclature
  425. ### 1 - Fichiers temporaires
  426. Les fichiers temporaires doivent etre écrits dans le répertoire **${NC\_EXPL\_TMP}**.
  427. Les noms des fichiers temporaires sont de la forme : **&lt;Libre&gt;\_${SH\_SESSION\_ID}.tmp**
  428. De cette facon il seront gérés par le socle (Suppresion automatique).
  429. ### 2 - Nom des exécutables (fichiers du dossier **${EXPL\_ROOT}/bin** )
  430. Les noms des fichiers doivent être de la forme :
  431. <pre>_<descr>
  432. <pre>_<descr>.<language>
  433. <pre>_<app_source>_<app_dest>[_<libre>].<language>
  434. <app>_<descr>.<language>
  435. * **&lt;pre&gt;**: est une des valeurs suivantes : "**sys**", "**dba**", "**exp**", "**ctl**", "**aud**", "**int**"
  436. * "**sys**": Scrits d'administration système.
  437. * "**dba**": Scripts d'administration base de données
  438. Ces scripts peuvent présenter des risques et doivent faire l'objet d'une attention particulière
  439. lors de leurs exécution.
  440. * "**exp**" : Scripts d'exploitation dévolus principalement aux traitements réccurents
  441. Ces scripts sont réservés à l'exploitation courante. Il peuvent modifier le système dans le cadres de
  442. traitements réccurents.
  443. Leurs exécution est de risque modére, comme respecter une date d'execution.
  444. Il sont reservés à l'exploitation système uniquement.
  445. Dans le cas d'un traitement réccurrent pour le compte d'une application le nom doit
  446. être de la forme <app>\_<descr>.<language>
  447. * "**int**" : Scripts dédiés aux interfaces entre applications
  448. Ces scripts doivent faire l'objet d'une attention particulière car il peuvent modifier
  449. les données applicatives et peuvent être contraints par des conditions d'execution.
  450. * "**ctl**" : Script de contrôle (dévolu principalement au système de monitoring)
  451. * "**aud**" : Script d'audit ne modifiant pas le système.
  452. Ces scripts peuvent être executés sans aucun risque.
  453. * **&lt;descr&gt;** est libre, doit refléter si possible la fonction du script.
  454. * **&lt;language&gt;** est une des valeurs suivantes :
  455. "**sh**" : Script Bash.
  456. * **&lt;app&gt;** est le nom de l'application à laquelle le script est dédié.
  457. Ces scripts sont réservés à une application particulière dans le cadres de l'exploitation
  458. réccurente de l'application.
  459. ## V - Description et usage des bibliothèques
  460. ### 1 - fct\_message
  461. * **Syntaxe**: fct\_message [-cpt] [-hist] [-nolog] [-debug N] [-color Couleur] "&lt;Message à ecrire&gt;"
  462. * **Usage**: Cette fonction est à utiliser en remplacement de la commande "echo".
  463. Elle ajoute l'horadatage au message et gère la ventilation des écritures dans les differents fichiers de traces.
  464. * **Fonction**: Par défaut le message est affiché sur le terminal et est écrit dans le fichier journal **${NC\_EXPL\_LOG}/&lt;nom\_du\_script&gt;.log**
  465. Les options modifient la destination de l'écriture :
  466. * **-cpt**: Écrit en plus du journal dans le fichier de compte-rendu **${NC\_EXPL\_CPT}/&lt;nom\_du\_script&gt;.cpt**
  467. * **-hist**: Écrit uniquement dans le fichier d'historique des exécutions **${NC\_EXPL\_TRC}/&lt;nom\_du\_script&gt;.hist**
  468. * **-nolog**: Inhibe l'écritutre dans le fichier journal
  469. * **-debug N**: N'affiche pas le message sur le terminal mais uniquement dans le fichier journal, à condition
  470. que le script soit execute en mode debug de niveau equivalent à "N" via l'option "**-dbg N**".
  471. Par défaut le niveau de debug est 0, ainsi si "N" vaut zero alors le message est écrit uniquement dans le fichier journal.
  472. * **-color**: Affiche le message en couleur. Les couleurs reconues sont : vert, rouge, bleu, cyan, jaune, orange, blanc et noir
  473. ### 2 - fct\_affiche\_ligne
  474. * **Syntaxe**: fct\_affiche\_ligne [entete|pied] &lt;elements&gt;
  475. * **Usage**: Affiche un tableau sur la sortie standard et dans le fichier compte-rendu **${NC\_EXPL\_ROOT}/&lt;script&gt;.cpt**
  476. * **Fonction**: 3 étapes sont nécéssaires pour créer un tableau :
  477. * Définition du tableau
  478. * Affichage des éléments
  479. * Fermeture du tableau
  480. Ces étapes doivent impérativement être suivies et dans cet ordre.
  481. **Il n'est pas possible d'imbriquer des tableaux.**
  482. * **Définition**: Elle est réalisée par l'appel de la fonction **fct\_affiche\_ligne** avec l'argument entête. La forme est alors la suivante :
  483. fct_affiche_ligne entete "{Titre}" "{Colonne_1},{Taille_1}" "{Colonne_2},{Taille_2}" "{Colonne_3},{Taille_3}" "{Colonne_4},{Taille_4}" ...
  484. ou bien:
  485. 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}:...)"
  486. * Affichage des éléments:
  487. fct_affiche_ligne "<Element1>" "<Element2>" ...
  488. * Fermeture du tableau: Cette action permet de libérer les variables de session qui ont été créées
  489. fct_affiche_ligne pied
  490. * Exemples:
  491. fct_affiche_ligne entete "Un tableau" "C1,10" "C2,10" "c3,10"
  492. fct_affiche_ligne A B C
  493. fct_affiche_ligne 1 "" 3
  494. fct_affiche_ligne pied
  495. affichera:
  496. --------------------------------------
  497. Un tableau
  498. --------------------------------------
  499. C1 | C2 | c3
  500. --------------------------------------
  501. A |B |C
  502. 1 | |3
  503. --------------------------------------
  504. et
  505. fct_affiche_ligne entete "Un Autre tableau" "C1,10" "G1(C2,20:C3,10:C4,3)" "C5,15"
  506. fct_affiche_ligne A B C D E
  507. fct_affiche_ligne 1 "" 3 3 4
  508. fct_affiche_ligne pied
  509. affichera:
  510. ------------------------------------------------------------------------
  511. Un Autre tableau
  512. ------------------------------------------------------------------------
  513. | G1 |
  514. C1 |-----------------------------------------| C5
  515. | C2 | C3 | C4 |
  516. ------------------------------------------------------------------------
  517. A |B |C |D |E
  518. 1 | |3 |3 |4
  519. ------------------------------------------------------------------------
  520. ### 3 - fct\_erreur
  521. * **Syntaxe**: fct\_erreur &lt;N&gt;
  522. * **Usage**: Gestion des erreurs d'un script
  523. * **Fonction**: Cette fonction doit etre appelée pour sortir d'un script du socle.
  524. Elle affiche le message d'erreur associé au code qui est lu dans le fichier **${NC\_EXPL\_MSG}/&lt;script&gt;.msg**
  525. Elle exécute éventuellement une fonction rattachée, spécifiée dans ce même fichier.
  526. Elle ferme les fichiers de traces, supprime les fichiers temporaires, libère les semaphores et
  527. renvoie un code retour au script appelant.
  528. N est un entier positif dont les valeurs suivantes sont reservées :
  529. 0 : Fin normale du script
  530. 250 : <lib:fct_erreur> Appel de la bibliothèque sans le numero d'erreur (<N> non renseigne !)
  531. 251 : <lib:fct_erreur> La description de l'erreur <N> n'existe pas dans le fichier <script>.msg
  532. 252 : <lib:fct_erreur> Le fichier <script>.msg n'existe pas
  533. 253 : <lib:fct_erreur> La description de l'erreur dans le fichier <script>.msg est incorrecte
  534. 254 : <lib:fct_params> Erreur a été remontée par la bibliothèque
  535. 255 : <lib:fct_erreur> Appel de la bibliothèque avec un numero d'erreur >= 250
  536. 256 : réservé pour un futur usage
  537. * Le fichier **&lt;script&gt;.msg**: Contient les descriptions des codes erreur.
  538. * Un code par ligne de la forme:
  539. <NumErreur> | <type> | <action> | <message> ou <fonction>
  540. * **&lt;NumErreur&gt;**: Entier positif identifiant l'erreur
  541. * **&lt;type&gt;**: prend les valeurs erreur, alert ou info. Colorise le message en fonction
  542. du type respectivement rouge, orange et bleu
  543. * **&lt;action&gt;**: Action à realiser (continu, stop, exec)
  544. * **continu**: Affiche le message puis rend la main au script
  545. * **stop**: Affiche le message puis sort en erreur
  546. * **exec**: exécute la fonction puis rend la main au script
  547. * **&lt;fonction&gt;**: Fonction à exécuter. Ce champs peut contenir des variables qui seront valorisées.
  548. * **&lt;message&gt;**: Message à afficher (dans les traces et sur la sortie standard). Ce champs peut contenir
  549. des variables qui seront valorisées.
  550. ### 4 - fct\_unique\_exec
  551. * **Syntaxe**: fct\_unique\_exec [&lt;nom&gt;] [&lt;Occurences&gt;]
  552. * **Usage**: Empeche l'exécution multiple d'un code par l'acquisition de sémaphore
  553. * **Fonction**: [DOCUMENTATION MANQUANTE]
  554. ### 5 - fct\_libere\_exec
  555. * **Syntaxe**: fct\_libere\_exec [&lt;nom&gt;]
  556. * **Usage**: Libère les sémaphores
  557. * **Fonction**: [DOCUMENTATION MANQUANTE]
  558. ### 6 - fct\_usage
  559. * **Syntaxe**: fct\_usage
  560. * **Usage**: Affiche l'aide du script. Ce sont les lignes du cartouche commencant par "##"
  561. * **Fonction**: Cette fonction est uniquement à usage interne du socle. Elle est intégrée à la fonction fct\_params.
  562. ### 7 - fct\_rotation
  563. * **Syntaxe**: [DOCUMENTATION MANQUANTE]
  564. * **Usage**: [DOCUMENTATION MANQUANTE]
  565. * **Fonction**: Cette fonction est uniquement à usage interne du socle
  566. ### 8 - fctpath
  567. * **Syntaxe**: [DOCUMENTATION MANQUANTE]
  568. * **Usage**: [DOCUMENTATION MANQUANTE]
  569. * **Fonction**: Cette fonction est uniquement à usage interne du socle
  570. ### 9 - fct\_params
  571. * **Syntaxe**: fct\_params
  572. * **Usage**: Gestion des options et arguments du script
  573. * **Fonction**: Cette fonction est uniquement à usage interne du socle.
  574. Elle est appelée à l'initialisation des variables de session lors du chargement du fichier **${NC\_EXPL\_CFG}/init.conf**
  575. Cette fonction extrait les lignes de déclaration "# OPT:" et les compare aux arguments sousmis au script.
  576. Pour plus d'information voir le paragraphe III-1.1.2