475 lines
16 KiB
Bash
475 lines
16 KiB
Bash
##@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 runsmod.defaults
|
|
set_defaults runsmod
|
|
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" scheme path userhost user host dummy
|
|
case "$url" in
|
|
http:*|https:*)
|
|
scheme="${url%%:*}"
|
|
path="${url#*://}"
|
|
path="${path%/}"
|
|
path="${path/:\/\//_}"
|
|
path="${path//\//_}"
|
|
echo "${path}_${scheme}"
|
|
return
|
|
;;
|
|
*)
|
|
splitpair "$url" userhost dummy
|
|
splituserhost "$userhost" user host
|
|
echo "${host}_${user}_ssh"
|
|
;;
|
|
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 :
|
|
}
|