BOFH/socle_bash
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Doug Le Tough 2017-07-21 09:44:49 +02:00
commit 103f54f895
18 changed files with 2950 additions and 0 deletions

159
conf/init.conf Executable file
View File

@ -0,0 +1,159 @@
##------------------------------------------------------------------------------
## Script : init.conf
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 29-06-2017
## Version : 2.1.2
## Objet : Fichier de configuration commun a tout les scripts
##
## Detail : Ce fichier contient les varaibles de fonctionement commune au script du socle
## Il est charge systematiquement au debut de chaque script
## Toute les variables initialisees ici sont nomme SH_*
##
## -----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 23-04-2014 - Emmanuel Confrere - Cre : Creation a partir de commun.conf
# qu'il doit remplacer a terme
# 1.1.0 13-05-2014 - Emmanuel Confrere - Evo : Factorisation du code
# Amelioration de la lisibilite et ajout de commentaire
# Passage de certaine variable en heritage
# 1.2.0 13-05-2014 - Emmanuel Confrere - Evo : Ajout de message de debug
# 1.3.0 16-04-2015 - Daniel Frochtmann - Evo : Ajout semaphore pour controler les executions
# multiples (SH_CPT_SEMAPHORE)
# 1.4.0 22-09-2015 - Emmanuel Confrere - Evo : Possibilite de defferencier les retentions entre les fichier cpt et log
# 2.0.0 10-02-2016 - Emmanuel Confrere - Evo : Integration au socle DTSI via Puppet
# 2.0.1 16-03-2016 - Emmanuel Confrere - Ano : Perte de la variable SH_RETENTION (Cf. DBA-2088)
# 2.1.0 24-03-2017 - Emmanuel Confrere - Evo : Changement du nom du serveur de batch
# 2.1.1 27-06-2017 - Emmanuel Confrere - Ano : Fonctionnement inattendu sous Bash 3.2.25
# la fonction logname ne renvoi rien ?
# 2.1.2 29-06-2017 - Emmanuel Confrere - Ano : Erreur : logname() renvoi null si connexion via sshd
# Remplacement de logname() par /etc/proc/self/loginuid
## -----------------------------------------------------------------------------
## Ce fichier contient les varaibles de fonctionement commune au script du socle
## Il est charge systematiquement au debut de chaque script
## Toute les variables initialisees ici sont nomme SH_*
## -----------------------------------------------------------------------------
# - Init variables
# - --------------
# - Elements d infrastructure et systeme
[ "`hostname`" = "sousetsuken" ] && SH_SRVDEP="oui" || SH_SRVDEP="non"
SH_OS_TYPE=`uname -s`
SH_IDLOGUSER=`cat /proc/self/loginuid`
SH_LOGUSER=`grep -E "[^:]*:[^:]:${SH_IDLOGUSER}" /etc/passwd|cut -d":" -f1`
SH_EXECUSER=${LOGNAME}
SH_PATH=${PATH}
# - Identification de la session de travail
# - ---------------------------------------
# La variable SH_SESSION_ID permet d identifier une session de travail.
# Il s agit d un identifiant unique permentant de reunir dans une unite commune
# les objets trace, journaux , historique ... Cette variable est partage par tout
# les shell appele en aval d un shell pere. La variable SH_SESSION_ID est initialise
# qu au premier chargement de init.conf
# L initialisation de certainne variable sont dependante de cette premiere initialisation
# pour permetre l heritage des parametres au sous-shell appele.
SH_TIME_STAMP=`date "+%x %X"` # Horrodatage pour l historique
SH_TIMES=`date +"%s"` # Horrodatage pour identification
SH_OSPID=$$ # Numero de processus
SH_SESSION_IDP="${SH_TIMES}_${SH_OSPID}"
# La variable SH_SESSION_ID est initialise que la premiere fois
[ -z "${SH_SESSION_ID}" ] && SH_SESSION_ID="${SH_SESSION_IDP}"
# La variable SH_FIRSTTIME permet de savoir si l execution courante de init.conf
# est issu d un appel depuis un script ou d un lancement manuel depuis le shell.
[ "${SH_SESSION_IDP}" = "${SH_SESSION_ID}" ] && SH_FIRSTTIME="oui" || SH_FIRSTTIME="non"
# - Localistaion du script, pour afficher l'aide si
# necessaire.Localisation defini par $SH_DIR/$SH_PROG
SH_PROG=`which $0 2>&1`
SH_DIR=`dirname ${SH_PROG}`
[ "${SH_DIR}" = "." ] && SH_DIR=`pwd`
SH_PROG=`basename ${SH_PROG}`
SH_PROG_VERSION=`grep "^## Version *:" ${SH_DIR}/${SH_PROG}|cut -d: -f2|sed 's/ *//g'`
SH_PARAM="$*"
# - Initialisationdes fichiers de trace, compte-rendu, message,
# historique, configuration specifique, fichier de semaphore
SH_FICTRC="${NC_EXPL_HST}/`echo ${SH_PROG}|cut -d"." -f1`.hist"
SH_FICMSG="${NC_EXPL_MSG}/`echo ${SH_PROG}|cut -d"." -f1`.msg"
SH_FICCFG="${NC_EXPL_CFG}/`echo ${SH_PROG}|cut -d"." -f1`.conf"
SH_FICSEM="/dev/shm/`echo ${SH_PROG}|cut -d"." -f1`.sem"
[ "${SH_FIRSTTIME}" = "oui" ] && SH_FICLOG="${NC_EXPL_LOG}/`echo ${SH_PROG}|cut -d"." -f1`_${SH_SESSION_IDP}.log"
[ "${SH_FIRSTTIME}" = "oui" ] && SH_FICCPT="${NC_EXPL_CPT}/`echo ${SH_PROG}|cut -d"." -f1`_${SH_SESSION_IDP}.cpt"
# - initialisation des variables commune aux scripts
# Ces variable peuvent etre surcharge ou modifier dans le fichier de configuration specifique du script
# SH_FICCFG mais dans ce cas il n y auras plus d heritage.
[ "${SH_FIRSTTIME}" = "oui" ] && SH_RETENTION_CPT=8 # Retention des fichiers cpt en jours par defaut
[ "${SH_FIRSTTIME}" = "oui" ] && SH_RETENTION_LOG=8 # Retention des fichiers trc en jours par defaut
[ "${SH_FIRSTTIME}" = "oui" ] && SH_SILENCE="non" # Mode d affichage silencieu (Valeur par default)
[ "${SH_FIRSTTIME}" = "oui" ] && SH_NIV_DEBUG=0 # Debug inactif par defaut
[ "${SH_FIRSTTIME}" = "oui" ] && SH_AFF_SID="non" # Affichage du numero de session dans fct_message et fct_erreur
# Les variable prefixe avec F sont utilise pour proteger l initialisation des variables principales (sans le F)
# Lorsque qu un script initialise une des ce variables dans le fichier de configuration specifique au script
# alors il faut ignorer les initialisation specifique qui pourrais etre effectuer par les scripts appeles par ce dernier.
SH_RETENTION_FLOG=${SH_RETENTION_LOG}
SH_RETENTION_FCPT=${SH_RETENTION_CPT}
SH_FSILENCE=${SH_SILENCE}
# - Parallelisation d execution des scripts.
# - Par defaut seul une occurance active d un meme script
# - Le controle d execution concurrente est realiase par la lib semaphore.lib
SH_CPT_SEMAPHORE=1 # Valeur d execution du semaphore par defaut
# - Indentation des messages affiche par fct_message
# pour ameliore la lisibilite des traces
# La valeur de la variable SH_INDENT_MSG est diminuer par fct_erreur(stop)
[ "${SH_FIRSTTIME}" = "non" ] && SH_INDENT_MSG="${SH_INDENT_MSG} " || SH_INDENT_MSG=""
# - Connection a la base de referencement
[ -z "${SH_CNX_REF}" ] && SH_CNX_REF=${SH_CNX_REF:="cmdb/IRji_5#1O@refpro"}
# Globalisation des variables
export SH_FICLOG SH_FICCPT SH_CNX_REF SH_INDENT_MSG SH_SESSION_ID SH_NIV_DEBUG SH_SILENCE
export SH_RETENTION_CPT SH_RETENTION_LOG SH_LOGUSER SH_EXECUSER
# - Chargement de l'environement specifique au script
if [ -f ${SH_FICCFG} ]
then
fct_message -debug 0 "Chargement de fichier de configuration : ${SH_FICCFG}"
. ${SH_FICCFG}
fi
# - Remise en etat des variables protegees
if [ "${SH_FIRSTTIME}" = "oui" ]
then
# - Les variables peuvent etre changees dans le fichier specifique lors de la premiere inittialisation
# - Cependant pour conserve la compatibilte acsendante la variable SH_RETENTION doit etre controlee
# - Si cette derniere est non vide alors c est qu elle a ete utilise dans le fichier de configuration specifique
# - on doit alors initialiser les nouvelles variables avec cette valeur ...
# - Note : SH_RETENTION est obsolete et ne doit plus etre utilise dans les scripts
# Cette variable a ete remplace par SH_RETENTION_CPT et SH_RETENTION_LOG
if [ -n "${SH_RETENTION}" ]
then
SH_RETENTION_LOG=${SH_RETENTION}
SH_RETENTION_CPT=${SH_RETENTION}
else
SH_RETENTION=8 # Valeur par defaut, conserve pour compatibilite ascendante
fi
export SH_RETENTION
else
SH_RETENTION_LOG=${SH_RETENTION_FLOG}
SH_RETENTION_CPT=${SH_RETENTION_FCPT}
SH_SILENCE=${SH_FSILENCE}
fi
# - Rotation des fichiers de compte-rendu et de trace
[ "${SH_FIRSTTIME}" = "oui" ] && fct_rotation ${SH_FICCPT} ${SH_RETENTION_CPT}
[ "${SH_FIRSTTIME}" = "oui" ] && fct_rotation ${SH_FICLOG} ${SH_RETENTION_LOG}
# - Marque le debut de l execution du programme
fct_message -hist "(${SH_SESSION_ID}) : Debut du script"
fct_message -hist "(${SH_SESSION_ID}) : Parametre : ${SH_PARAM}"
[ "${SH_FIRSTTIME}" = "oui" -a ${SH_NIV_DEBUG} -gt 0 ] && fct_message -color rouge "ATTENTION - Mode debug activer : Niveau de trace ${SH_NIV_DEBUG}"
# - Liberation des variables locale
unset SH_TIMES SH_OSPID SH_TIME_STAMP SH_FIRSTTIME SH_RETENTION_FLOG SH_RETENTION_FCPT SH_FSILENCE SH_IDLOGUSER
# - Gestion des options et argument
fct_params ${*}

22
conf/shell-env/lisezmoi.txt Executable file
View File

@ -0,0 +1,22 @@
Ce dossier contient les fichiers d initialisation d'environement.
Il sont charger par le script /etc/profile.d/socle_bash_dtsi.sh.
Le nom des fichiers sont de la forme profile_<type>_<sous-type>.env.
<type> prend une des valeurs suivante :
- "socle" : profile dependant du socle
- "grp" : Profile lie au groupe Linux <sous-type>
- "app" : profile indepandant du socle
<sous-type> est libre sauf pour le type "grp". Dans ce cas
la valeurs doit etre le nom d un groupe Linux existant. Le fichiers
d'environement seras alors source uniquemement si le compte de connexion
est membre du groupe.
Les fichiers de ce dossiers sont sources dans l ordre suivant :
1 - le fichier profile_init.env
2 - les fichiers profile_socle_*.env
3 - les fichiers profile_grp_*.env (En fontion des groupe dont est membre le compte de connexion)
4 - les fichiers profile_app_*.env
Attention : Les fichiers present ici, doivent etre gere par Puppet.

