# ulib/runs

## `runs_initdir`
~~~
Initialiser le répertoire d'hôte. $1 est un nom d'hôte pleinement
qualifié, et les fichiers sont créés dans le premier répertoire de
RUNSHOSTSDIRS qui convient: si un fichier .udir existe avec un tableau
runs_domains qui contient le domaine de l'hôte spécifié, alors c'est ce
répertoire qui est sélectionné. Sinon, on prend le premier répertoire de
RUNSHOSTSDIRS.
$2 spécifie si le fichier doit être créé avec de l'aide (yes) ou avec le
script minimum (no)
$3 est le contenu à placer dans le fichier sysinfos.conf, s'il n'a pas
déjà été provisionné.
Il faut lancer __runs_setpath avant d'utiliser cette fonction et
RUNSHOSTDIRS ne doit pas être vide
~~~
## `runs_create_rscript`
~~~
Créer un modèle de script. Si $2 est spécifié, c'est un nom d'hôte
pleinement qualifié. Le répertoire d'hôte correspondant *doit* exister.
$3 spécifie si le fichier doit être créé avec de l'aide (yes) ou avec le
script minimum (no)
Si $2!="", il faut lancer __runs_setpath avant d'utiliser cette fonction
et RUNSHOSTDIRS ne doit pas être vide
Le chemin du nouveau script est ajouté au tableau new_rscripts
~~~
## `runs_unsupported_system`
~~~
Afficher un message d'erreur indiquant que le système actuel n'est pas
supporté, et quitter le script
~~~
## `runs_require_sysinfos`
~~~
Vérifier le système actuel avec check_sysinfos(), et afficher un message
d'erreur avec runs_unsupported_system() s'il ne correspond pas à la
requête
~~~
## `runs_find_host`
## `runs_add_domain`
~~~
Si $1 est nom d'hôte pleinement qualifié, retourner cette valeur
Sinon, lui rajouter le domaine RUNSDOMAIN
~~~
## `runs_find_hostfile`
~~~
Trouver et afficher le fichier d'hôte $1 dans les répertoires du tableau
$3(=RUNSHOSTSDIRS), pour l'hôte $2(=$RUNSHOST). Retourner 0 en cas de
succès, 1 en cas d'échec.
Si host=$2 est une valeur non vide, la recherche est effectuée dans
{$RUNSHOSTSDIRS}/$host et {$RUNSHOSTSDIRS}/$domain/$hostname. Sinon,
retourner 1, car il faut spécifier un nom d'hôte.
~~~
## `runs_find_datafile`
~~~
Trouver et afficher le fichier de données $1 dans le répertoire $3 s'il
est non vide puis dans les répertoires des tableaux $4(=RUNSSCRIPTSDIRS),
$5(=RUNSMODULESDIRS) et $6(=RUNSHOSTSDIRS), pour l'hôte
$2(=$RUNSHOST). Retourner 0 en cas de succès, 1 en cas d'échec.
- D'abord, si $1 *n'est pas* de la forme "./path" ou "../path", chercher
dans $3.
- Puis si l'hôte est spécifié, chercher dans {$RUNSHOSTSDIRS}/$host et
{$RUNSHOSTSDIRS}/$domain/$hostname.
- Puis chercher dans {$RUNSSCRIPTSDIRS} puis {$RUNSMODULESDIRS}.
- Puis, si $1 est de la forme "./path" ou "../path", chercher dans $3.
- Sinon, retourner 1
~~~
## `runs_initvars`
~~~
Initialiser les variables RUNSDIR, RUNSSCRIPT, RUNSDIRPATH,
RUNSSCRIPTPATH, RUNSSCRIPTDIR et RUNSSCRIPTNAME pour le script $1.
Les valeurs sont initialisées comme suit:
RUNSSCRIPT="$(abspath "$1")"
RUNSDIR="$2" (le répertoire de $RUNS*PATH dans lequel a été trouvé le
script)
Si $3!="", RUNSDIRPATH="$3" et RUNSSCRIPTPATH="$4"
Sinon, RUNSDIRPATH="$RUNSSCRIPTDIR" et RUNSSCRIPTPATH="$RUNSSCRIPTNAME"
~~~
## `runs_find_scriptfile`
~~~
Trouver sans l'afficher le script $1 dans les répertoires des tableaux
$3(=RUNSSCRIPTSDIRS), $4(=RUNSMODULESDIRS) et $5(=RUNSHOSTSDIRS), en
considérant que le script sera lancé sur l'hôte $2(=$RUNSHOST), et
initialiser les variables RUNSDIR, RUNSSCRIPT, RUNSSCRIPTDIR,
RUNSSCRIPTNAME, RUNSDIRPATH et RUNSSCRIPTPATH. Retourner 0 en cas de
succès, 1 en cas d'échec.
$6 vaut ".rs" par défaut est c'est une extension à rajouter au nom
spécifié si le fichier sans l'extension n'existe pas
RUNSDIR est le répertoire dans lequel a été trouvé le script (parmi les
valeurs fournies dans les tableaux RUNSSCRIPTSDIRS, RUNSMODULESDIRS,
RUNSHOSTSDIRS), RUNSDIRPATH est le répertoire à partir duquel est exprimé
le chemin du script (i.e RUNSDIRPATH + RUNSSCRIPTPATH == RUNSSCRIPT),
RUNSSCRIPT contient le chemin absolu vers le script, RUNSSCRIPTPATH
contient le chemin du script dans RUNSDIRPATH, RUNSSCRIPTDIR le répertoire
du script, et RUNSSCRIPTNAME le nom du script.
D'abord, si l'hôte est spécifié, chercher dans {$RUNSHOSTSDIRS}/$host et
{$RUNSHOSTSDIRS}/$domain/$hostname. Puis chercher dans {$RUNSSCRIPTSDIRS}
~~~
## `runs_find_scriptfile_reverse`
~~~
Soit le fichier de script $1, exprimée de façon absolue, trouver le
fichier parmi les tableaux $3(=RUNSSCRIPTSDIRS), $4(=RUNSMODULESDIRS)
et $5(=RUNSHOSTSDIRS), en considérant que le script sera lancé sur l'hôte
$2(=$RUNSHOST), puis initialiser les variables RUNSDIR, RUNSSCRIPT,
RUNSSCRIPTDIR, RUNSSCRIPTNAME, RUNSDIRPATH et RUNSSCRIPTPATH. Retourner 0
en cas de succès, 1 en cas d'échec.
~~~
## `runs_rscript`
~~~
Lancer le fichier $1 comme un script avec les arguments $2..$*. Retourner
la valeur de retour du script.
~~~
## `runs_recipe`
~~~
Lancer les scripts de la recette contenue dans le fichier $1. Arrêter au
premier script qui est en erreur
~~~
## `runs_rscriptpath`
~~~
Lancer le script $1 avec les arguments $2..$*. Le script est cherché dans
les répertoires de RUNSSCRIPTSPATH. Retourner 123 si le script n'est pas
trouvé, sinon retourner la valeur de retour du script.
~~~
## `runs_recipepath`
~~~
Lancer la recette $1. Le fichier de recette est cherché dans les
répertoires de RUNSSCRIPTSPATH. Retourner 123 si le fichier de recette n'a
pas été trouvé, sinon retourner la valeur de retour de runs_recipe()
~~~
## `runs_before_parse_args`
## `runs_after_parse_args`
## `runs_init`
## `runs_initdomains`
~~~
Si ce n'est pas déjà le cas, initialiser RUNSDOMAINS en fonction de
/etc/resolv.conf
~~~
## `runs_inithost`
## `runs_initsysinfos`
## `runs_initworkdir`
## `runs_after_export`
~~~
après l'export, initialiser varsfile avec les valeurs qu'il faut garder
entre le déploiement local et le déploiement distant.
~~~
## `runs_check_runsscript`
## `runs_var`
~~~
Initialiser les variables selon les directives données en ligne de
commande.
Les arguments peuvent être une suite de définitions de la forme
'scalar=value', 'scalar!=name', 'array+=value', 'array-=value' ou
'array@=name'.
Sinon, le *dernier* argument peut-être de l'une des formes suivantes:
'array value0 [value1...]' pour initialiser un tableau,
'array+ value0 [value1...]' pour ajouter des valeurs à un tableau,
'array- value0 [value1...]' pour enlever des valeurs à un tableau.
Les formes 'scalar!=value' et 'array@=value' sont des indirections et
permettent d'initialiser la variable avec la valeur d'une autre
variable. L'avantage est que la résolution de la valeur est faite
uniquement lors de l'appel de cette fonction, ce qui est utile avec des
fonction comme 'after -r'
~~~
## `runs_conf`
~~~
Activer les flags $*
~~~
## `runs_indref`
~~~
fonction de convenance pour créer des références $3..* avec le fichier de
configuration $1 et les variables $2
~~~
## `runs_refcerts`
~~~
fonction de convenance pour créer une référence à un répertoire contenant
des certificats mentionnés dans le fichier de configuration $1. Si les
références $2..* ne sont pas mentionnées, la variable certsdir dans le
fichier de configuration est utilisée.
~~~
## `runs_refapacheconfig`
~~~
fonction de convenance pour créer les références à un répertoire de
configuration pour apache.
USAGE: refapacheconfig autoconfdir=path/to/autoconfdir [certsdir=[path/to/certsdir]]
- autoconfdir= est requis et permet de définir à la fois la variable qui
contiendra la référence ainsi que le répertoire à référencer.
- certsdir= est optionel. Si cet argument est spécifié sous la forme
certsdir=path/to/certsdir, il permet de définir à la fois la variable qui
contiendra la référence ainsi que le répertoire à référencer. Si
l'argument est spécifié sous la forme certsdir=, il permet de définir la
variable qui contiendra la référence. C'est cette variable qui sera lue
dans les fichiers de configuration. Si l'argument n'est pas spécifié, on
considère que l'argument 'certsdir=' a été utilisé.
~~~
## `runs_set_lang`
~~~
Charger la valeur de LANG depuis l'environnement. La variable LANG est
initialisée
~~~
## `runs_set_proxy`
~~~
Charger la valeur du proxy depuis l'environnement. Les variables
http_proxy, ftp_proxy et no_proxy sont initialisées
~~~
## `runs_check_confs`
~~~
Vérifier l'état courant par rapport aux flags
~~~
## `runs_after`
~~~
Vérifier que ce script est lancé après le scriptpath $1, par rapport à
RUNSSTORY
~~~
## `runs_clvars`
~~~
Traiter les spécifications de variables données en ligne de commande ou
dans un fichier de recettes
~~~
## `runs_indvars`
~~~
Résoudre les valeurs effectives des variables qui sont des indirections
~~~
## `runs_clvars_cmd`
~~~
écrire la ligne de recette correspondant au script $1 et aux variables
$2..$*
~~~
## `runs_loadconfs`
## `runs_clearvars`
## `runs_action_desc`
## `runs_action_dump`
## `runs_action_run`
## `runs_action_export`
## `shouldrun`
## `checkdone`
## `requiredone`
## `setdone`
## `resetdone`

-*- coding: utf-8 mode: markdown -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8:noeol:binary