From f04e862bc08d23162f942ce1f0bab6650742fcc0 Mon Sep 17 00:00:00 2001 From: Jephte Clain Date: Sun, 24 Apr 2016 18:50:20 +0400 Subject: [PATCH] =?UTF-8?q?impl=C3=A9mentation=20initiale=20de=20runsmod?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/default/runsmod | 63 +++++ lib/ulib/runsmod | 472 ++++++++++++++++++++++++++++++++++++++ lib/ulib/runsmod.defaults | 37 +++ runsmod | 141 ++++++++++++ 4 files changed, 713 insertions(+) create mode 100644 lib/default/runsmod create mode 100644 lib/ulib/runsmod create mode 100644 lib/ulib/runsmod.defaults create mode 100644 runsmod diff --git a/lib/default/runsmod b/lib/default/runsmod new file mode 100644 index 0000000..6243a7d --- /dev/null +++ b/lib/default/runsmod @@ -0,0 +1,63 @@ +# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 + +# Type d'url à préférer pour le clonage des dépôts récupérés automatiquement. +# Cette valeur détermine le mode de fonctionnement: mode production ou mode +# développement. +# En mode production, les dépôts doivent être accessibles sans authentification +# et sont en lecture seule. En mode développement, les dépôts sont typiquement +# accédés par ssh et sont à priori modifiables. +#RUNSMOD_MODE=prod + +# Mode opératoire pour la récupération des dépôts. Avec la valeur 'offline', ni +# clone ni pull ne sont autorisés: le module doit avoir déjà été cloné si on +# veut l'utiliser. Avec la valeur 'clone' seul le clonage est autorisé, e.g. le +# dépôt est cloné si ce n'est pas déjà le cas. Avec la valeur 'pull', cloner le +# dépôt si ce n'est pas déjà le cas, ou le mettre à jour le dépôt avant de +# l'utiliser s'il avait déjà été cloné. Avec la valeur 'auto', utiliser 'pull' +# en mode production et 'clone' en mode développement. +#RUNSMOD_UPDATE=auto + +# Fichier d'identité par défaut pour la connexion par ssh en mode développement +#RUNSMOD_IDENTITY="$HOME/.ssh/id_rsa" + +# URL de base par défaut pour les définitions de dépôts. Toutes les définitions +# de dépôt sont relatives à cet url de base i.e. si RUNSMOD_BASEURL="git@host" +# alors la définition de dépôt "runs" est résolue en "git@host:runs" +#RUNSMOD_BASEURL= + +# Définitions par défaut des dépôts pour les scripts génériques. Ces URLs sont +# relatifs à RUNSMOD_BASEURL et peuvent contenir %h pour l'hôte, et %m pour le +# nom du module. Si aucune de ces variables n'apparait, on considère que c'est +# un dépôt unique. +#RUNSMOD_SCRIPTS_URLS=(hosts/%h/runs runs-scripts) + +# Définitions par défaut des dépôts pour les modules. Ces URLs sont relatifs à +# RUNSMOD_BASEURL et peuvent contenir %h pour l'hôte, et %m pour le nom du +# module. Si aucune de ces variables n'apparait, on considère que c'est un +# dépôt unique. +#RUNSMOD_MODULES_URLS=(hosts/%h/modules/%m modules/%m) + +# Définitions par défaut des dépôts dans lesquels rechercher des répertoires +# d'hôtes qui contiennent scripts et modules spécifiques aux hôtes. Ces URLs +# sont relatifs à RUNSMOD_BASEURL et ne *doivent pas* contenir de variable comme +# %h ou %m. +#RUNSMOD_HOSTS_URLS=(runs-hosts) + +# Répertoire de base dans lequel sont clonés les dépôts. +#RUNSMOD_BASEDIR="$HOME/runs" + +# Liste de profils à utiliser pour la récupération automatique. Lors de la +# recherche d'un module, ces serveurs sont testés dans l'ordre mentionné +# ici. Pour chacun de ces serveurs, il est possible de définir des variables qui +# remplacent les valeurs par défaut définies ci-dessus. +#RUNSMOD_PROFILES=(vcs) + +### Exemples de définitions pour le profil vcs +#RUNSMOD_vcs_IDENTITY=... +#RUNSMOD_vcs_BASEURL=http://vcs.tld/anongit/ +#RUNSMOD_vcs_prod_BASEURL=http://vcs.tld/anongit/ +#RUNSMOD_vcs_devel_BASEURL=git@vcs.tld: +#RUNSMOD_vcs_SCRIPTS_URLS=(...) +#RUNSMOD_vcs_MODULES_URLS=(...) +#RUNSMOD_vcs_HOSTS_URLS=(...) +#RUNSMOD_vcs_BASEDIR=... diff --git a/lib/ulib/runsmod b/lib/ulib/runsmod new file mode 100644 index 0000000..96fec24 --- /dev/null +++ b/lib/ulib/runsmod @@ -0,0 +1,472 @@ +##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 +## Gestion des modules pour runs +##@cooked nocomments +##@require base +uprovide runsmod +urequire base + +function __runsmod_loadconf() { + # Charger le fichier de configuration $1. Les paramètres RUNSMOD_MODE et + # RUNSMOD_UPDATE peuvent être modifiés par rapport à la configuration + # chargée avec les paramètres $2 et $3 respectivement. + local config="$1" mode="$2" update="$3" + + urequire runs.defaults + set_defaults runs + if [ -n "$config" ]; then + [ -f "$config" ] || { + eerror "$config: fichier introuvable" + return 1 + } + source "$config" || { + eerror "Erreur de configuration" + return 1 + } + fi + + [ -n "$mode" ] || mode="$RUNSMOD_MODE" + case "$mode" in + production|prod|p) mode=prod;; + development|devel|dev|d) mode=devel;; + *) die "$mode: mode invalide. Ce doit être prod ou devel";; + esac + RUNSMOD_MODE="$mode" + + [ -n "$update" ] || update="$RUNSMOD_UPDATE" + if [ "$update" == auto ]; then + case "$RUNSMOD_MODE" in + prod) update=pull;; + devel) update=clone;; + esac + fi + RUNSMOD_UPDATE="$update" + case "$RUNSMOD_UPDATE" in + offline) RUNSMOD_CLONE=; RUNSMOD_PULL=;; + clone) RUNSMOD_CLONE=1; RUNSMOD_PULL=;; + pull) RUNSMOD_CLONE=1; RUNSMOD_PULL=1;; + esac + + return 0 +} + +function __runsmod_get() { + # obtenir la valeur de la première variable définie dans une liste + # construite à partir des arguments de cette fonction. + # $1 étant le suffixe, pour chacun des préfixes $2..@, tester l'existence de + # la variable "RUNSMOD_${prefix}_${suffix}". Le cas particulier prefix=="" + # teste l'existence de la variable RUNSMOD_${suffix} + # Si la liste des préfixes n'est pas spécifiée, prendre par défaut la liste + # suivante: ("${RUNSMOD_PROFILE}_${RUNSMOD_MODE}" "$RUNSMOD_PROFILE" "") + + # Si $1=-a, alors copier un tableau plutôt qu'afficher une valeur + # scalaire. dans ce cas, $2 est le nom du tableau destination, et toutes les + # autres valeurs indiquées ci-dessus sont décalées de 2 vers la droite + local _array + if [ "$1" == -a ]; then + _array="$2" + shift; shift + fi + local _suffix="$1"; shift + [ -n "$_suffix" ] || return 1 + + if [ $# -eq 0 ]; then + # préfixes par défaut + local -a _args + if [ -n "$RUNSMOD_PROFILE" ]; then + if [ -n "$RUNSMOD_MODE" ]; then + _args=("${_args[@]}" "${RUNSMOD_PROFILE}_${RUNSMOD_MODE}") + fi + _args=("${_args[@]}" "$RUNSMOD_PROFILE") + fi + _args=("${_args[@]}" "") + set -- "${_args[@]}" + fi + local _prefix _var + local -a _values + for _prefix in "$@"; do + if [ -n "$_prefix" ]; then + _var="RUNSMOD_${_prefix}_${_suffix}" + else + _var="RUNSMOD_${_suffix}" + fi + if [ -n "$_array" ]; then + array_copy _values "$_var" + if [ ${#_values[*]} -gt 0 -a -n "${_values[0]}" ]; then + array_copy "$_array" "$_var" + return 0 + fi + else + _var="${!_var}" + if [ -n "$_var" ]; then + echo "$_var" + return 0 + fi + fi + done + return 1 +} + +function __runsmod_fixurl() { + # Ajouter la définition de dépôt $1 à l'url de base $2 pour en faire un url + # de dépot. + local url="$2" + case "$url" in + http:*|https:*) + [ "${url%/}" != "$url" ] || url="$url/" + ;; + *) + if [[ "$url" == *: ]]; then + : + elif [[ "$url" == *:* ]]; then + [ "${url%/}" != "$url" ] || url="$url/" + else + url="$url:" + fi + ;; + esac + echo "$url$1" +} + +function __runsmod_getpath_from_baseurl() { + # obtenir le nom correspond à un url de base, utilisable dans un chemin + local url="$1" path userhost user host dummy + case "$url" in + http:*|https:*) + path="${url%/}" + path="${path/:\/\//_}" + path="${path//\//_}" + echo "$path" + return + ;; + *) + splitpair "$url" userhost dummy + splituserhost "$userhost" user host + echo "ssh_${user}_${host}" + ;; + esac +} + +__RUNSMOD_CONNECT_TIMEOUT=3 + +function __runsmod_dumpurl() { + if progexists curl; then + curl -fs --connect-timeout "$__RUNSMOD_CONNECT_TIMEOUT" "$@" + elif progexists wget; then + wget -q --connect-timeout "$__RUNSMOD_CONNECT_TIMEOUT" -O - "$@" + else + eerror "Nécessite curl ou wget" + return 1 + fi +} + +function __runsmod_getinfo() { + # interroger le serveur gitolite à l'url de base $1 avec la commande info + local url="$1" + case "$url" in + http:*|https:*) + __runsmod_dumpurl "${url%/}/info" + ;; + *) + local userhost dummy + splitpair "$url" userhost dummy + local -a options + options=( + -o StrictHostKeyChecking=no + -o BatchMode=yes + -o ConnectTimeout="$__RUNSMOD_CONNECT_TIMEOUT" + ) + "${GIT_SSH:-ssh}" -q "${options[@]}" "$userhost" info + ;; + esac +} +function __runsmod_fixinfo() { + # traiter le résultat de __runsmod_getinfo() pour avoir la liste des dépôts + sed -n '3,$p' | sed 's/^.*\t//g' +} + +function runsmod_checkenv() { + # vérifier l'environement. créer les répertoires nécessaires. + if [ -z "$RUNSMOD_BASEDIR" ]; then + eerror "Vous devez définir RUNSMOD_BASEDIR" + return 1 + fi + if [ ! -d "$RUNSMOD_BASEDIR" ]; then + estep "Création de $(ppath "$RUNSMOD_BASEDIR")" + mkdir -p "$RUNSMOD_BASEDIR" || return 1 + fi +} + +function __runsmod_get_repolistfile() { + # obtenir le chemin absolu vers le fichier contenant la liste des dépôts + # correspondant à l'url de base $1 + local repopath + setx repopath=__runsmod_getpath_from_baseurl "$1" + echo "$RUNSMOD_BASEDIR/$repopath.lst" +} + +function runsmod_should_update_repolists() { + # tester s'il faut mettre à jour au moins un des fichiers contenant les + # listes des dépôts + local RUNSMOD_PROFILE + local now baseurl repobase repopath repolistfile mtime + local -a urls + setx now=date +%s + for RUNSMOD_PROFILE in "${RUNSMOD_PROFILES[@]}"; do + setx baseurl=__runsmod_get BASEURL || continue + setx repolistfile=__runsmod_get_repolistfile "$baseurl" + + # si le fichier n'existe pas, il faut mettre à jour + [ -f "$repolistfile" ] || return 0 + # si le fichier a été modifié depuis plus de 24 heures, mettre à jour + setx mtime=stat -c %Y "$repolistfile" + [ $(($now - $mtime)) -lt 86400 ] || return 0 + done + return 1 +} + +function runsmod_update_repolists() { + # mettre à jour si nécessaire les fichiers contenant les listes des dépôts. + # Si $1 n'est pas vide, forcer la mise à jour de tous les fichiers + local force="$1"; shift + local RUNSMOD_PROFILE + local now baseurl repobase repopath repo mtime update + local -a urls + setx now=date +%s + for RUNSMOD_PROFILE in "${RUNSMOD_PROFILES[@]}"; do + setx baseurl=__runsmod_get BASEURL || continue + setx repolistfile=__runsmod_get_repolistfile "$baseurl" + + update="$force" + if [ -z "$update" ]; then + # si le fichier n'existe pas, il faut mettre à jour + [ -f "$repolistfile" ] || update=1 + fi + if [ -z "$update" ]; then + # si le fichier a été modifié depuis plus de 24 heures, mettre à jour + setx mtime=stat -c %Y "$repolistfile" + [ $(($now - $mtime)) -lt 86400 ] || update=1 + fi + if [ -n "$update" ]; then + local list + ebegin "$baseurl" + if setx list=__runsmod_getinfo "$baseurl"; then + echo "$list" | __runsmod_fixinfo >"$repolistfile" + edot 0 + else + edot 1 + fi + eend + fi + done +} + +function runsmod_setup_vars() { + # récupérer configuration statique pour la mettre à jour + array_new REPODIRS + array_split SCRIPTSDIRS "$RUNSSCRIPTSPATH" : + array_split MODULESDIRS "$RUNSMODULESPATH" : + array_split HOSTSDIRS "$RUNSHOSTSPATH" : +} + +function __runsmod_has_vmodule() { + # tester si l'url $1 contient une variable de module %m + [ "${1//%m/}" != "$1" ] +} +function __runsmod_has_vhost() { + # tester si l'url $1 contient une variable d'hôte %h + [ "${1//%h/}" != "$1" ] +} +function __runsmod_replace1() { + # remplacer dans l'url $1 la variable %h par l'hôte complet $2 et + # éventuellement la variable %m par le module $3 + local url="$1" + [ -n "$2" ] && url="${url//%h/$2}" + [ -n "$3" ] && url="${url//%m/$3}" + echo "$url" +} +function __runsmod_replace2() { + # remplacer dans l'url $1 la variable %h par le nom d'hôte correspondant à + # au nom d'hôte complet $2 et éventuellement la variable %m par le module $3 + local url="$1" + local host="${2%%.*}" + [ -n "$host" ] && url="${url//%h/$host}" + [ -n "$3" ] && url="${url//%m/$3}" + echo "$url" +} + +function __runsmod_clone_or_pull() { + local repourl="$1" repodir="$2" + mkdirof "$repodir" + if [ -d "$repodir" ]; then + if [ -n "$RUNSMOD_PULL" ]; then + estepi "pull $(ppath "$repodir") [$repourl]" + (cd "$repodir"; git pull) + return $? + else + estep "nopull $(ppath "$repodir")" + return 0 + fi + else + if [ -n "$RUNSMOD_CLONE" ]; then + estepi "clone $(ppath "$repodir") [$repourl]" + git clone "$repourl" "$repodir" + return $? + else + estepe "noclone $(ppath "$repodir")" + return 1 + fi + fi +} + +function runsmod_clone_or_pull() { + # Chercher les modules $3..@, pour l'hôte $1 qui est le mode d'hôte: none, + # all, self ou one pour un hôte spécifique $2. Ajouter les chemins dans le + # tableau REPO_DIRS. Mettre à jour les tableaux SCRIPTS_DIRS, MODULES_DIRS + # et HOSTS_DIRS + local all_hosts host_mode="$1" host="$2"; shift; shift + case "$host_mode" in + none) host=;; + all) host=; all_hosts=1;; + self) host="${RUNSHOST:-$MYHOST}";; + esac + if [ -n "$host" -a "${host%%.*}" == "$host" -a -n "$RUNSDOMAIN" ]; then + # le nom d'hôte doit être avec un domaine + host="$host.$RUNSDOMAIN" + enote "Autocorrection du nom d'hôte en $host" + fi + #XXX implémenter all_hosts=1 + + local -a repolist reponames repourls + local RUNSMOD_PROFILE baseurl repopath repolistfile + local vprefix repospec reponame repourl repodir module moduledir + local r=0 + + # Tout d'abord, traiter les dépôts sans variable %m + edebug "Traitement des dépôts sans vmodule" + for RUNSMOD_PROFILE in "${RUNSMOD_PROFILES[@]}"; do + setx baseurl=__runsmod_get BASEURL || continue + setx repopath=__runsmod_getpath_from_baseurl "$baseurl" + setx repolistfile=__runsmod_get_repolistfile "$baseurl" + [ -f "$repolistfile" ] || continue + array_from_lines repolist "$(<"$repolistfile")" + + edebug ".. baseurl=$baseurl, repopath=$repopath" + for vprefix in SCRIPTS MODULES HOSTS; do + __runsmod_get -a repourls "${vprefix}_URLS" + edebug ".... vprefix=$vprefix, repourls=(${repourls[*]})" + + for repospec in "${repourls[@]}"; do + edebug "...... repospec=$repospec" + __runsmod_has_vmodule "$repospec" && continue + + reponames=() + if __runsmod_has_vhost "$repospec"; then + if [ -n "$host" ]; then + setx reponame=__runsmod_replace1 "$repospec" "$host" + array_contains repolist "$reponame" && array_add reponames "$reponame" + + setx reponame=__runsmod_replace2 "$repospec" "$host" + array_contains repolist "$reponame" && array_add reponames "$reponame" + fi + else + array_contains repolist "$repospec" && array_add reponames "$repospec" + fi + + edebug "...... reponames=(${reponames[*]})" + for reponame in "${reponames[@]}"; do + repodir="$RUNSMOD_BASEDIR/$repopath/$reponame" + + setx repourl=__runsmod_fixurl "$reponame" "$baseurl" + __runsmod_clone_or_pull "$repourl" "$repodir" || r=1 + + [ -d "$repodir" ] || continue + array_addu REPODIRS "$repodir" + case "$vprefix" in + SCRIPTS) array_addu SCRIPTSDIRS "$repodir";; + #MODULES) ;; + HOSTS) array_addu HOSTSDIRS "$repodir";; + esac + done + done + done + done + + ## Ensuite, traiter les dépôts de module + + # modules contient la liste des modules qui ont été trouvés, pour ne pas les + # lister en double s'ils existent dans plusieurs sources + edebug "Traitement des dépôts de modules" + local -a modules foundmodules + + modules=("$@") + for RUNSMOD_PROFILE in "${RUNSMOD_PROFILES[@]}"; do + setx baseurl=__runsmod_get BASEURL || continue + setx repopath=__runsmod_getpath_from_baseurl "$baseurl" + setx repolistfile=__runsmod_get_repolistfile "$baseurl" + [ -f "$repolistfile" ] || continue + array_from_lines repolist "$(<"$repolistfile")" + + edebug ".. baseurl=$baseurl, repopath=$repopath" + for module in "${modules[@]}"; do + array_contains foundmodules "$module" && continue + edebug ".... module=$module" + + for vprefix in SCRIPTS MODULES HOSTS; do + __runsmod_get -a repourls "${vprefix}_URLS" + edebug "...... vprefix=$vprefix, repourls=(${repourls[*]})" + + for repospec in "${repourls[@]}"; do + edebug "........ repospec=$repospec" + __runsmod_has_vmodule "$repospec" || continue + + reponames=() + if __runsmod_has_vhost "$repospec"; then + if [ -n "$host" ]; then + setx reponame=__runsmod_replace1 "$repospec" "$host" "$module" + array_contains repolist "$reponame" && array_add reponames "$reponame" + + setx reponame=__runsmod_replace2 "$repospec" "$host" "$module" + array_contains repolist "$reponame" && array_add reponames "$reponame" + fi + else + setx reponame=__runsmod_replace1 "$repospec" "" "$module" + array_contains repolist "$reponame" && array_add reponames "$reponame" + fi + + edebug "........ reponames=(${reponames[*]})" + for reponame in "${reponames[@]}"; do + repodir="$RUNSMOD_BASEDIR/$repopath/$reponame" + + setx repourl=__runsmod_fixurl "$reponame" "$baseurl" + __runsmod_clone_or_pull "$repourl" "$repodir" || r=1 + + [ -d "$repodir" ] || continue + array_addu foundmodules "$module" + + array_addu REPODIRS "$repodir" + case "$vprefix" in + SCRIPTS) array_addu SCRIPTSDIRS "$repodir";; + MODULES) + setx moduledir=dirname -- "$repodir" + array_addu MODULESDIRS "$moduledir" + ;; + HOSTS) array_addu HOSTSDIRS "$repodir";; + esac + done + done + done + done + done + + for module in "${modules[@]}"; do + array_contains foundmodules "$module" || ewarn "$module: module non trouvé" + done + + return $r +} + +function runsmod_teardown_vars() { + setx RUNSSCRIPTSPATH=array_join SCRIPTSDIRS : + setx RUNSMODULESPATH=array_join MODULESDIRS : + setx RUNSHOSTSPATH=array_join HOSTSDIRS : +} diff --git a/lib/ulib/runsmod.defaults b/lib/ulib/runsmod.defaults new file mode 100644 index 0000000..455dbb0 --- /dev/null +++ b/lib/ulib/runsmod.defaults @@ -0,0 +1,37 @@ +##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 +## Valeurs par défaut pour runs.modules +##@cooked nocomments +##@require base +uprovide runsmod.defaults + +# Ne pas supprimer la ligne ci-dessous +##--runsmod.defaults-- +RUNSMOD_MODE=prod +RUNSMOD_UPDATE=auto +RUNSMOD_IDENTITY= +RUNSMOD_BASEURL= +RUNSMOD_SCRIPTS_URLS=(hosts/%h/runs runss runs-scripts) +RUNSMOD_MODULES_URLS=(hosts/%h/modules/%m modules/%m) +RUNSMOD_HOSTS_URLS=(runsh runs-hosts) +RUNSMOD_BASEDIR="$HOME/runs" +RUNSMOD_PROFILES=(vcs pvcs jclain) + +# vcs +RUNSMOD_vcs_BASEURL=http://vcs.univ-reunion.fr/anongit +RUNSMOD_vcs_devel_BASEURL=git@vcs.univ.run +RUNSMOD_vcs_SCRIPTS_URLS=("${RUNSMOD_SCRIPTS_URLS[@]}") +RUNSMOD_vcs_MODULES_URLS=("${RUNSMOD_MODULES_URLS[@]}") +RUNSMOD_vcs_HOSTS_URLS=("${RUNSMOD_HOSTS_URLS[@]}") + +# pvcs +RUNSMOD_pvcs_BASEURL=http://pvcs.univ-reunion.fr/anongit +RUNSMOD_pvcs_devel_BASEURL=pgit@vcs.univ.run +RUNSMOD_pvcs_SCRIPTS_URLS=("${RUNSMOD_SCRIPTS_URLS[@]}" si/base-runs) +RUNSMOD_pvcs_MODULES_URLS=("${RUNSMOD_MODULES_URLS[@]}") +RUNSMOD_pvcs_HOSTS_URLS=("${RUNSMOD_HOSTS_URLS[@]}") + +# jclain +RUNSMOD_jclain_BASEURL=git@jclain.fr +RUNSMOD_jclain_SCRIPTS_URLS=("${RUNSMOD_SCRIPTS_URLS[@]}") +RUNSMOD_jclain_MODULES_URLS=("${RUNSMOD_MODULES_URLS[@]}") +RUNSMOD_jclain_HOSTS_URLS=("${RUNSMOD_HOSTS_URLS[@]}") diff --git a/runsmod b/runsmod new file mode 100644 index 0000000..12e9958 --- /dev/null +++ b/runsmod @@ -0,0 +1,141 @@ +#!/bin/bash +# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 +source "$(dirname "$0")/lib/ulib/ulib" || exit 1 +urequire DEFAULTS runsmod + +function display_help() { + uecho "$scriptname: récupérer des dépôts git à usage de runs + +USAGE + $scriptname [options] [-h host] [modules...] + +Tous les dépôts spécifiés dans la configuration sont récupérés. Si des modules +sont spécifiés, les dépôts correspondants sont récupérés aussi. Avec l'option +-h, des dépôts spécifiques à l'hôte peuvent éventuellement être récupérés en +plus. + +OPTIONS + -c, --config CONFIG + Spécifier un fichier de configuration à charger au lieu de la valeur par + défaut ~/etc/default/runs + --prod + --devel + Forcer un mode de sélection des urls. En mode production, préférer pour + le clonage les urls de production, qui sont en principe accessibles sans + authentification et en lecture seule. En mode développement, préférer + pour le clonage les urls de développement, qui sont en principe + accessibles par clé ssh et en lecture/écriture + --no-fetch + Ne rien récupérer. Utile avec --update-repolist + -N, --no-host + -A, --all-hosts + -H, -h, --host HOST + -T, --this-host + Options permettant de spécifier l'hôte pour la récupération de dépôts + spécifiques. + --no-host demande explicitement à ce qu'aucun hôte ne soit spécifié + --all-hosts sélectionne tous les dépôts spécifiques + --host récupère uniquement les dépôts pour l'hôte spécifié + --this-host équivaut à --host $MYHOST + L'option par défaut est --this-host en mode production et --all-hosts en + mode développement + --update-repolist + Forcer la mise à jour de la liste des dépôts. En principe, cette mise à + jour n'est pas faite plus d'une fois par période de 24 heures. + -0, --offline + -n, --no-pull + -u, --pull + Spécifier le mode opératoire pour la récupération des dépôts. + En mode --offline, ni clone ni pull ne sont autorisés. Le module doit + avoir déjà été cloné. + En mode --no-pull, seul le clonage est autorisé, e.g. le dépôt est + cloné si ce n'est pas déjà le cas. + En mode --pull, cloner le dépôt si ce n'est pas déjà le cas, ou le + mettre à jour le dépôt avant de l'utiliser s'il avait déjà été cloné. + Par défaut, utiliser --pull en mode production et --no-pull en mode + développement. + -i, --identity IDENTITY_FILE + Spécifier le fichier depuis lequel lire la clé privée pour les + connexions par ssh. + -o, --output OUTPUT + Spécifier un fichier dans lequel écrire des définitions de variables, + notamment REPODIRS qui reçoit la liste des chemins des dépôts qui ont + été récupérés. De plus, les variables RUNSSCRIPTSPATH, RUNSMODULESPATH + et RUNSHOSTSPATH sont définies. + -a, --append-output + Ajouter au fichier OUTPUT au lieu de l'écraser" +} + +config= +mode= +fetch=1 +host_mode=auto +host= +update_repolist=auto +update=auto +identity= +output= +append_output= +parse_opts "${PRETTYOPTS[@]}" \ + --help '$exit_with display_help' \ + -c:,--config: config= \ + --prod mode=prod \ + --devel mode=devel \ + --no-fetch fetch= \ + -N,--no-host host_mode=none \ + -A,--all-hosts host_mode=all \ + -h:,-H:,--host: '$set@ host; host_mode=one' \ + -T,--this-host host_mode=self \ + --update-repolist update_repolist=1 \ + --no-update-repolist update_repolist= \ + -0,--offline update=offline \ + -n,--no-pull update=clone \ + -u,--pull update=pull \ + -i:,--identity: identity= \ + -o:,--output: output= \ + -a,--append-output append_output=1 \ + @ args -- "$@" && set -- "${args[@]}" || die "$args" + +__runsmod_loadconf "$config" "$mode" "$update" || die +runsmod_checkenv || die +estepn "Opération dans le mode $RUNSMOD_MODE" + +if [ "$host_mode" == auto ]; then + case "$RUNSMOD_MODE" in + prod) host_mode=self;; + devel) host_mode=all;; + *) host_mode=none;; + esac +fi + +if [ "$update_repolist" == auto ]; then + if runsmod_should_update_repolists; then + etitle "Vérification de la liste des dépôts" + runsmod_update_repolists + eend + fi +elif [ -n "$update_repolist" ]; then + etitle "Mise à jour de la liste des dépôts" + runsmod_update_repolists 1 + eend +fi + +r=0 +if [ -n "$fetch" ]; then + etitle "Clonage/mise à jour des dépôts" + runsmod_setup_vars + runsmod_clone_or_pull "$host_mode" "$host" "$@" || r=1 + runsmod_teardown_vars + eend +fi + +if [ -n "$output" ]; then + [ "$output" == "-" ] && output=/dev/stdout + [ -n "$append_output" ] || >"$output" + set_array_cmd REPODIRS >>"$output" + echo_setv RUNSSCRIPTSPATH="$RUNSSCRIPTSPATH" >>"$output" + echo_setv RUNSMODULESPATH="$RUNSMODULESPATH" >>"$output" + echo_setv RUNSHOSTSPATH="$RUNSHOSTSPATH" >>"$output" +fi + +exit $r