74
conf/shell-env/profile_init.env Executable file
View File

@ -0,0 +1,74 @@
##----------------------------------------------------------------------------
## Script : profile_init.env
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 11-07-2017
## Version : 1.2.3
## Objet : Initialisation des variables d environements du socle
## Chargement des librairie bash
## Initialisation du PATH
##
## Fonctionnement : Ce script est depose dans le repertoire ${NC_EXPL_ROOT}/conf/shell-env
## avec les droits suivant : 0644 asr:asr
##
## Il initialise l environement globale du socles, charge les librairie et
## initialise les PATH et les alias commun.
##
## Il est appele par le script /etc/profile.d/dtsi.sh
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Cre : A partir de l ancien fichier .dbenv
# 1.0.1 21-07-2016 - Stephane Tourneyre - Ano : Ajout ancien path pour man ADMLINUX-1176
# 1.1.0 28-07-2016 - Emmanuel Confrere - Evo : Normalisation : Versionnage Sementique
# 1.2.0 05-04-2017 - Emmanuel Confrere - Evo : Ajout de la variable NC_EXPL_NFS
# 1.2.1 07-04-2017 - Emmanuel Confrere - Ano : Definition du prompt
# 1.2.2 11-04-2017 - Emmanuel Confrere - Ano : Suppression de la definition du Prompt
# 1.2.3 11-07-2017 - Emmanuel Confrere - Ano : Description du fonctionnement erronee.
# ----------------------------------------------------------------------------
# -- Initialisation des variable globale NC_*
#
NC_EXPL_LIB=${NC_EXPL_ROOT}/lib
NC_EXPL_BIN=${NC_EXPL_ROOT}/bin
NC_EXPL_LOG=${NC_EXPL_ROOT}/log
NC_EXPL_HST=${NC_EXPL_ROOT}/hist
NC_EXPL_CPT=${NC_EXPL_ROOT}/cpt
NC_EXPL_TMP=${NC_EXPL_ROOT}/tmp
NC_EXPL_DAT=${NC_EXPL_ROOT}/dat
NC_EXPL_MOD=${NC_EXPL_ROOT}/mod
NC_EXPL_CFG=${NC_EXPL_ROOT}/conf
NC_EXPL_MSG=${NC_EXPL_ROOT}/msg
NC_EXPL_MAN=${NC_EXPL_ROOT}/man
#[ `df|grep -c "srv-nfs"` -eq 1 ] && NC_EXPL_NFS="oui" || NC_EXPL_NFS="non"
NC_EXPL_NFS="non"
# -- Export des variables
#
export NC_EXPL_LOG NC_EXPL_HST NC_EXPL_TMP NC_EXPL_LIB NC_EXPL_DAT NC_EXPL_MAN
export NC_EXPL_CPT NC_EXPL_BIN NC_EXPL_CFG NC_EXPL_MSG NC_EXPL_MOD NC_EXPL_NFS
# -- Chargement des librairies
#
for lib in `find ${NC_EXPL_LIB} -name \*.lib`
do
. ${lib}
done
# Ajout du repertoire des scripts au Path
# bin -> Repertoire des script dba
fctpath "${NC_EXPL_BIN}" PATH :
fctpath '/usr/local/share/man' MANPATH :
fctpath '/usr/share/man/fr' MANPATH :
fctpath '/usr/share/man/overrides' MANPATH :
fctpath '/usr/share/man/' MANPATH :
fctpath "${NC_EXPL_MAN}" MANPATH :
# -- Definition des alias
#
alias bbin='cd ${NC_EXPL_ROOT}/bin'
alias type='whence -v'
alias log='cd ${NC_EXPL_LOG}'
alias hist='cd ${NC_EXPL_HST}'

793
how_to_use_bash_socle.txt Executable file
View File

@ -0,0 +1,793 @@
-- ----------------------------------------------------------------- --
-- Aide memoire pour l ecriture de script Bash sous le socle DTSI --
-- ----------------------------------------------------------------- --
-- --------------------------------------------------------
-- Sommaire
--
-- I - Arborescence du socle
-- II - Variables d environement
-- 1 - Variables globales
-- 2 - Variables globales specifiques
-- 2.1 Pour les serveurs BDD
-- 3 - Variables de session
-- III - Utilisation du socle bash
-- 1 - Cartouche
-- 1.1 Elements du cartouche
-- 1.2 Versionnement semantique
-- 1.2.1 Usage
-- 1.2.2 Format
-- 1.2.3 Semantique
-- 2 - Initialisation du socle
-- 3 - Structure d un script
-- 4 - Actions realisees au lancement d un script
-- IV - Nomenclature
-- 1 - Fichiers temporaires
-- 2 - Nom des executables
-- V - Description et usage des Librairies
-- 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
-- VI - Deploiement via puppet
-- --------------------------------------------------------
I - Arborescence du socle
---------------------
La racine des dossiers utilisee par le Socle DTSI est definie par la variable d'environement NC_EXPL_ROOT.
Cette derniere est initialisee a la connexion par l appel au script /etc/profile.d/dtsi.sh
Cette arborescence est utilisee pour tous scripts Bash ou Ruby, ainsi que les variables d'environement qui
en decoulent.
Sous l arborescence ${NC_EXPL_ROOT} on trouve les dossiers suivants :
+-----------------+-----------------------------------------------------------------------------------------------+
| Dossier | Description |
+-----------------+-----------------------------------------------------------------------------------------------+
| {Racine}/bin | Contient les binaires (scripts Bash et Ruby, eventuellement C) |
| {Racine}/conf | Contient les fichiers de configuration des scripts, ainsi que du socle |
| {Racine}/cpt | Contient les fichiers de comtpe rendu generes par les script (purge auto , 8 jours par defaut)|
| {Racine}/dat | Contient les fichiers de donnees geres par les scripts |
| {Racine}/hist | Contient l historique d execution des scripts (pas de purge) |
| {Racine}/lib | Contient les librairies charge a la connexion par le socle |
| {Racine}/log | Contient les fichiers de logs d execution des scripts (purge auto , 8 jours par defaut ) |
| {Racine}/man | Contient les fichiers d aide des scripts pour l utilitaire "man" |
| {Racine}/mod | Contient les fichiers modeles a usage des scripts |
| {Racine}/msg | Contient les fichiers de message pour les scripts pour la librairie "fct_erreur" |
| {Racine}/tmp | Continet les fichiers temporaires des scripts du socle |
+-----------------+-----------------------------------------------------------------------------------------------+
Note : Sous chaque dossier vous trouverez un fichier texte lisezmoi.txt decrivant l usage du repertoire.
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 definies et exportees a la connexion. Elles sont donc utilisables
par tous les scripts, mais elles ne sont pas modifiables.
Les variables de session sont definies a l'execution d un script et lui sont propre.
Cependent certaines d entre elles sont transmises au script enfant
- 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 a 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 definit dans "init.conf" seras utlisee sauf
si elle as ete surchargee dans le fichier de configuration du script.
Il y a cependant une specificite pour SH_RETENTION_CPT et SH_RETENTION_LOG, ces variables sont defini une et une seul fois
lors de la premiere initialisation. Ce qui signinfie qu'un script qui aurait surcharge ces variables, ignorera l initialisation
de ces variable si il est appeler par un autre script.
1 - Variables globales generals
+-------------------+----------------------------+
| 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 definie dans le fichier "dtsi.sh"
Les autres variables NC_~ sont definie dans le fichier "profile_init.env"
2 - Variables globales specifiques
2.1 Pour les serveurs BDD
+--------------------+------------------------------------------+
| Nom | Usage |
+--------------------+------------------------------------------+
| NC_EXPL_SQL | Pointe vers {Racine}/sql |
| NC_EXPL_DBTAB | Pointe vers le fichier .dbtab |
| NC_EXPL_DBEDITEUR | Vaut : "oracle" ou "postgres" ou "mysql" |
+--------------------+------------------------------------------+
Ces variables sont definie dans le fichier "profile_socle_database.env"
3 - Variables de session
Cette liste n est pas exhaustive, seules les principales variables sont citees.
+--------------------+-------------------------------------------------------------------------------+
| Nom | Usage |
+--------------------+-------------------------------------------------------------------------------+
| SH_SESSION_ID | Numero unique d execution : <TimeStamp>_<PId> |
| SH_SILENCE | Acitve 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 executant le script |
| SH_DIR | Dossier hebergeant 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 defaut. Niveau d affichage dans les fichiers de trace |
| SH_RETENTION_CPT | Vaut 8 par defaut. Duree de retention en jours des fichiers de compte-rendu |
| SH_RETENTION_LOG | Vaut 8 par defaut. Duree de retention en jours des fichiers de trace |
+--------------------+-------------------------------------------------------------------------------+
Remarque : Les variables SH_SILENCE et SH_NIV_DEBUG sont controlees par les options "-s" et "-dbg"
si la gestion des options a ete activee.
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 commencant par 2 "#" sont utilisees pour generer l aide, leur maintient est donc necessaire
pour garantir la fiabilite 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-donnees
- <Action> : peut prendre les valeurs suivantes -> cre, ano, evo, typo
cre : Creation du script.
evo : Evolution du script -> Ajout de nouvelles fonctionnalites, Amelioration du code.
ano : Correction du code suite a un comportement inattendu.
typo : Ajout de commentaires, de texte ou correction gramatical sans influence sur le code.
- <Auteur> : <Prenom> <Nom>
- <Version> : Format x.y.z
Pour le suivie des versions on utilisera le versionnement semantique (voir paragraphe III-1.2).
1.1.2 Paragraphe
- Mise a jour : Ce paragraphe est utilise pour suivre l evolution des versions. La derniere version en
vigueur doit etre reportee dans le premier paragraphe.
- Dependance : Permet de definir la liste ainsi que la version des scripts qui sont appeles.
Dans le cas d un changement cela permet de connaitre les scripts qui sont impactes.
Pour le moment aucun script n exploite cette meta-donnee.
Present pour un future usage.
- Liste des options : La declaration des options n est pas obligatoire.
Si aucune declaration n est presente alors la librairie params.lib ne fait aucune action.
Dans ce cas les options par defaut -h, -log, -hist, -cpt, -s et -dbg ne seront pas disponible.
Si le script ne necessite pas d option mais que l on souhaite disposer des options par defaut, il
faudras declarer une option bidon. ex: "# @OPT: f:bidon::::::"
Si la declaration existe alors le socle gerera les parametres en entree du script, ainsi que
les options par defaut -h, -log, -hist, -cpt, -s et -dbg. Ces mots cle sont reserve et ne
peuvent pas etre utilise par le script.
La declaration est realise dans le paragraphe "Liste des options et arguments". Chaque
option est identifiee par l entete de ligne "# @OPT:" suivi de la description.
La description consiste en une liste de parametres separes par ":"
<type>:<nom>:<var>:<nb_arg>:<def_val>:<OptE>:<OptI>:<ctl_val>
L ordre des parametre est fige et tous doivent etre presents.
8 champs sont obligatoires, soit 7 caracteres ":" (on ne compte pas le caracatere ":" suivant @OPT).
Exemple de declaration 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:
<type> : Propriete de l attribu defini par l agregation des lettres suivantes
f -> Option falcultative
b -> Booleen
o -> Option obligatoire
M -> Argument transforme en majuscule
<nom> : nom de l option (sans le tiret) Attention le nom de l option est senssible a la casse.
<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".
<nb_arg> : nombre d arguments attendus de la forme "min/max", "min/", "max" ou ""
si vide ou "0" alors l option est booleene.
la forme "min/" considere le nombre max non determine (infini)
<def_val>: Valeur par defaut assignee a <var>
Fonctionne si <nb_arg> vaut 0/1 1/1
<OptE> : Liste des options mutellement exclusives separees par une virgule.
<OptI> : Liste des options inclusives separees par une virgule.
Lors de l initialisation les marqueurs "@OPT" sont lues et analysees.
Le resultat est compare aux arguments et options sousmis au script
et les variables suivantes son initialisees ...
- SH_OPTION_<nom> : Initialisee a "1" (Vrai) ou "0" (Faux) selon que l option est respectivement utilise ou non.
Il existe toujours une variable par option declaree. Ceci concerne aussi les options par defaut
gere par la librairie params.lib
- SH_ARG_<nom> : Cette variable existe uniquement si le champ <var> est null et si le type n est pas booleen.
Par defaut elle est initialisee a null ou avec la valeur <def_val>
Si le champ <var> est renseigne, alors SH_ARG_<nom> est remplacee pas <var>.
Si l option associee peut prendre plusieurs arguments, alors les variables
SH_ARG_<nom> ou <var> sont des tableaux dont l index commence a zero.
La taille du tableau peut etre recuperee via ${#SH_ARG_<nom>[*]} ou ${#<var>[*]}.
Les option -h, -s, -log [id], -hist [N] et -dbg N
sont prises en charge automatiquement. Ces noms sont donc reserves.
Les options par defaut realisent 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 : <Libre>_${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'

79
install.sh Executable file
View File

@ -0,0 +1,79 @@
#!/bin/bash
#
# Script d'installation du socle bash Tetalab
#
# 21/07/2017 - Doug Le Tough
#
PROFILE_DIR=/etc/profile.d
PROFILE_FILE=tetalab.sh
INSTALL_DIR=$(dirname $0)
NC_EXPL_ROOT=/opt/tetalab
export NC_EXPL_ROOT
NC_EXPL_LIB=${NC_EXPL_ROOT}/lib
NC_EXPL_BIN=${NC_EXPL_ROOT}/bin
NC_EXPL_LOG=${NC_EXPL_ROOT}/log
NC_EXPL_HST=${NC_EXPL_ROOT}/hist
NC_EXPL_CPT=${NC_EXPL_ROOT}/cpt
NC_EXPL_TMP=${NC_EXPL_ROOT}/tmp
NC_EXPL_DAT=${NC_EXPL_ROOT}/dat
NC_EXPL_MOD=${NC_EXPL_ROOT}/mod
NC_EXPL_CFG=${NC_EXPL_ROOT}/conf
NC_EXPL_MSG=${NC_EXPL_ROOT}/msg
NC_EXPL_MAN=${NC_EXPL_ROOT}/man
function exit_on_error
{
ERROR="$@"
echo -e "\033[91m*** ${ERROR} ***\033[0m"
exit 1
}
if [ ! $(id -u) -eq 0 ]; then
exit_on_error "Ce script doit être exécuté par l'utilisateur root"
fi
echo -e "\033[93mInstallation du socle bash Tetalab:\033[0m"
echo -e "\033[93m * Création du répertoire racine: ${NC_EXPL_ROOT}\033[0m"
echo -e "\033[93m * Création des répertoires:\033[0m"
for DIR in $NC_EXPL_LIB $NC_EXPL_BIN $NC_EXPL_LOG $NC_EXPL_HST $NC_EXPL_CPT $NC_EXPL_TMP $NC_EXPL_DAT $NC_EXPL_MOD $NC_EXPL_CFG $NC_EXPL_MSG $NC_EXPL_MAN;
do
echo -e " * ${DIR}"
sudo mkdir -p ${DIR};
RET_VAL=$?
if [ ! ${RET_VAL} -eq 0 ]; then
exit_on_error "Erreur lors de la création des répertoires"
fi
done
echo -e "\033[93m * Copie des fichiers de profile dans ${PROFILE_DIR}\033[0m"
cp ${INSTALL_DIR}/${PROFILE_FILE} ${PROFILE_DIR}
RET_VAL=$?
if [ ! ${RET_VAL} -eq 0 ]; then
exit_on_error "Erreur lors de la copie des fichiers de profile"
fi
echo -e "\033[93m * Copie des fichiers de configuration dans ${NC_EXPL_CFG}\033[0m"
cp -R ${INSTALL_DIR}/conf/* ${NC_EXPL_CFG}
RET_VAL=$?
if [ ! ${RET_VAL} -eq 0 ]; then
exit_on_error "Erreur lors de la copie des fichiers de configuration"
fi
echo -e "\033[93m * Copie des bibliothèques dans ${NC_EXPL_LIB}\033[0m"
cp -R ${INSTALL_DIR}/lib/* ${NC_EXPL_LIB}
RET_VAL=$?
if [ ! ${RET_VAL} -eq 0 ]; then
exit_on_error "Erreur lors de la copie des bibliothèques"
fi
echo -e "\033[93m * Copie des scripts dans ${NC_EXPL_BIN}\033[0m"
cp -R ${INSTALL_DIR}/bin/* ${NC_EXPL_BIN}
RET_VAL=$?
if [ ! ${RET_VAL} -eq 0 ]; then
exit_on_error "Erreur lors de la copie des scripts"
fi

169
lib/affiche-ligne.lib Executable file
View File

@ -0,0 +1,169 @@
##----------------------------------------------------------------------------
## Script : affiche_ligne.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 13-04-2017
## Version : 1.1.0
## Objet : Permet d'afficher sur la sortie standard un texte sous forme de tableau
##
## Fonction : fct_affiche_ligne
##
## Detail : Definition de l'entete du tableau :
## fct_affiche_ligne entete "{Titre}" "{Colonne_1},{Taille_1}" "{Colonne_2},{Taille_2}" "{Colonne_3},{Taille_3}" "{Colonne_4},{Taille_4}" ...
## fct_affiche_ligne entete "{Titre}" "Groupe1({Colonne_1},{Taille_1}:{Colonne_2},{Taille_2})" "{Colonne_3},{Taille_3}" "Groupe2({Colonne_4},{Taille_4}:...)" ...
##
## Affichage des lignes du tableau :
## fct_affiche_ligne "${Variable_1}" "${Variable_2}" "${Variable_3}" "${Variable_4}" ...
##
## Affichage du pied
## fct_affiche_ligne pied
##
## Affichage d une ligne de separation
## fct_affiche_ligne sep
##
## Les trois forme de declaration doivent apparaitre dans l ordre :
## fct_affiche_ligne entete -> Initialise le tableau
## fct_affiche_ligne -> Affiche une ligne
## fct_affiche_ligne pied -> Libere la configuration du tableau
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Cre : Reprise du script du socle Oracle
# 1.1.0 13-04-2017 - Emmanuel Confrere - Evo : Ajout de l option "sep"
##----------------------------------------------------------------------------
function fct_affiche_ligne
{
local L_NB_PARAM=$#
local L_PARAM=""
local L_IDX_PARAM=1
local L_IDX_COL=1
local L_MESSAGE=""
local L_ENTETE="non"
local L_PIED="non"
local L_SEP="non"
local L_GROUPE="non"
local L_GRP_NOM=""
local L_TAILLE_GRP=0
local L_COL_LISTE=""
local L_COL=""
local L_GRP_MESS_L1=""
local L_GRP_MESS_L2=""
local L_GRP_MESS_L3=""
local L_OLD_IFS=""
# - recuperation des parametres en entree
[ -n "${IFS}" ] && L_OLD_IFS=${IFS}
IFS="@"
while [ ${L_IDX_PARAM} -le ${L_NB_PARAM} ]
do
L_PARAM[${L_IDX_PARAM}]=`echo $1|cut -d, -f1`
[ "${L_PARAM[1]}" = "entete" ] && L_ENTETE="oui"
[ "${L_PARAM[1]}" = "pied" ] && L_PIED="oui"
[ "${L_PARAM[1]}" = "sep" ] && L_SEP="oui"
if [ "${L_ENTETE}" = "oui" -a ${L_IDX_PARAM} -gt 2 ]
then
if [ `echo $1|grep -c "("` -eq 1 ]
then
L_GROUPE="oui"
L_TAILLE_GRP=0
L_GRP_NOM=`echo $1|cut -d "(" -f1`
L_COL_LISTE=`echo $1|sed 's/:/@/g;s/^.*(//;s/)//'`
for L_COL in ${L_COL_LISTE}
do
L_PARAM[${L_IDX_PARAM}]=`echo ${L_COL}|cut -d, -f1`
SH_TAILLE_COL[${L_IDX_COL}]=`echo ${L_COL}|cut -d, -f2`
[ -z "${SH_TAILLE_COL[${L_IDX_COL}]}" ] && SH_TAILLE_COL[${L_IDX_COL}]=${#L_PARAM[${L_IDX_PARAM}]}
[ ${SH_TAILLE_COL[${L_IDX_COL}]} -eq 0 ] && SH_TAILLE_COL[${L_IDX_COL}]=${#L_PARAM[${L_IDX_PARAM}]}
SH_TAILLE_COL[${L_IDX_COL}]=$(( ${SH_TAILLE_COL[${L_IDX_COL}]} + 2 ))
SH_TAILLE_TABLEAU=$(( ${SH_TAILLE_TABLEAU} + ${SH_TAILLE_COL[${L_IDX_COL}]} ))
L_TAILLE_GRP=$(( ${L_TAILLE_GRP} + ${SH_TAILLE_COL[${L_IDX_COL}]} + 1 ))
[ ${L_IDX_PARAM} -eq ${L_NB_PARAM} ] && L_GRP_MESS_L3="${L_GRP_MESS_L3}`fct_format "${L_PARAM[${L_IDX_PARAM}]}" ${SH_TAILLE_COL[${L_IDX_COL}]} c`"
[ ${L_IDX_PARAM} -ne ${L_NB_PARAM} ] && L_GRP_MESS_L3="${L_GRP_MESS_L3}`fct_format "${L_PARAM[${L_IDX_PARAM}]}" ${SH_TAILLE_COL[${L_IDX_COL}]} c`|"
((L_IDX_COL++))
((L_IDX_PARAM++))
((L_NB_PARAM++))
done
((L_TAILLE_GRP--))
((L_IDX_PARAM--))
((L_NB_PARAM--))
L_GRP_MESS_L1="${L_GRP_MESS_L1}`fct_format "${L_GRP_NOM}" ${L_TAILLE_GRP} c`|"
L_GRP_MESS_L2="${L_GRP_MESS_L2}`fct_format "-" ${L_TAILLE_GRP} r`|"
else
SH_TAILLE_COL[${L_IDX_COL}]=`echo $1|cut -d, -f2`
[ -z "${SH_TAILLE_COL[${L_IDX_COL}]}" ] && SH_TAILLE_COL[${L_IDX_COL}]=${#L_PARAM[${L_IDX_PARAM}]}
[ ${SH_TAILLE_COL[${L_IDX_COL}]} -eq 0 ] && SH_TAILLE_COL[${L_IDX_COL}]=${#L_PARAM[${L_IDX_PARAM}]}
SH_TAILLE_COL[${L_IDX_COL}]=$(( ${SH_TAILLE_COL[${L_IDX_COL}]} + 2 ))
SH_TAILLE_TABLEAU=$(( ${SH_TAILLE_TABLEAU} + ${SH_TAILLE_COL[${L_IDX_COL}]} ))
if [ ${L_IDX_PARAM} -eq ${L_NB_PARAM} ]
then
L_GRP_MESS_L1="${L_GRP_MESS_L1}`fct_format " " ${SH_TAILLE_COL[${L_IDX_COL}]} c`"
L_GRP_MESS_L2="${L_GRP_MESS_L2}`fct_format "${L_PARAM[${L_IDX_PARAM}]}" ${SH_TAILLE_COL[${L_IDX_COL}]} c`"
L_GRP_MESS_L3="${L_GRP_MESS_L3}`fct_format " " ${SH_TAILLE_COL[${L_IDX_COL}]} c`"
else
L_GRP_MESS_L1="${L_GRP_MESS_L1}`fct_format " " ${SH_TAILLE_COL[${L_IDX_COL}]} c`|"
L_GRP_MESS_L2="${L_GRP_MESS_L2}`fct_format "${L_PARAM[${L_IDX_PARAM}]}" ${SH_TAILLE_COL[${L_IDX_COL}]} c`|"
L_GRP_MESS_L3="${L_GRP_MESS_L3}`fct_format " " ${SH_TAILLE_COL[${L_IDX_COL}]} c`|"
fi
((L_IDX_COL++))
fi
fi
shift
((L_IDX_PARAM++))
done
[ "${L_ENTETE}" = "oui" ] && SH_TAILLE_TABLEAU=$(( ${SH_TAILLE_TABLEAU} + ${L_NB_PARAM} - 3 ))
# -- Affichage de la ligne
# -- ---------------------
L_IDX_PARAM=1
L_IDX_COL=1
L_MESSAGE=""
# -- Affichage de l entete du tableau
if [ "${L_ENTETE}" = "oui" ]
then
fct_message -cpt "`fct_format "-" ${SH_TAILLE_TABLEAU} r`"
fct_message -cpt -color jaune "`fct_format "${L_PARAM[2]}" ${SH_TAILLE_TABLEAU} c`"
fct_message -cpt "`fct_format "-" ${SH_TAILLE_TABLEAU} r`"
if [ "${L_GROUPE}" = "oui" ]
then
fct_message -cpt "${L_GRP_MESS_L1}"
fct_message -cpt "${L_GRP_MESS_L2}"
fct_message -cpt "${L_GRP_MESS_L3}"
else
fct_message -cpt "${L_GRP_MESS_L2}"
fi
fct_message -cpt "`fct_format "-" ${SH_TAILLE_TABLEAU} r`"
export SH_TAILLE_TABLEAU SH_TAILLE_COL
L_IDX_PARAM=3
fi
# -- Affichage du corp du tableau
while [ ${L_IDX_PARAM} -le ${L_NB_PARAM} -a "${L_PIED}" = "non" -a "${L_ENTETE}" = "non" ]
do
if [ ${L_IDX_PARAM} -eq ${L_NB_PARAM} ]
then
L_MESSAGE="${L_MESSAGE}`fct_format "${L_PARAM[${L_IDX_PARAM}]}" ${SH_TAILLE_COL[${L_IDX_COL}]} d`"
else
L_MESSAGE="${L_MESSAGE}`fct_format "${L_PARAM[${L_IDX_PARAM}]}" ${SH_TAILLE_COL[${L_IDX_COL}]} d`|"
fi
((L_IDX_PARAM++))
((L_IDX_COL++))
done
[ "${L_PIED}" = "non" -a "${L_ENTETE}" = "non" ] && fct_message -cpt "${L_MESSAGE}"
# -- Affichage du pied et liberation des variables de gestion
if [ "${L_PIED}" = "oui" ]
then
fct_message -cpt "`fct_format "-" ${SH_TAILLE_TABLEAU} r`"
unset SH_TAILLE_TABLEAU SH_TAILLE_COL
fi
# -- Affichage d une ligne de separation
[ "${L_SEP}" = "oui" ] && fct_message -cpt "`fct_format "-" ${SH_TAILLE_TABLEAU} r`"
[ -n "${L_OLD_IFS}" ] && IFS=${L_OLD_IFS} || unset IFS
return 0
}
typeset -Ffx fct_affiche_ligne

121
lib/erreur.lib Executable file
View File

@ -0,0 +1,121 @@
##----------------------------------------------------------------------------
## Script : erreur.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 06-04-2017
## Version : 1.2.2
## Objet : Affiche le message d erreur associe au code et execute
## eventuellement une fonction rattachee.
##
## Fonction : fct_erreur Nombre
##
## Detail : Le message, et eventuellement la fonction sont recherche dans
## le fichier "${NC_EXPL_MSG}/nom_du_script.msg". Chaque ligne de ce fichier
## correspond a la definition d une erreur : Numero_err,Type,Fonction,Message
## Les parametre sont separe par le caractere "|".
## Type peut prendre les valeurs "info" ou "erreur"
## La fonction peut etre "stop","continu" ou defini dans le shell appelant.
## Numero_err est le code de retour du script (les numero de 250 a 256 sont reseves).
##
## Si numero_err vaut zero CodeRet=0 Fonction="stop"
## Si numero_err non renseigne CodeRet=250 Fonction="stop"
## Si numero_err n est pas trouver dans le fichier ".msg" CodeRet=251 Fonction="stop"
## Si le fichier ".msg" n existe pas CodeRet=252 Fonction="stop"
## Si la ligne de definition n est pas correcte CodeRet=253 Fonction="stop"
## Une erreur ete remontee par la fonction fct_params CodeRet=254 Fonction="stop"
## Si numero_err > 250 CodeRet=255
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Evo : Integration au socle DTSI
# 1.0.1 17-03-2016 - Emmanuel Confrere - Ano : Les fichier temporaire ne sont pas supprimer dans les sous arborescence
# 1.1.0 24-08-2016 - Emmanuel Confrere - Evo : Prise en charge de la librairie fct_params
# 1.2.0 05-10-2016 - Emmanuel Confrere - Evo : Interpretation des variables dans la zone de texte de fichier de configuration .msg
# 1.2.1 10-03-2017 - Emmanuel Confrere - Ano : Suppression des variables NC_EXPL_*
# 1.2.2 06-04-2017 - Emmanuel Confrere - Ano : Degradation de performance serveur (Cf. DBA-2458)
# Suppression de la commande "find"
##----------------------------------------------------------------------------
function fct_erreur
{
# - Declaration des variables
local L_NumErr=$1 # Numero d erreur a rechercher
local L_CodRet=0 # Code de sortie
local L_Cmd="stop" # Fonction execute par defaut, apres recheche
local L_RefErr="" # Extraction de la ligne du fichier .msg
local L_NbChamp="" # Controle le Nb Champ des ligne .msg
local L_Msg="" # Message a afficher
local L_Type="" # Type de message
[ -z "${SH_FICMSG}" ] && return 0
if [ $# -ne 1 ]
then
L_Cmd="stop"; L_CodRet=250; L_NumErr=250; L_Type="ERREUR"; L_Msg="NoErr non renseigne"
else
case ${L_NumErr} in
0 ) L_Cmd="stop"; L_CodRet=0; L_Type="FIN-OK" ;;
254 ) L_Cmd="stop"; L_CodRet=254; L_Type="ERREUR"; L_Msg="Une erreur ete remontee par la librairie fct_params" ;;
* ) if [ -f ${SH_FICMSG} ]
then
L_RefErr=`grep -e "^${L_NumErr} *|" ${SH_FICMSG}`
if [ -n "${L_RefErr}" ]
then
L_NbChamp=`echo ${L_RefErr}|sed "s/[^|]//g"`
if [ ${#L_NbChamp} -ne 3 ]
then
L_Cmd="stop"; L_CodRet=253; L_Type="ERREUR"; L_Msg="Definition de l erreur incorrecte"
else
[ ${L_NumErr} -ge 250 ] && L_CodRet=255 || L_CodRet=${L_NumErr}
L_Type=`echo ${L_RefErr}|cut -d"|" -f 2|tr a-z A-Z|sed 's/^ *//;s/ *$//'`
L_Cmd=`echo ${L_RefErr}|cut -d"|" -f 3|sed 's/^ *//;s/ *$//'`
eval L_Msg=\"${L_RefErr##*|}\"
[ -z "${L_Cmd}" ] && L_Cmd="stop"
fi
else
L_Cmd="stop"; L_CodRet=251; L_Type="ERREUR"; L_Msg="Definition de l erreur non trouvee"
fi
else
L_Cmd="stop"; L_CodRet=252; L_Type="ERREUR"; L_Msg="Le fichier msg n existe pas"
fi ;;
esac
fi
case ${L_Type} in
"ERREUR" ) fct_message -color rouge "${L_Type} : ${L_Msg}" ;;
"ALERTE" ) fct_message -color orange "${L_Type} : ${L_Msg}" ;;
"INFO" ) fct_message -color bleu "${L_Type} : ${L_Msg}" ;;
"FIN-OK" ) ;;
* ) fct_message "${L_Type} : ${L_Msg}" ;;
esac
case "${L_Cmd}" in
"stop" ) fct_message -hist "(${SH_SESSION_ID}) : fin - ${L_NumErr}"
# Suppression des fichiers temporaire a la sortie du shell principal si mode debug pas activer
if [ ${#SH_INDENT_MSG} -eq 0 -a ${SH_NIV_DEBUG} -eq 0 ]
then
fct_message -debug 0 "<lib:fct_erreur> Nettoyage des fichiers temporaire de la session ${SH_SESSION_ID}"
if [ -n "${NC_EXPL_TMP}" -a -n "${SH_SESSION_ID}" -a "${NC_EXPL_TMP}" != "/" -a "${NC_EXPL_TMP}" != "." ]
then
rm -f "${NC_EXPL_TMP}/*${SH_SESSION_ID}*"
else
fct_message -debug 0 "<lib:fct_erreur> Variable de session incoherente : NC_EXPL_TMP = ${NC_EXPL_TMP} & SH_SESSION_ID = ${SH_SESSION_ID}"
fi
fi
case ${L_Type} in
"ERREUR" ) fct_message -color rouge "fin (${L_NumErr})" ;;
"ALERTE" ) fct_message -color orange "fin (${L_NumErr})" ;;
"INFO" ) fct_message -color bleu "fin (${L_NumErr})" ;;
"FIN-OK" ) fct_message -color vert "fin (${L_NumErr})" ;;
* ) fct_message "${L_Type} : ${L_Msg}" ;;
esac
# Signaler la fin d execution au semaphore eventuel
fct_libere_exec
# Reduction de l indentation
[ ${#SH_INDENT_MSG} -gt 0 ] && SH_INDENT_MSG=${SH_INDENT_MSG:0:$((${#SH_INDENT_MSG}-2))}
exit ${L_CodRet} ;;
"continu" ) return 0 ;;
"*" ) eval ${L_Cmd} ;;
esac
}
typeset -Ffx fct_erreur

266
lib/esql.lib Executable file
View File

@ -0,0 +1,266 @@
##----------------------------------------------------------------------------
## Script : esql.lib
## Module Puppet : gnc-script_database_dtsi
## Auteur : Emmanuel Confrere
## Date : 10-02-2016
## Version : 8.0.7-0
## Objet : Cette fonction permet l execution d une requete sur un serveur de base de donnees
##
## Fonction : esql [NomVariable] [Connexion]
##
## Detail : Cette fonction permet l execution d une requete sur un serveur de base de donnees
## La requete est passe a travers la variable d environement ESQL_SQLSTMT.
## Cette fonction s appuis sur les executables psql et sqlplus. Les client de ces
## editeurs doivent donc a minima etre installer.
## La fonction est appelle depuis le shell ou depuis un script de la facon suivante
## esql <VAR> <CNX>
##
## Note : l ordre des parametres n a pas d importance et sont tout deux optionnel.
##
## Le type de base est determine soit par la variable d environement NC_EXPL_DBEDITEUR
## soit par la forme du parametre <CNX>. Ce parametre reconnais le format suivant
## <editeur>:<compte>/<mdp>@<Alias>|@<host:port>//<base>
##
## Ex. cpt/mdp@host:port//base
## cpt/mdp
## cpt/mdp@Alias ( @ est equivalent a //base pour Postgres )
## cpt/mdp//base ( // est equivalent a @Alias pour Oracle)
## /sys ( connexion "/ as sysdba" pour Oracle et "postgres" pour Postgres )
## /sys//base ( pour Postgres se connecte a la base "base" sous le compte "postgres". Ignore par oracle)
##
## Chacune de ces formes peut etre precede par l editeur de la base...
## Ex. oracle:cpt/mdp@Alias
## postgres:/sys
##
## Note : Prefixer par l editeur est necessaire pour interoger une base distante.
## Si l editeur n est pas specifier alors la variable NC_EXPL_DBEDITEUR seras utilisee
## pour determiner l executable a utiliser. La variable NC_EXPL_DBEDITEUR est initialise
## par /opt/expl/conf/shell-env/profile_socle_database.env
##
## Le resultat de la requete est envoye sur la sortie standard ou dans la variable <VAR>
## si cette derniere est renseignee. Si plusieur enragistrement sont
## retourne par la requete la variable <VAR> seras un tableau.
##
## Si aucun parametre de connexion n est fourni (<CNX> est null) alors
## une connxion par defaut sur la base local est utilise
##
## Par defaut la connexion a un serveur Postgres se fait avec le compte postgres
## et si la base n est pas specifier on se connectre a la base postgres.
## Sur un serveur Oracle la connexion se fait par defaut via un compte externe "/"
## sur la base courante defini par la librairie "base".
##
## Si aucune erreur n est releve cette fontion retourne le code de sortie 0.
##
## IMPORTANT : Cette fonction utilise le disque virtuel /dev/shm pour construire les tableaux
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 8.0.7-0 - 10-02-2016 - Emmanuel Confrere - Integration au socle DTSI via Puppet
##----------------------------------------------------------------------------
function esql
{
local VAR_DB=""
local VAR_RES=$1
local VAR_CPT=$2
local VAR_TMP=""
local VAR_CNX=""
local VAR_SES=""
local VAR_LIGNE=""
local VAR_I=1
local PVF=${ESQL_SQLSTMT:${#ESQL_SQLSTMT}-1:1}
local VAR_TMP=""
local VAR_MDP=""
local VAR_CPT2=""
local VAR_ERR=0
local VAR_HOST=""
local VAR_PORT=""
local VAR_BASE=""
fct_message -debug 0 "<lib:esql> ## ---------------------- esql.lib sql submit -------------------- ##"
# -- On controle si l ordre SQL fini bien par ";", le cas echeans on ajoute ce caractere...
[ "${PVF}" = "/" -o "${PVF}" = ";" ] && PVF="" || PVF=";"
# -- On identifie une eventuelle chaine de connexion sur le premier argument
# -- si c est c est le cas, soit il y eu inversion des arguments, soit il n y a pas de nom de variable passe en argument
# -- Si dessous on echange les arguments dans tous les cas ...
if [ `expr match "${VAR_RES}" ".*/.*@.*$"` -ne 0 -o `expr match "${VAR_RES}" ".*/.*$"` -ne 0 -o `expr match "${VAR_RES}" "[a-z,A-Z][a-z,A-Z]*:.*$"` -ne 0 ]
then
VAR_TMP="${VAR_RES}"
VAR_RES="${VAR_CPT}"
VAR_CPT="${VAR_TMP}"
fct_message -debug 0 "<lib:esql> Echange des parametre d entree"
fi
# -- identification de l editeur a partir du format de la chaine de connection
if [ `expr match "${VAR_CPT}" "[a-z]*:"` -ne 0 ]
then
VAR_DB=`echo ${VAR_CPT}|cut -d ":" -f1`
VAR_CPT=`echo ${VAR_CPT}|sed 's/[^:]*:\(.*$\)/\1/'`
else
VAR_DB=${NC_EXPL_DBEDITEUR}
fi
# -- Construction de la chaine de connexion en fontion de l editeur (VAR_CNX) et de la forme du parametre VAR_CPT
case "${VAR_DB}" in
"oracle" ) fct_message -debug 0 "<lib:esql> Connexion a une base Oracle"
if [ -z "${VAR_CPT}" ]
then
VAR_MDP="Aucun"
VAR_CPT2="/"
VAR_CNX="/"
VAR_SES="alter session set current_schema = zzsmai_adm;"
fct_message -debug 2 "<lib:esql> <1> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
fct_message -debug 2 "<lib:esql> <1> Schema courant (VAR_SES) : ${VAR_SES}"
elif [ "${VAR_CPT}" = "/sys" ]
then
VAR_MDP="Aucun"
VAR_CPT2="/ as sysdba"
VAR_CNX="/ as sysdba"
fct_message -debug 2 "<lib:esql> <2> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" "/sys//.*$"` -ne 0 ]
then
fct_message "<lib:esql> format de connexion non supporte (VAR_CPT=${VAR_CPT})"
return 2
elif [ `expr match "${VAR_CPT}" ".*/.*@.*:[0-9][0-9]*//.*$"` -ne 0 ]
then
VAR_BASE=`echo "${VAR_CPT}"|sed 's#.*/.*@.*:[0-9][0-9]*//\(.*\)$#\1#'`
VAR_HOST=`echo "${VAR_CPT}"|sed 's#.*/.*@\(.*\):[0-9][0-9]*//.*$#\1#'`
VAR_PORT=`echo "${VAR_CPT}"|sed 's#.*/.*@.*:\([0-9][0-9]*\)//.*$#\1#'`
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*@.*:[0-9][0-9]*//.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)@.*:[0-9][0-9]*//.*$#\1#'`
VAR_CNX="${VAR_CPT2}/${VAR_MDP}@${VAR_HOST}:${VAR_PORT}/${VAR_BASE}"
fct_message -debug 2 "<lib:esql> <3> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*@.*$"` -ne 0 ]
then
VAR_HOST=`echo "${VAR_CPT}"|sed 's#.*/.*@\(.*\)$#\1#'`
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*@.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)@.*$#\1#'`
VAR_CNX="${VAR_CPT2}/${VAR_MDP}@${VAR_HOST}"
fct_message -debug 2 "<lib:esql> <4> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*//.*$"` -ne 0 ]
then
VAR_HOST=`echo "${VAR_CPT}"|sed 's#.*/.*//\(.*\)$#\1#'`
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*//.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)//.*$#\1#'`
VAR_CNX="${VAR_CPT2}/${VAR_MDP}@${VAR_HOST}"
fct_message -debug 2 "<lib:esql> <5> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*$"` -ne 0 ]
then
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)$#\1#'`
VAR_CNX="${VAR_CPT2}/${VAR_MDP}"
fct_message -debug 2 "<lib:esql> <6> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
else
fct_message "<lib:esql> Chaine de connexion non reconnu"
return 2
fi ;;
"postgres" ) fct_message -debug 0 "<lib:esql> Connexion a une base Postgres"
if [ -z "${VAR_CPT}" -o "${VAR_CPT}" = "/sys" ]
then
VAR_CPT2="postgres"
VAR_MDP="aucun"
VAR_CNX="postgres://"
fct_message -debug 2 "<lib:esql> <7> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" "/sys//.*$"` -ne 0 ]
then
VAR_BASE=`echo "${VAR_CPT}"|sed 's#^/sys//\(.*\)$#\1#'`
VAR_CPT2="postgres"
VAR_MDP="aucun"
VAR_CNX="postgres:///${VAR_BASE}"
fct_message -debug 2 "<lib:esql> <8> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*@.*:[0-9][0-9]*//.*$"` -ne 0 ]
then
VAR_BASE=`echo "${VAR_CPT}"|sed 's#.*/.*@.*:[0-9][0-9]*//\(.*\)$#\1#'`
VAR_HOST=`echo "${VAR_CPT}"|sed 's#.*/.*@\(.*\):[0-9][0-9]*//.*$#\1#'`
VAR_PORT=`echo "${VAR_CPT}"|sed 's#.*/.*@.*:\([0-9][0-9]*\)//.*$#\1#'`
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*@.*:[0-9][0-9]*//.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)@.*:[0-9][0-9]*//.*$#\1#'`
VAR_CNX="postgres://${VAR_CPT2}:${VAR_MDP}@${VAR_HOST}:${VAR_PORT}/${VAR_BASE}"
fct_message -debug 2 "<lib:esql> <9> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*@.*$"` -ne 0 ]
then
VAR_BASE=`echo "${VAR_CPT}"|sed 's#.*/.*@\(.*\)$#\1#'`
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*@.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)@.*$#\1#'`
VAR_CNX="postgres://${VAR_CPT2}:${VAR_MDP}@localhost/${VAR_BASE}"
fct_message -debug 2 "<lib:esql> <10> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*//.*$"` -ne 0 ]
then
VAR_BASE=`echo "${VAR_CPT}"|sed 's#.*/.*//\(.*\)$#\1#'`
VAR_CPT2=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*//.*$#\1#'`
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)//.*$#\1#'`
VAR_CNX="postgres://${VAR_CPT2}:${VAR_MDP}@localhost/${VAR_BASE}"
fct_message -debug 2 "<lib:esql> <11> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
elif [ `expr match "${VAR_CPT}" ".*/.*$"` -ne 0 ]
then
VAR_BASE=`echo "${VAR_CPT}"|sed 's#\(.*\)/.*$#\1#'`
VAR_CPT2=${VAR_BASE}
VAR_MDP=`echo "${VAR_CPT}"|sed 's#.*/\(.*\)$#\1#'`
VAR_CNX="postgres://${VAR_CPT2}:${VAR_MDP}@localhost/${VAR_BASE}"
fct_message -debug 2 "<lib:esql> <12> Chaine de connexion (VAR_CNX) : ${VAR_CNX}"
else
fct_message "<lib:esql> Chaine de connexion non reconnu"
return 2
fi ;;
* ) fct_message "<lib:esql> Editeur inconnu : ${VAR_DB}"
return 3 ;;
esac
if [ -n "${ESQL_SQLSTMT}" ]
then
fct_message -debug 0 "<lib:esql> Compte de soumission : ${VAR_CPT2}"
fct_message -debug 3 "<lib:esql> Mot de passe : ${VAR_MDP}"
fct_message -debug 0 "<lib:esql> ${ESQL_SQLSTMT}${PVF}"
case "${VAR_DB}" in
"oracle" ) VAR_TMP=`sqlplus -s ${VAR_CNX} << EndSQL
whenever sqlerror exit 100 rollback;
whenever oserror exit 101 rollback;
set head off pages 0 feed off echo off lines 2048 trim on verify off;
${VAR_SES}
${ESQL_SQLSTMT}${PVF}
EndSQL`
VAR_ERR=$? ;;
"postgres" ) VAR_TMP=`psql -t -q -F "|" -A ${VAR_CNX} << EndSQL
${ESQL_SQLSTMT}${PVF}
EndSQL`
VAR_ERR=$? ;;
esac
if [ ${VAR_ERR} -ne 0 ]
then
export ESQL_NUMROWS=0
[ -n "${SH_SESSION_ID}" ] && fct_message -debug 0 "<lib:esql> ${VAR_TMP}" || echo "${VAR_TMP}"
return 1
else
[ -z "${VAR_TMP}" ] && ESQL_NUMROWS=0 || ESQL_NUMROWS=`echo "${VAR_TMP}"|wc -l`
fct_message -debug 0 "<lib:esql> ESQL_NUMROWS=${ESQL_NUMROWS}"
export ESQL_NUMROWS
fct_message -debug 2 "<lib:esql> ## ---------------------- esql.lib result set -------------------- ##"
if [ -n "${VAR_RES}" ]
then
eval unset ${VAR_RES}
[ ${ESQL_NUMROWS} -eq 0 ] && eval ${VAR_RES}=""
[ ${ESQL_NUMROWS} -eq 1 ] && eval ${VAR_RES}=\"${VAR_TMP}\"
[ ${ESQL_NUMROWS} -eq 1 -a -n "${SH_SESSION_ID}" ] && fct_message -debug 2 "<lib:esql> ${VAR_TMP}"
if [ ${ESQL_NUMROWS} -gt 1 ]
then
VAR_I=0
echo "${VAR_TMP}" > /dev/shm/sql$$.tmp
while read VAR_LIGNE
do
VAR_LIGNE=`echo ${VAR_LIGNE}|sed 's/ */ /g'`
[ -n "${SH_SESSION_ID}" ] && fct_message -debug 2 "<lib:esql> ${VAR_LIGNE}"
eval ${VAR_RES}[${VAR_I}]=\"${VAR_LIGNE}\"
(( VAR_I++ ))
done < /dev/shm/sql$$.tmp
rm -f /dev/shm/sql$$.tmp
fi
else
[ ${ESQL_NUMROWS} -ne 0 ] && echo "${VAR_TMP}"
fi
fct_message -debug 0 "<lib:esql> ## --------------------------------------------------------------- ##"
fi
fi
return 0
}
typeset -Ffx esql

69
lib/format-ligne.lib Executable file
View File

@ -0,0 +1,69 @@
##----------------------------------------------------------------------------
## Script : format_ligne.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 10-02-2016
## Version : 1.0.0
## Objet : Permet de formater le texte dans la fonction fct_affiche_ligne.
##
## Fonction : fct_format Texte taille justification
##
## Detail : Ne pas appeler directement.
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Creation : Reprise du script du socle Oracle
##----------------------------------------------------------------------------
function fct_format
{
local L_TEXT="$1"
local L_TAILLE=$2
local L_JUSTIFIER=$3
local L_TMP=""
local L_TMP2=""
local L_RESULT=""
local L_REPETITION=0
case "${L_JUSTIFIER}" in
"r" ) L_TMP=1
L_REPETITION=$(( ${L_TAILLE} / ${#L_TEXT} + 1))
while [ ${L_TMP} -le ${L_REPETITION} ]
do
L_RESULT="${L_RESULT}${L_TEXT}"
L_TMP=$(( ${L_TMP} + 1 ))
done ;;
"c" ) L_TMP=1
L_REPETITION=$(( ${L_TAILLE} - ${#L_TEXT} ))
L_REPETITION=$(( ${L_REPETITION} / 2 ))
L_TMP2=$(( ${L_TAILLE} - ${#L_TEXT} - ${L_REPETITION} ))
while [ ${L_TMP} -le ${L_REPETITION} -a ${L_REPETITION} -gt 0 ]
do
L_RESULT="${L_RESULT} "
L_TMP=$(( ${L_TMP} + 1 ))
done
if [ ${L_REPETITION} -gt 0 ]
then
if [ ${L_REPETITION} -eq ${L_TMP2} ]
then
L_RESULT="${L_RESULT}${L_TEXT}${L_RESULT}"
else
L_RESULT="${L_RESULT}${L_TEXT}${L_RESULT} "
fi
else
L_RESULT="${L_TEXT}"
fi ;;
"d" ) L_TMP=1
L_REPETITION=$(( ${L_TAILLE} - ${#L_TEXT} ))
while [ ${L_TMP} -le ${L_REPETITION} -a ${L_REPETITION} -gt 0 ]
do
L_RESULT="${L_RESULT} "
L_TMP=$(( ${L_TMP} + 1 ))
done
L_RESULT="${L_TEXT}${L_RESULT}" ;;
esac
L_RESULT=${L_RESULT:0:${L_TAILLE}}
echo ${L_RESULT}
return 0
}
typeset -Ffx fct_format

47
lib/gen-mdp.lib Executable file
View File

@ -0,0 +1,47 @@
##----------------------------------------------------------------------------
## Script : gen-mdp.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 10-02-2016
## Version : 1.0.0
## Objet : Genration d un mots depasse aleatoire
##
## Fonction : fct_gen_mdp
##
## Detail :
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Creation : Reprise du script du socle Oracle
##----------------------------------------------------------------------------
function fct_gen_mdp
{
local L_CARACTERES="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
local L_CHIFFRES="1234567890"
local L_SPECCAR="-=:#+_"
local L_MDP=""
local L_TMP=""
local L_CPT=1
local L_LONGUEUR=9
local L_SIMPLE="non"
[ "$1" = "-ns" ] && L_SPECCAR=""
[ -z "$1" -a "$1" != "-ns" ] && L_SIMPLE="oui"
L_MDP=${L_CARACTERES:$(( $RANDOM % ${#L_CARACTERES} )):1}
L_TMP="${L_CARACTERES}${L_SPECCAR}${L_CHIFFRES}${L_SPECCAR}${L_CHIFFRES}${L_SPECCAR}${L_CHIFFRES}"
if [ -z "$1" -a "$1" != "-ns" ]
then
while [ ${L_CPT} -le ${L_LONGUEUR} ]
do
L_MDP="${L_MDP}${L_TMP:$(( $RANDOM % ${#L_TMP} )):1}"
((L_CPT++))
done
else
L_MDP=`echo $1|md5sum|sed 's/ *//g;s/-$//;s/[0-9]*\([a-f][a-f,0-9]*\)/\1/'|cut -c1-9`
fi
echo ${L_MDP}
}
typeset -Ffx fct_gen_mdp

153
lib/message.lib Executable file
View File

@ -0,0 +1,153 @@
##----------------------------------------------------------------------------
## Script : message.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 29-06-2017
## Version : 1.2.1
## Objet : Gestion des message sur la console et dans les divers fichiers de trace
##
## Fonction : fct_message
##
## Detail : Cette fonction remplace l utilisation de "echo".
## Elle permet de gerer les messages a destination des fichiers de traces
## , des fichiers de compte rendu ou de la console.
##
## Sans parametre le message est ecrit sur la console et dans le fichier
## journal du script ${SH_FICLOG}. Le comportement est modifie selon les options
## utilisees.
##
## -cpt : Le message est aussi ecrit dans le fichier de compte-rendu ${SH_FICCPT}
## -hist : Le message est aussi ecrit dans le fichier d historique ${SH_FICTRC}
## Cette option ajoute des information d execution dans le fichier d historique
## notamant le compte qui execute le script sous la forme user/sudo_user
## -debug N : Le message est ecrit uniquement dans le fichier journal ${SH_FICLOG}
## si N est inferrieure ou egal au niveau de debug du Shell. Par defaut
## le niveau debug du shell est 0.
## -nolog : inhibe l ecritutre dans le fichier journal
## -color : Ecrit le message en couleur sur la console.
## Les couleurs disponible sont noir,, rouge, vert, jaune, bleu, rose, cyan,
## gris, orange et blanc
##
## Les variables SH_FIC* sont definies dans le fichiers ${NC_EXPL_CONF}/init.conf
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Cre : Reprise du script du socle Oracle
# 1.1.0 10-03-2017 - Emmanuel Confrere - Evo : Optimisation du traitement de l option -debug
# 1.2.0 13-04-2017 - Emmanuel Confrere - Evo : Journalisation du compte d execution dans l historique
# 1.2.1 29-06-2017 - Emmanuel Confrere - Ano : Fonctionnement inattendu sous Bash 3.2.25
# la fonction logname ne renvoi rien ?
##----------------------------------------------------------------------------
function fct_message
{
local L_TEXT="" # Texte a afficher
local L_TIME_STAMP=`date "+%x %X"` # Horrodatage a ajouter au texte
local L_EXISTE_REP
local L_NB_PARAM=0 # Nb de parametre de la ligne de commande
local L_TMP
local L_TMP2
local L_OPT # Nom des option
local L_OPTION_DBG="non" # Message de debug
local L_OPTION_SID="" # Affichage du SH_SESSION_IDP a l ecran
local L_NIV_DEBUG=0 # Niveau de trace par defaut 0=aucune
local L_OPTION_CPT="non" # Message de compte rendu
local L_OPTION_HIST="non" # Message pour l historique
local L_COULEUR="" # Couleur du texte avec l option -color
local L_OPTION_COULEUR="non"
local L_LIST_COULEUR="noir:0;30 rouge:0;31 vert:0;32 jaune:1;33 bleu:1;34 rose:0;35 cyan:0;36 gris:0;37 orange:0;33 blanc:1;37 "
# - recuperation des parametres en entree
L_TMP=1
L_NB_PARAM=$#
while [ ${L_TMP} -le ${L_NB_PARAM} ]
do
L_OPT="$1"
case "${L_OPT}" in
"-cpt") L_OPTION_CPT="oui" ;;
"-nolog") L_OPTION_NOLOG="oui" ;;
"-hist") L_OPTION_HIST="oui" ;;
"-color") L_OPTION_COULEUR="oui"
L_ARG=`echo $2|tr A-Z a-z`
L_TMP2=${L_ARG:0:1}
if [ "${L_TMP2}" != "-" ]
then
# on recherche la correspondance numerique de la couleur
L_COULEUR=`echo ${L_LIST_COULEUR}|sed "s/.*${L_ARG}:\([0-1];3[0-7]\) .*/\1/"`
# Si on ne la trouve pas on annule la colorisation
[ ${#L_COULEUR} -ne 4 ] && L_OPTION_COULEUR="non"
L_TMP=$(( ${L_TMP} + 1 ))
shift
fi ;;
"-debug") L_OPTION_DBG="oui"
L_ARG="$2"
L_TMP2=${L_ARG:0:1}
if [ "${L_TMP2}" != "-" ]
then
L_ARG=`echo $2|sed 's/[0-9]//g'`
if [ -n "${L_ARG}" ]
then
L_TEXT="$2"
L_NIV_DEBUG=1
else
L_NIV_DEBUG=$2
fi
L_TMP=$(( ${L_TMP} + 1 ))
shift
else
L_NIV_DEBUG=1
fi
[ ${L_NIV_DEBUG} -gt ${SH_NIV_DEBUG} ] && return 0 ;;
*) L_TEXT="${L_OPT}" ;;
esac
L_TMP=$(( ${L_TMP} + 1 ))
shift
done
# - controle que la fonction est lance depuis un shell
if [ -z "${SH_SESSION_ID}" ]
then
# -- La fonction est executer en mode inetractif (Pas dans un shell)
# -- on autorise alors que l affichage sur la sortie standard
SH_AFF_SID="non"
SH_SILENCE="non"
SH_NIV_DEBUG=0
L_EXISTE_REP=1
else
# - Mode shell...
# - On control l'existance des repertoires
[ -d ${NC_EXPL_HST} -a -d ${NC_EXPL_LOG} -a -d ${NC_EXPL_CPT} ] && L_EXISTE_REP=0 || L_EXISTE_REP=1
fi
# - initialisation des variables
[ "${SH_AFF_SID}" = "oui" ] && L_OPTION_SID="[${SH_SESSION_IDP}] "
L_OPTION_NOLOG=${L_OPTION_NOLOG:="non"}
# - Ecriture des messages
# - Ajout d une indentation si elle est definie
[ -n "${SH_INDENT_MSG}" ] && L_TEXT="${SH_INDENT_MSG} ${L_TEXT}"
if [ "${L_OPTION_DBG}" = "oui" ]
then
[ ${L_EXISTE_REP} -eq 0 ] && echo "${L_TIME_STAMP} [${SH_SESSION_IDP}] : <Debug_${L_NIV_DEBUG}> ${L_TEXT}" >> ${SH_FICLOG}
else
[ ${L_EXISTE_REP} -eq 0 -a "${L_OPTION_CPT}" = "oui" -a "${L_OPTION_HIST}" = "non" ] && echo "${L_TIME_STAMP} : ${L_TEXT}" >> ${SH_FICCPT}
[ ${L_EXISTE_REP} -eq 0 -a "${L_OPTION_CPT}" = "non" -a "${L_OPTION_HIST}" = "oui" ] && echo "${L_TIME_STAMP} : ${SH_LOGUSER} : ${SH_EXECUSER} : ${L_TEXT}" >> ${SH_FICTRC}
if [ "${L_OPTION_NOLOG}" = "non" ]
then
[ ${L_EXISTE_REP} -eq 0 -a "${L_OPTION_CPT}" = "non" -a "${L_OPTION_HIST}" = "non" ] && echo "${L_TIME_STAMP} [${SH_SESSION_IDP}] : ${L_TEXT}" >> ${SH_FICLOG}
[ ${L_EXISTE_REP} -eq 0 -a "${L_OPTION_CPT}" = "oui" -a "${L_OPTION_HIST}" = "oui" ] && echo "${L_TIME_STAMP} : ${L_TEXT}" >> ${SH_FICLOG}
fi
if [ "${SH_SILENCE}" = "non" -a "${L_OPTION_HIST}" = "non" ]
then
if [ "${L_OPTION_COULEUR}" = "oui" ]
then
echo -e "${L_OPTION_SID}\033[${L_COULEUR}m${L_TEXT}\033[0m"
else
echo -e "${L_OPTION_SID}${L_TEXT}"
fi
fi
fi
return 0
}
typeset -Ffx fct_message

580
lib/params.lib Executable file
View File

@ -0,0 +1,580 @@
##----------------------------------------------------------------------------
## 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 "<lib:fct_params> Le nom du script Bash n est pas defini"
fct_erreur 254
fi
# -- Extraction des options de la declaration
# -- ----------------------------------------
# -- Definition d un fichier tempon ( ${L_PARMF} ) pour acceuillir l entete du script contenant la declaration
# -- des options. Comme ce fichier va etre parcouru souvent, on le charge en RAM disque de preference ( sur /dev/shm).
# -- Le nom du fichier tempon sera le nom du script suffixee par ".parms" en lieu et place de ".sh"
L_PARMF=`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]="<lib:fct_params> 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]="<lib:fct_params> 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]="<lib:fct_params> 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]="<lib:fct_params> 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} derniere execution 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

109
lib/path.lib Executable file
View File

@ -0,0 +1,109 @@
##----------------------------------------------------------------------------
## Script : path.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 10-02-2016
## Version : 2.0.0
## Objet : Ajout d'un repertoire a une variable avec control d unicite.
##
## Fonction : fctpath
##
## detail : Certaines variables represente une liste de repertoire
## separes par un caractere significatif. C'est le cas pour
## les variables PATH, MANPATH, etc...
## Cette fonction permet la mise a jour de ce type de
## variable sans se poser la question de la redondance
## de l'information ou de l'existance du repertoire.
## L'appel de cette fonction doit etre suivi de quatre
## parametres :
## - 1 : le nom du repertoire a ajouter
## - 2 : le nom de la variable a mettre a jour
## - 3 : le separateur de champs utilise
## - 4 : le parametre "avant" si vous desirez ajouter
## le repertoire en debut de variable
## La variable est automatiquement exportee.
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 19-08-2001 - Marc GRESSET - Creation
# 1.0.0 10-02-2016 - Emmanuel Confrere - Integration au script du socle DTSI
##---------------------------------------------------------------------------
fctpath () {
local V_PATH_NAME="${1}"
local V_PATH_VAR="${2}"
local V_PATH_SEPAR="${3}"
local V_PATH_WHERE="${4}"
eval V_PATH_CONTENU=\"\$\{"${V_PATH_VAR}"\}\"
#- Suppression des caracteres V_PATH_SEPAR au debut et en fin de ligne
V_PATH_CONTENU=`echo "${V_PATH_CONTENU}"|sed "s#^${V_PATH_SEPAR}##;s#${V_PATH_SEPAR}\\$##"`
if [ -z "${V_PATH_NAME}" ] || [ -z "${V_PATH_VAR}" ] || [ -z "${V_PATH_SEPAR}" ]
then
echo "fct_path : Probleme sur les parametres :"
echo "fct_path : \${V_PATH_NAME} = [ ${V_PATH_NAME} ]"
echo "fct_path : \${V_PATH_VAR} = [ ${V_PATH_VAR} ]"
echo "fct_path : \${V_PATH_SEPAR} = [ ${V_PATH_SEPAR} ]"
return 1
else
case ${V_PATH_SEPAR} in
\.|\,|\;|\:|\!|\~|\@|\#|\%|\^) \
:
;;
*) echo "fct_path : Probleme sur le separateur de champs."
echo "fct_path : \${V_PATH_NAME} = [ ${V_PATH_NAME} ]"
echo "fct_path : \${V_PATH_VAR} = [ ${V_PATH_VAR} ]"
echo "fct_path : \${V_PATH_SEPAR} = [ ${V_PATH_SEPAR} ]"
return 2
;;
esac
fi
# - Suppression du path si existe deja dans la variable
case ${V_PATH_CONTENU} in
*${V_PATH_SEPAR}${V_PATH_NAME}${V_PATH_SEPAR}* ) \
V_PATH_CONTENU=`echo ${V_PATH_CONTENU}|sed "s#${V_PATH_SEPAR}${V_PATH_NAME}${V_PATH_SEPAR}#${V_PATH_SEPAR}#"` ;;
${V_PATH_NAME}${V_PATH_SEPAR}* ) \
V_PATH_CONTENU=`echo ${V_PATH_CONTENU}|sed "s#${V_PATH_NAME}${V_PATH_SEPAR}##"` ;;
*${V_PATH_SEPAR}${V_PATH_NAME} ) \
V_PATH_CONTENU=`echo ${V_PATH_CONTENU}|sed "s#${V_PATH_SEPAR}${V_PATH_NAME}##"` ;;
${V_PATH_NAME} ) V_PATH_CONTENU="" ;;
esac
# - Initialisation de la nouvelle variable
if [ "${V_PATH_WHERE}" != "supp" ]
then
if [ -z "${V_PATH_CONTENU}" ]
then
V_PATH_CONTENU="${V_PATH_NAME}"
elif [ "${V_PATH_WHERE}" = "avant" ]
then
V_PATH_CONTENU=${V_PATH_NAME}${V_PATH_SEPAR}${V_PATH_CONTENU}
else
V_PATH_CONTENU=${V_PATH_CONTENU}${V_PATH_SEPAR}${V_PATH_NAME}
fi
fi
if [ ! -d "${V_PATH_NAME}" ] && [ ! -f "${V_PATH_NAME}" ]
then
#- Le repertoire specifier n existe pas
unset V_PATH_NAME
unset V_PATH_VAR
unset V_PATH_SEPAR
unset V_PATH_WHERE
unset V_PATH_CONTENU
return 2
else
#- Export du nouveau Path
eval ${V_PATH_VAR}=${V_PATH_CONTENU}
eval export ${V_PATH_VAR}
unset V_PATH_NAME
unset V_PATH_VAR
unset V_PATH_SEPAR
unset V_PATH_WHERE
unset V_PATH_CONTENU
fi
}
typeset -Ffx fctpath

97
lib/rotattrace.lib Executable file
View File

@ -0,0 +1,97 @@
##----------------------------------------------------------------------------
## Script : rotattrace.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 12-04-2017
## Version : 2.0.6
## Objet : Rotation du fichier passe en parametre
##
## Fonction : fct_rotation fichier retention
##
## Detail :
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 24-01-2008 - Emmanuel Confrere - Cre : Creation
# 1.0.0 06-06-2008 - Emmanuel Confrere - Ano : Correction des noms de variable
# 1.1.0 06-06-2008 - Emmanuel Confrere - Evo : Ajout recherche fichier
# 2.0.0 10-02-2016 - Emmanuel Confrere - Evo : Integration au socle DTSI
# 2.0.1 09-03-2016 - Pierre Trhin - Ano : Ajout du suivie des liens symbolique
# 2.0.2 04-01-2017 - Emmanuel Confrere - Ano : Limiter la profondeur de la purge au dossier specifier - Cf. Jira : DBA-2372
# Ajout d un control de validite des variables L_FIC2 et L_REP_FIC
# 2.0.3 05-01-2017 - Emmanuel Confrere - Ano : Erreur de syntax dans le control de validite
# 2.0.4 06-04-2017 - Emmanuel Confrere - Ano : Degradation de performance serveur (Cf. DBA-2458)
# 2.0.5 06-04-2017 - Emmanuel Confrere - Ano : Degradation de performance serveur,
# ajout de l option "-delete" dans find a la place de "-exec rm {} \;"
# 2.0.6 12-04-2017 - Emmanuel Confrere - Ano : l expension des nom ne se fait pas dans l instruction rm -f "${L_REP_FIC}/${L_FIC2}*"
# a cause des double-cotes. Du coup les fichiers ne sont pas supprimees.
##----------------------------------------------------------------------------
function fct_rotation
{
# Objet : Tourne les fichier de trace
# Parametre : Nom du fichier, periode de retention en jours
local L_FICHIER=`basename $1` # nom du fichier
local L_FIC2=""
local L_RET=$2 # Retention en jour - Entier positif
local L_SEQ=1
local L_REP_FIC="`dirname $1`" # Chemin absolu vers le fichier
local L_TMP=""
local L_TMP2=""
local L_OSPID=""
# Recuperation du PID du fichier ( uniquement pour les fichiers de trace )
L_OSPID=`echo ${L_FICHIER}|sed 's/.*_\([0-9][0-9]*\)\..*/\1/'`
# Si les chaine L_OSPID et L_FICHIER sont egale , alors le SH_SESSION_ID n as pas ete trouve
[ "${L_OSPID}" = "${L_FICHIER}" ] && L_OSPID=""
# L_OSPID doit etre un chiffre !
[ -z "`echo ${L_OSPID}|sed 's/[0-9][0-9]*//'`" ] || L_OSPID=""
if [ -n "${L_OSPID}" ]
then
# L_OSPID n est pas vide, L_FICHIER est donc un fichier de trace
# Extraction du nom de fichiers sans le numero d identification
L_FIC2=`echo ${L_FICHIER}|sed 's/^\(.*\)_\([0-9][0-9]*_[0-9][0-9]*\)\..*/\1/'`
else
L_FIC2=${L_FICHIER}
fi
# On controle ... de securite
[ "${L_FIC2}" = "*" ] && return 1 # Le fichier a supprimer ne peut pas etre "*"
[ -z "${L_FIC2}" -o -z "${L_REP_FIC}" ] && return 4 # Le nom du fichier et son repertoire doivent etre soumis
[ "${L_REP_FIC:0:1}" != "/" ] && return 2 # Le repertoire est fourni en valuer absolu
L_TMP=`echo ${L_REP_FIC}|cut -d "/" -f2` # Les repertoires suivant sont interdit
L_TMP2=`echo "bin boot sbin cgroup dev lib lib64 misc proc root selinux sys srv usr run"|grep -c "${L_TMP}"`
[ ${L_TMP2} -gt 0 ] && return 3
# fct_rotation du fichier ${L_REP_FIC}/${L_FICHIER}
# Suppression des fichier de trace anterieure a ${L_RET} jours
if [ ${L_RET} -eq 0 ]
then
# Si la retention est null on supprime tous les fichiers
rm -f ${L_REP_FIC}/${L_FIC2}*
else
# Limitation de la profondeur de la purge au dossier specifier (Ne pas prendre en compte les sous-dossier - Cf. Jira : DBA-2372)
# pour eliminer un find on reduit la pronfondeur de recherche L_RET-- (Induit par le fonctionnement de find).
((L_RET--))
find -L ${L_REP_FIC} -maxdepth 1 -name ${L_FIC2}\* -daystart -type f -mtime +${L_RET} -delete;
fi
if [ -z "${L_OSPID}" ]
then
# il s agit d un fichier sans SH_SESSION_ID on effectue donc la rotation des fichiers
# Nombre de fichier residuel...
L_SEQ=`ls ${L_REP_FIC}/${L_FICHIER}* 2>/dev/null|wc -l`
# Rotattion des fichiers
while [ ${L_SEQ} -gt 0 ]
do
L_TMP=$(( ${L_SEQ} - 1 ))
[ -f ${L_REP_FIC}/${L_FICHIER}.${L_TMP} ] && mv ${L_REP_FIC}/${L_FICHIER}.${L_TMP} ${L_REP_FIC}/${L_FICHIER}.${L_SEQ}
((L_SEQ--))
done
[ -f ${L_REP_FIC}/${L_FICHIER} ] && mv ${L_REP_FIC}/${L_FICHIER} ${L_REP_FIC}/${L_FICHIER}.1
fi
}
typeset -Ffx fct_rotation

153
lib/semaphore.lib Executable file
View File

@ -0,0 +1,153 @@
##----------------------------------------------------------------------------
## Script : semaphore.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 16-06-2016
## Version : 3.1.0
## Objet : Gestion de l execution parallel d un shell.
##
## Fonction : fct_unique_exec [nom] [occurences] [mode]
## fct_libere_exec [nom]
##
## [nom] : Mot alphabetique quelconque identifiant la ressource.
## [nom] ne peut pas prendre pour valeur "wait" ou "nowait".
##
## [occurence] : Nombre d execution parallel (Par defaut 1).
##
## [mode] : "wait" (par defaut) ou "nowait".
##
## Rem : Tous les parametres sont facultatif, mais doivent etre presentes dans l'ordre.
##
## Detail : Cette librairie gere les acces concurrent a une portion de code Bash.
## Deux fonctions sont utilisees :
## - fct_unique_exec : Positionne des semaphores et controle la disponibilite.
## - fct_libere_exec : Supprime des semaphores
##
## La fonction fct_unique_exec(), si appelee sans l argument [nom] et/ou [occurences],
## doit etre positionee en debut de script juste apres le chargement du fichier
## ${NC_EXPL_CONF}/init.conf sinon elle peut etre placee a n importe quel endroit dans le code.
##
## Elle positionne une semaphore pour proteger d une execution concurrente.
## Ensuite elle controle la disponibilite de la ressource et selon le [mode] utilise
## "wait ou "nowait", attend sa liberation ou sort immediatement en erreur.
##
## La semaphore est liberee automatiquement par l appel a la fonction fct_erreur(), sauf si [nom] a ete
## utilisee - fct_erreur() appelle la fonction fct_libere_exec() -.
##
## L utilisation avec [nom] implique OBLIGATOIREMENT de liberer la semaphore en appelant
## explicitement fct_libere_exec [nom] dans le script ayant appele fct_unique_exec().
##
## [occurences] fixe le nb d execution concurrente qui peuvent etre executer en parallel
## cette valeur est fixe par defaut avec ${SH_CPT_SEMAPHORE} qui vaut 1 si non
## surcharger par le script.
##
## [mode] fixe le comportement de sortie de la fonction fct_unique_exec().
## Par defaut le mode est fixe a "wait" mais il est possible de demander de ne pas
## attendre et de renvoyer le code erreur 1 en possitionnant la valeur du mode a "nowait".
##
## Les variables SH_FICSEM, SH_PROG et SH_CPT_SEMAPHORE sont initialisees dans le
## fichier ${NC_EXPL_CONF}/init.conf (comme toute les variables SH_*).
## SH_CPT_SEMAPHORE vaut 1 par defaut et peut etre surcharge dans le fichier
## de configuration du script.
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 - Emmanuel Confrere - Creation
# 1.0.1 - Daniel Frochtmann - Parallelisation de traitement
# 1.0.2 - Emmanuel Confrere - Ajout de commentaire
# 2.0.0 - Emmanuel Confrere - Debug (Ne fonctionnais pas si plus de 2 occurance)
# Refonte complete. On se base maintenant sur une liste de PID
# 2.1.0 - Emmanuel Confrere - Evo : prise en charge du nb d occurences actives
# 3.0.0 10-02-2016 - Emmanuel Confrere - Evo : Integration au socle DTSI
# 3.0.1 17-03-2016 - Emmanuel Confrere - Evo : Ajout d information de debug
# 3.1.0 16-06-2017 - Emmanuel Confrere - Evo : Ajout de l option "mode"
# Attente progressive
# Reformulation de l aide.
##----------------------------------------------------------------------------
function fct_unique_exec()
{
local NOM=$1
local OCCURENCES=$2
local MODE=$3
local PID=$$
local WAITING=2
local ELIGIBLE=0
local ELIGIBILITE=0
local FICSEM=""
# -- Marquage
fct_message -debug 0 "<lib:fct_unique_exec> Nom:${NOM} Occ:${OCCURENCES} mode:${MODE} PID:${PID}"
# -- Fixer le nombre maxi d'occurences actives
[ "${OCCURENCES}" = "nowait" -o "${OCCURENCES}" = "wait" ] && MODE=${OCCURENCES} && OCCURENCES=${SH_CPT_SEMAPHORE} || (( ${OCCURENCES} )) || OCCURENCES=${SH_CPT_SEMAPHORE}
# -- Identification de la ressource
[ "${NOM}" = "nowait" -o "${NOM}" = "wait" ] && MODE=${NOM} && NOM=""
(( ${NOM} )) && OCCURENCES=${NOM} && NOM=""
[ -n "${NOM}" ] && FICSEM=`echo ${SH_FICSEM}|sed "s/\.sem$/_${NOM}\.sem/"` || FICSEM=${SH_FICSEM}
echo "${PID}" >> ${FICSEM}
# -- Fixer le mode d execution
[ "${MODE}" = "nowait" ] && MODE=1 || MODE=0
# -- On controle l occupation de la ressource
# -- Le process est-il eligible pour continuer l execution
# -- 0 : Non
# -- 1 : Oui
ELIGIBLE=`head -${OCCURENCES} ${FICSEM}|grep -cw "${PID}"`
# -- Dans le cas ou le process n est pas eligible mais que le mode est nowait
# -- on ne passera pas dans la boucle d attente et on doit par consequent
# -- enleve le process de la liste d attente.
fct_message -debug 1 "<lib:fct_unique_exec> Stack 1 - Nom:${NOM} Occ~:${OCCURENCES} Mode:${MODE} Eligible:${ELIGIBLE}"
(( ${MODE} & ( ${MODE} ^ ${ELIGIBLE} ) )) && fct_libere_exec "@${NOM}@${PID}"
if (( ! (${MODE} | ${ELIGIBLE}) ))
then
# -- La resource est en cours d utilisation, on attend sa liberation...
fct_message -color cyan "Une ou plusieurs occurrence du script ${SH_PROG} est en cours d execution..."
fct_message -nolog -color cyan " - Nombre d occurance active : ${OCCURENCES}"
fct_message -nolog -color blanc " .\c"
while (( ! ${ELIGIBLE} ))
do
fct_message -nolog -color cyan ".\c"
sleep ${WAITING}
(( WAITING++ ))
ELIGIBLE=`head -${OCCURENCES} ${FICSEM}|grep -cw "${PID}"`
ELIGIBILITE=`grep -cw "${PID}" ${FICSEM}`
(( ! ${ELIGIBILITE} )) && echo "${PID}" >> ${FICSEM}
CPID=`head -1 ${FICSEM}`
[ ! -d /proc/${CPID} ] && fct_libere_exec "@${NOM}@${CPID}"
done
fct_message -nolog -color vert "."
fi
return $(( ${MODE} & ( ${MODE} ^ ${ELIGIBLE} ) ))
}
typeset -Ffx fct_unique_exec
# --------------------------------------------------------------------------------------------------------------
function fct_libere_exec()
{
# Objet : Signaler la fin d execution unique d un script shell
#
# Syntaxe : fct_libere_exec
#
local NOM=$1
local PID=$$
local FICSEM
# -- Marquage
fct_message -debug 0 "<lib:fct_libere_exec> Nom:${NOM} PID:${PID}"
[ "${NOM:0:1}" = "@" ] && PID=${NOM##*@} && NOM=${NOM%@*} && NOM=${NOM#@}
[ -n "${NOM}" ] && FICSEM=`echo ${SH_FICSEM}|sed "s/\.sem$/_${NOM}\.sem/"` || FICSEM=${SH_FICSEM}
if [ -f ${FICSEM} ]
then
cat ${FICSEM}|grep -wv "${PID}" > ${FICSEM}.tmp
mv ${FICSEM}.tmp ${FICSEM}
[ ! -s ${FICSEM} ] && rm ${FICSEM}
fi
}
typeset -Ffx fct_libere_exec

24
lib/usage.lib Executable file
View File

@ -0,0 +1,24 @@
##----------------------------------------------------------------------------
## Script : usage.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 10-02-2016
## Version : 1.0.0
## Objet : affiche l'entete du script passer en parametre commencant par ##
##
## Fonction : fct_usage Nom_Script
##
## Detail :
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0 10-02-2016 - Emmanuel Confrere - Creation : Reprise du script du socle Oracle
##----------------------------------------------------------------------------
function fct_usage
{
local L_PROG_NAME=$1
sed -n "/^##/s/^##//p" ${L_PROG_NAME}
}
typeset -Ffx fct_usage

32
lib/what.lib Executable file
View File

@ -0,0 +1,32 @@
##----------------------------------------------------------------------------
## Script : what.lib
## Module Puppet : gnc-script_core_dtsi
## Auteur : Emmanuel Confrere
## Date : 10-02-2016
## Version : 1.1.0-1
## Objet : Fournie la version et l objet du fichier passe en parametre
##
## Fonction : what Nom_Fichier
##
## Detail :
##
# ----------------------------------------------------------------------------
# Mise a jour :
# 1.0.0-0 24-01-2008 - Emmanuel - Creation
# 1.0.0-1 06-06-2008 - Emmanuel - Correction des noms de variable
# 1.1.0-0 06-06-2008 - Emmanuel - Ajout recherche fichier
# 2.0.0-0 10-02-2016 - Emmanuel Confrere - Integration au socle DTSI
##----------------------------------------------------------------------------
what()
{
local L_FICHIER=`which $1`
if [ -f ${L_FICHIER} ]
then
grep "^## Version" ${L_FICHIER}|sed 's/#* *//'
grep "^## Objet" ${L_FICHIER}|sed 's/#* *//'
fi
}
typeset -fx what

3
tetalab.sh Normal file
View File

@ -0,0 +1,3 @@
NC_EXPL_ROOT=/opt/tetalab
export NC_EXPL_ROOT
source ${NC_EXPL_ROOT}/conf/shell-env/profile_init.env