modules
/
nutools
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Intégration de la branche tomcat-deploy

This commit is contained in:
Jephté Clain 2017-04-19 11:29:15 +04:00
parent bab9c501e5 2394edf7da
commit 1dbe02f6af
8 changed files with 1058 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/completion.d/nutools
View File

@ -7,7 +7,7 @@ function __nutools_host_completion() {
_known_hosts_real "$cur"
fi
}
complete -F __nutools_host_completion -o default uinst ruinst runs rruns
complete -F __nutools_host_completion -o default uinst ruinst runs rruns rwoinst rtoinst
if __bash_completion_module_enabled ssh; then
shopt -u hostcomplete

6
lib/ulib/base.args
View File

@ -87,7 +87,7 @@ function __po_parse_optdescs() {
option_="${optdesc_%::}"
if [[ "$2" == *=* ]]; then
# la valeur mentionnée est toujours ignorée
name_="${2%%=*}="
name_="${2%%=*}"
[ -n "$reset_" ] && eval "$name_="
else
name_="$2"
@ -98,7 +98,7 @@ function __po_parse_optdescs() {
option_="${optdesc_%:}"
if [[ "$2" == *=* ]]; then
# la valeur mentionnée est toujours ignorée
name_="${2%%=*}="
name_="${2%%=*}"
[ -n "$reset_" ] && eval "$name_="
else
name_="$2"
@ -108,7 +108,7 @@ function __po_parse_optdescs() {
else
option_="$optdesc_"
name_="$2"
[ -n "$reset_" ] && eval "$name_="
[ -n "$reset_" ] && eval "${2%%=*}="
flag_=
fi

20
lib/ulib/base.core
View File

@ -191,6 +191,22 @@ function echo_setv() {
fi
echo "$__s_var=$(qvalr "$*")"
}
function echo_setv2() {
# Afficher la commande qui recrée la variable $1
# Cette fonction est équivalente à echo_setv "$1=${!1}"
# Si d'autres arguments que le nom de la variable sont spécifiés, cette fonction
# se comporte comme echo_setv()
local __s_var="$1"; shift
if [[ "$__s_var" == *=* ]]; then
set -- "${__s_var#*=}" "$@"
__s_var="${__s_var%%=*}"
fi
if [ $# -eq 0 ]; then
echo_setv "$__s_var" "${!__s_var}"
else
echo_setv "$__s_var" "$@"
fi
}
function seta() {
# initialiser le tableau $1 avec les valeurs $2..@
# note: en principe, la syntaxe est 'seta array values...'. cependant, la
@ -219,8 +235,8 @@ function echo_seta() {
}
function echo_seta2() {
# Afficher la commande qui recrée le tableau $1
# Si des arguments sont spécifiés, cette fonction se comporte comme
# echo_seta()
# Si d'autres arguments que le nom de tableau sont spécifiés, cette fonction se
# comporte comme echo_seta()
local __s_var="$1"; shift
if [[ "$__s_var" == *=* ]]; then
set -- "${__s_var#*=}" "$@"

77
lib/ulib/deploy
View File

@ -6,15 +6,44 @@
# API publique
function deploy_query() {
deploy_query_once "$@" && return 0
if [ -n "$QUERYVARS" ]; then
deploy_query_recursive "$@" && return 0
fi
return 1
}
function deploy_query_recursive() {
local DFILE
for DFILE in "${QUERYVARS[@]}"; do
(
deploy_loadconf --no-auto-update
deploy_query_once "$@" && exit 0
if [ -n "$QUERYVARS" ]; then
deploy_query_recursive "$@" && exit 0
fi
exit 1
) && return 0
done
return 1
}
function deploy_query_once() {
# Afficher le résultat d'une requête
local alv
eval "set -- $(getopt -ov: -lallow-vars: -- "$@")"
local alv sov sdv slv sof sdf slf
eval "set -- $(getopt -ov:odl -lallow-vars:,object-vars,dest-vars,link-vars,of:,object-func:,df:,dest-func:,lf:,link-func: -- "$@")"
while [ -n "$1" ]; do
case "$1" in
-v|--allow-vars)
array_split alv "$2" ,
shift; shift
;;
-o|--object-vars) sov=1; shift;;
-d|--dest-vars) sdv=1; shift;;
-l|--link-vars) slv=1; shift;;
--of|--object-func) sof="$2"; shift; shift;;
--df|--dest-func) sdf="$2"; shift; shift;;
--lf|--link-func) slf="$2"; shift; shift;;
--) shift; break;;
*) break;;
esac
@ -27,7 +56,7 @@ function deploy_query() {
DEST|SOURCE)
if [ -n "$otype" ]; then
deploy_is_type "$otype" || {
qvals false "$otype: invalid type"
[ "$format" == shell ] && qvals false "$otype: invalid type"
return 2
}
fi
@ -35,7 +64,7 @@ function deploy_query() {
*)
if [ -n "$qtype" ]; then
deploy_is_type "$qtype" || {
qvals false "$qtype: invalid type"
[ "$format" == shell ] && qvals false "$qtype: invalid type"
return 3
}
fi
@ -43,12 +72,12 @@ function deploy_query() {
esac
if [ -n "$ltype" ]; then
deploy_is_link "$ltype" || {
qvals false "$ltype: invalid link type"
[ "$format" == shell ] && qvals false "$ltype: invalid link type"
return 4
}
fi
[ -n "$term" ] || {
qvals false "search term required"
[ "$format" == shell ] && qvals false "search term required"
return 5
}
@ -57,23 +86,40 @@ function deploy_query() {
edebug "=== search type DEST"
edebug "term=$term, otype=$otype"
deploy_search_artifact object type "$term" "$otype" host || {
qvals false "artifact not found"
[ "$format" == shell ] && qvals false "artifact not found"
return 1
}
edebug "object=$object, type=$type"
deploy_search_link link "$type" "$ltype" || {
qvals false "link not found"
[ "$format" == shell ] && qvals false "link not found"
return 1
}
deploy_show_values object object "$format" shell alv
deploy_show_values type otype "$format" shell alv
deploy_show_values link ltype "$format" shell alv
deploy_show_links "$object" "$link" "$profile" "$format" "" alv
if [ -n "$sov" ]; then
deploy_copy_object_values vs "$object" "$type"
deploy_show_values vs "$type" "$format" shell alv
deploy_show_attrs "$object" "$type" "$format" alv vars "$sof"
fi
if [ -n "$sdv" ]; then
local -a pons pgns ons gns ans ovs os; local an av o
deploy_prepare_copy_link_attrs pons pgns ons gns "$object" "$link" "$profile"
deploy_copy_link_attr_values hvs host "$object" "$link" "$profile" pons pgns ons gns
for hv in "${hvs[@]}"; do
deploy_copy_object_values hs "$hv" host
deploy_show_values hs host "$format" shell alv
deploy_show_attrs "$hn" host "$format" alv vars "$sdf"
done
fi
deploy_show_links "$object" "$link" "$profile" "$format" "" alv vars "$slf"
[ "$format" == shell ] && echo true
return 0
;;
SOURCE)
# XXX implémenter
[ "$format" == shell ] && echo true
return 0
;;
*)
@ -83,9 +129,10 @@ function deploy_query() {
deploy_show_values type otype "$format" shell alv
deploy_show_values vs "$type" "$format" "" alv
deploy_show_attrs "$object" "$type" "$format" alv
[ "$format" == shell ] && echo true
return 0
fi
qvals false "artifact not found"
[ "$format" == shell ] && qvals false "artifact not found"
return 1
;;
esac
@ -224,10 +271,7 @@ function deploy_show_values() {
[ -n "$ff" -a "$f" != "$ff" ] && return
case "$f" in
shell)
[ -n "$5" ] && echo "$t=()"
deploy_dump_values "$t" vs
;;
shell) deploy_dump_values "$t" vs;;
line) array_to_lines vs;;
*) array_join vs "$f";;
esac
@ -244,16 +288,17 @@ function deploy_show_attrs() {
local -a ons gns ans vs; local an
deploy_prepare_copy_attrs ons gns "$o" "$t"
deploy_copy_attr_names ans "$o" "$t" ons gns
[ -n "$5" ] && echo_seta "${t}_vars" "${ans[@]}"
for an in "${ans[@]}"; do
if [ -n "$4" ]; then
if ! array_isempty "$4"; then
array_contains alv "$an" || continue
fi
[ "$f" == shell ] && echo "$an=()"
fi
deploy_copy_attr_values vs "$an" "$o" "$t" ons
deploy_dump_values "$an" vs
done
[ -n "$6" ] && echo "$6"
}
function deploy_show_links() {
@ -272,6 +317,7 @@ function deploy_show_links() {
deploy_prepare_copy_link_attrs pons pgns ons gns "$o" "$l" "$p"
deploy_copy_link_attr_names ans "$o" "$l" "$p" pons pgns ons gns
[ -n "$7" -a "$f" == shell ] && echo_seta "${l}_vars" "${ans[@]}"
for an in "${ans[@]}"; do
deploy_copy_link_attr_values avs "$an" "$o" "$l" "$p" pons pgns ons gns
if [ "$an" == host ]; then
@ -287,6 +333,7 @@ function deploy_show_links() {
deploy_show_values avs "$an" "$f" shell alv
fi
done
[ -n "$8" -a "$f" == shell ] && echo "$8"
done
}

252
rtoinst Executable file
View File

@ -0,0 +1,252 @@
#!/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 pyulib/pyulib
function display_help() {
uecho "$scriptname: Déploiement distant avec toinst
USAGE
$scriptname [-h host] [-T tmproot] <archive|dir> [-- options de toinst]
note: à cause d'une limitation de makeself, les options de toinst ne devraient
pas contenir d'espaces ni de caractères spéciaux. L'échappement de ces
caractères n'est pas garanti.
OPTIONS
-T, --tmproot TMPROOT
Spécifier le répertoire temporaire sur l'hôte distant, comme par exemple
/var/tmp. Cette option est utile pour les vservers, qui ont par défaut
un /tmp minuscule de 16 Mo.
-S, --ssh SSH
Spécifier le programme à utiliser pour la connection par ssh.
-h, --host hosts
-h, --host @hostsfile
Spécifier un ou plusieurs hôtes sur lequels faire le déploiement. Pour
spécifier plusieurs hôtes, il est possible d'utiliser plusieurs fois
l'option -h, ou spécifier en une seule fois plusieurs hôtes en les
séparant par un espace ou le caractère ':', e.g. 'host1 host2' ou
'host1:host2'. Si la spécification contient les caractères { et },
l'expansion est effectuée, e.g
-h 'root@{host1,host2}.univ.run'
Par défaut, la connexion sur l'hôte distant se fait avec l'utilisateur
root. Il est possible de spécifier un autre utilisateur avec la syntaxe
user@host, e.g -h user@host
La forme @hostsfile permet de lire la liste des hôtes depuis le fichier
hostsfile, à raison d'un hôte par ligne.
--deploy
--no-deploy
Autoriser (respectivement interdire) l'utilisation de la configuration
locale de déploiement pour identifier la destination si aucun hôte n'est
spécifié.
Par défaut, si aucun hôte n'est spécifié, la configuration locale de
déploiement est interrogée pour avoir cette information.
-c, --deploy-config CONFNAME
Spécifier le nom de la configuration à utiliser pour l'interrogation de
la configuration locale de déploiement. Par défaut, utiliser le nom
'rtoinst'
-p, --deploy-profile PROFILE
Spécifier le profil à utiliser pour l'interrogation de la configuration
locale de déploiement. Par défaut, aucun profil n'est sélectionné."
}
__PARSED_HOSTS=()
__PARSED_FILES=()
function parse_hostsfile() {
# Lire chacun des fichiers $* et initialiser __PARSED_HOSTS avec la liste
# des hôtes mentionnés dans les fichiers.
local inputfile basedir inputs input
for inputfile in "$@"; do
inputfile="$(abspath "$inputfile")"
array_contains __PARSED_FILES "$inputfile" && {
ewarn "$(ppath "$inputfile"): inclusion récursive"
continue
}
array_add __PARSED_FILES "$inputfile"
basedir="$(dirname "$inputfile")"
array_from_lines inputs "$(<"$inputfile" filter_conf)" || {
ewarn "$inputfile: fichier ingnoré"
continue
}
for input in "${inputs[@]}"; do
if [ "${input#@}" != "$input" ]; then
# fichier inclus
parse_hostsfile "$(abspath "${input#@}" "$basedir")"
else
array_addu __PARSED_HOSTS "$input"
fi
done
done
}
function __expand_braces() {
if [[ "$1" == *{* ]] && [[ "$1" == *}* ]]; then
eval "echo $1"
else
echo "$1"
fi
}
function __dot_is_localhost() { [ "$1" == "." ] && echo "localhost" || echo "$1"; }
function fix_hosts() {
# Si hosts contient des éléments multiple, comme a:b, séparer ces
# éléments. i.e (a b:c) --> (a b c)
# Supporter la syntaxe @hostsfile qui permet de charger la liste des hôtes
# depuis un fichier.
# Remplacer aussi les '.' par 'localhost'
array_map hosts __expand_braces
array_fix_paths hosts ":"
array_fix_paths hosts " "
local -a _hosts _tmphosts host
for host in "${hosts[@]}"; do
host="${host%/}"
if [ "${host#@}" != "$host" ]; then
__PARSED_HOSTS=()
parse_hostsfile "${host#@}"
array_fix_paths __PARSED_HOSTS
array_extendu _hosts __PARSED_HOSTS
else
array_addu _hosts "$host"
fi
done
array_copy hosts _hosts
array_map hosts __dot_is_localhost
}
action=deploy
tmproot=
SSH=
hosts=()
deploy_enable=1
deploy_confname=rtoinst
deploy_profile=
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
-T:,--tmproot: tmproot= \
-S:,--ssh: SSH= \
-h:,-H:,--host: hosts \
--deploy deploy_enable=1 \
--no-deploy deploy_enable= \
-c:,--deploy-config: deploy_confname= \
-p:,--deploy-profile: deploy_profile= \
@ args -- "$@" && set -- "${args[@]}" || die "$args"
: "${SSH:=ssh}"
## webapp à déployer
if [ $# -eq 0 ] || [[ "$1" == -* ]]; then
# pas d'argument, ou c'est une option (qui fait donc partie des arguments de toinst)
[ -d WEB-INF ] && webapp=. || webapp=
read_value "Veuillez entrer la webapp à déployer" webapp "$webapp" O
set -- "$webapp" "$@"
fi
## Hôtes sur lesquels faire le déploiement
toinst_options=()
if array_isempty hosts && [ -n "$deploy_enable" ]; then
urequire deploy
deploy_setconf "$deploy_confname"
if deploy_loadconf; then
setxx webapp=abspath "$1" // basename --
if eval "$(deploy_query -v host,wamap,protect DEST webapp rtoinst_deploy "$deploy_profile" shell "$webapp")"; then
msg="Cette webapp sera déployée vers les hôtes suivants:
$(array_to_lines host "" " ")"
if [ -n "$wamap" -o -n "$protect" ]; then
msg="$msg
avec le(s) paramètre(s) suivant(s):"
[ -n "$wamap" ] && msg="$msg
--wamap $(qval "$wamap")"
[ -n "$protect" ] && msg="$msg
--protect $(qval "$protect")"
fi
check_interaction -c && einfo "$msg"
ask_any "Voulez-vous continuer?" Oq || die
array_copy hosts host
[ -n "$wamap" ] && array_add toinst_options --wamap "$wamap"
[ -n "$protect" ] && array_add toinst_options --protect "$protect"
fi
fi
fi
array_isempty hosts && read_value "Entrez une liste d'hôtes séparés par ':'" hosts "localhost"
fix_hosts
## Création de l'archive
etitle "Création du répertoire de travail"
ac_set_tmpdir workdir
webapps=()
while [ $# -gt 0 ]; do
if [ "$1" == "--" ]; then
# début des options de toinst
shift
break
elif [[ "$1" == -* ]]; then
# début des options de toinst
break
fi
osrc="$1"; shift
setx src=abspath "$osrc"
setx srcname=basename -- "$src"
if [ -f "$src" ] && is_archive "$src"; then
setx waname=get_archive_appname "$src"
estep "$(ppath "$src") --> $waname"
wadir="$workdir/$waname"
mkdir "$wadir"
extract_archive "$src" "$wadir" || die
src="$wadir"
elif [ -d "$src" ]; then
estep "$(ppath "$src")"
cp_R "$src" "$workdir/$srcname" || die
elif [ -e "$src" ]; then
die "$osrc: fichier invalide"
else
die "$osrc: fichier ou répertoire introuvable"
fi
array_add webapps "$srcname"
done
estep "Copie de l'environnement de déploiement"
mkdir "$workdir/lib"
ulibsync "$workdir/lib"
cp "$scriptdir/toinst" "$workdir"
chmod +x "$workdir/toinst"
eend
ac_set_tmpfile archive
archivename="$(basename "$archive")"
etitle "Création de l'archive pour le déploiement"
"$scriptdir/mkusfx" --bare --tmp-archive -o "$archive" "$workdir" -- ./toinst --is-tmpdir || die
eend
## Déploiement
# sur l'hôte distant, ne rendre interactif qu'à partir de -yy
rinteraction=$__interaction
[ $rinteraction -lt 2 ] && rinteraction=$(($rinteraction + 1))
for host in "${hosts[@]}"; do
if [ "$host" == "localhost" ]; then
etitle -s "Déploiement sur l'hôte local"
"$archive" ${tmproot:+--tmproot "$tmproot"} -- "${webapps[@]}" "$@" "${toinst_options[@]}"
eend
else
splituserhost "$host" user host
[ -n "$user" ] || user=root
etitle -s "Déploiement sur $user@$host"
estep "Copie de l'archive"
scp -S "$SSH" "$archive" "$user@$host:" || die
estep "Lancement du script de déploiement"
"$SSH" -qt "$user@$host" "\
__interaction=$rinteraction
__estack=$(qval "$__estack")
__tlevel=$(qval "$__tlevel")
export __interaction __estack __tlevel
${UTOOLS_LANG:+UTOOLS_LANG='$UTOOLS_LANG'; export UTOOLS_LANG
}$(qvals "./$archivename" ${tmproot:+--tmproot "$tmproot"} -- "${webapps[@]}" "$@" "${toinst_options[@]}")"
eend
fi
done

68
ruinst
View File

@ -56,37 +56,11 @@ OPTIONS
Par défaut, si aucun hôte n'est spécifié, la configuration locale de
déploiement est interrogée pour avoir cette information.
-c, --deploy-config CONFNAME
Cette option permet de spécifier le nom de la configuration à utiliser
pour effectuer la requête. Par défaut, utiliser le nom 'ruinst'"
Cette option permet de spécifier le nom de la configuration locale de
déploiement à utiliser pour effectuer la requête. Par défaut, utiliser
le nom 'ruinst'"
}
set_defaults pubkeys
action=deploy
confuser=
uses_su=
tmproot=
SSH=
force_make_archive=
hosts=()
deploy_enable=1
deploy_confname=ruinst
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
-C,--configure-user action=configure \
--configure: '$set@ confuser;action=configure' \
--uses-su uses_su=1 \
-T:,--tmproot: tmproot= \
-S:,--ssh: SSH= \
--force-make-archive force_make_archive=1 \
-h:,-H:,--host: hosts \
--deploy deploy_enable=1 \
--no-deploy deploy_enable= \
-c:,--deploy-config deploy_confname= \
@ args -- "$@" && set -- "${args[@]}" || die "$args"
: "${SSH:=ssh}"
__PARSED_HOSTS=()
__PARSED_FILES=()
function parse_hostsfile() {
@ -150,6 +124,33 @@ function fix_hosts() {
array_map hosts __dot_is_localhost
}
set_defaults pubkeys
action=deploy
confuser=
uses_su=
tmproot=
SSH=
force_make_archive=
hosts=()
deploy_enable=1
deploy_confname=ruinst
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
-C,--configure-user action=configure \
--configure: '$set@ confuser;action=configure' \
--uses-su uses_su=1 \
-T:,--tmproot: tmproot= \
-S:,--ssh: SSH= \
--force-make-archive force_make_archive=1 \
-h:,-H:,--host: hosts \
--deploy deploy_enable=1 \
--no-deploy deploy_enable= \
-c:,--deploy-config deploy_confname= \
@ args -- "$@" && set -- "${args[@]}" || die "$args"
: "${SSH:=ssh}"
################################################################################
# Configuration de l'accès par clé aux hôtes
@ -218,15 +219,13 @@ fi
################################################################################
# Déploiement
make_archive=
## Répertoire à déployer
src="$1"
if [ -z "$src" ] || [[ "$src" == -* ]]; then
if [ $# -eq 0 ] || [[ "$1" == -* ]] || [[ "$1" == *=* ]]; then
# pas d'argument, ou c'est une option (qui fait donc partie des arguments de uinst)
read_value "Entrez le répertoire à déployer" src "."
read_value "Entrez le répertoire à déployer" src "." O
else
# Enlever le répertoire à déployer. Le reste est pour uinst
src="$1"
shift
fi
@ -248,6 +247,7 @@ array_isempty hosts && read_value "Entrez une liste d'hôtes séparés par ':'"
fix_hosts
## Création de l'archive?
make_archive=
if [ -n "$force_make_archive" ]; then
make_archive=1
else

80
rwoinst
View File

@ -10,20 +10,6 @@ USAGE
$scriptname [-H host] [-T tmproot] <file|archive|dir>... [-- options de woinst]
OPTIONS
-C, --configure-user
--configure USER [--uses-su]
Ne pas faire le déploiement. Configurer uniquement la connexion par clé
sur les hôtes distants spécifiés pour le user spécifié. Il faut pouvoir
se connecter par mot de passe pour configurer la connexion par clé.
Si l'on veut configurer la connexion par clé pour le user root, mais que
ce n'est pas possible de se connecter par mot de passe avec le user root
sur l'hôte distant, et qu'il existe un user sudoer sur l'hôte distant,
il est possible de faire la configuration avec '--configure root'. La
commande serait alors
$scriptname -H user@host --configure root
Si l'hôte distant n'a pas sudo ou si sudo n'est pas configuré, il faut
rajouter l'option --uses-su, e.g:
$scriptname -h user@host --configure root --uses-su
-T, --tmproot TMPROOT
Spécifier le répertoire temporaire sur l'hôte distant, comme par exemple
/var/tmp. Cette option est utile pour les vservers, qui ont par défaut
@ -57,31 +43,6 @@ OPTIONS
pour effectuer la requête. Par défaut, utiliser le nom 'rwoinst'"
}
set_defaults pubkeys
action=deploy
confuser=
uses_su=
tmproot=
SSH=
hosts=()
deploy_enable=1
deploy_confname=rwoinst
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
-C,--configure-user action=configure \
--configure: '$set@ confuser;action=configure' \
--uses-su uses_su=1 \
-T:,--tmproot: tmproot= \
-S:,--ssh: SSH= \
-h:,-H:,--host: hosts \
--deploy deploy_enable=1 \
--no-deploy deploy_enable= \
-c:,--deploy-config deploy_confname= \
@ args -- "$@" && set -- "${args[@]}" || die "$args"
SSH="${SSH:-ssh}"
__PARSED_HOSTS=()
__PARSED_FILES=()
function parse_hostsfile() {
@ -145,25 +106,34 @@ function fix_hosts() {
array_map hosts __dot_is_localhost
}
################################################################################
# Configuration de l'accès par clé aux hôtes
action=deploy
tmproot=
SSH=
hosts=()
deploy_enable=1
deploy_confname=rwoinst
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
-T:,--tmproot: tmproot= \
-S:,--ssh: SSH= \
-h:,-H:,--host: hosts \
--deploy deploy_enable=1 \
--no-deploy deploy_enable= \
-c:,--deploy-config deploy_confname= \
@ args -- "$@" && set -- "${args[@]}" || die "$args"
if [ "$action" == "configure" ]; then
args=(${confuser:+--configure "$confuser"} ${uses_su:+--uses-su} -S "$SSH")
for host in "${hosts[@]}"; do
args=("${args[@]}" -H "$host")
done
exec "$scriptdir/ruinst" -C "${args[@]}"
fi
################################################################################
# Déploiement
: "${SSH:=ssh}"
## Bundle à déployer
if [ -z "$1" ] || [[ "$1" == -* ]] || [[ "$1" == *=* ]]; then
if [ $# -eq 0 ] || [[ "$1" == -* ]] || [[ "$1" == *=* ]]; then
# pas d'argument, ou c'est une option (qui fait donc partie des arguments de
# woinst)
die "Vous devez spécifier le bundle à déployer"
case "$(dirname "$(pwd)")" in
*.woa|*.framework) bundle=.;;
*) bundle=;;
esac
read_value "Veuillez entrer le bundle à déployer" bundle "$bundle" O
set -- "$bundle" "$@"
fi
## Hôtes sur lesquels faire le déploiement
@ -184,7 +154,7 @@ array_isempty hosts && read_value "Entrez une liste d'hôtes séparés par ':'"
fix_hosts
## Création de l'archive
etitle -s "Création du répertoire de travail"
etitle "Création du répertoire de travail"
ac_set_tmpdir workdir
bundles=()
while [ -n "$1" ]; do
@ -259,7 +229,7 @@ for host in "${hosts[@]}"; do
user=root
fi
etitle -s "Déploiement sur $user@$host"
etitle "Déploiement sur $user@$host"
estep "Copie de l'archive"
scp -S "$SSH" "$archive" "$user@$host:" || die
estep "Lancement du script de déploiement"

663
toinst Executable file
View File

@ -0,0 +1,663 @@
#!/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 xmlsupport
function display_help() {
uecho "$scriptname: Déployer une ou plusieurs webapps vers Tomcat
USAGE
$scriptname [options] <archive|dir>...
OPTIONS
-c, --config CONFIG
Spécifier un fichier de configuration qui contient les informations
spécifiées par les options ci-dessous: TOMCAT_PROFILE, CATALINA_BASE,
TOMCAT_USER, TOMCAT_GROUP, TOMCAT_VERSION, MANAGER_URL, MANAGER_USER,
MANAGER_PASSWORD, WAMAP, BACKUP, RESTART
-C, --config-profile TOMCAT_PROFILE
Spécifier le profil de configuration à utiliser. Cette valeur détermine
la façon dont sont calculés CATALINA_BASE, TOMCAT_USER, TOMCAT_GROUP et
TOMCAT_VERSION. Les valeurs valides sont:
* debian:tomcatV
Tomcat installé par 'apt-get install tomcatV'. L'alias 'd:V' est
aussi supporté, e.g 'debian:tomcat7' ou 'd:8'
* runs:NAME
Tomcat installé par 'runs tomcat/V name=NAME'. Le suffixe NAME est
le nom de base des fichiers de tomcat. Pour spécifier le cas échéant
la version de Tomcat, il faut utiliser l'option -V ci-dessous.
L'alias NAME sans le préfixe runs: est supporté aussi.
Le profil par défaut est calculé comme suit:
* Si un répertoire de la forme /var/lib/tomcatV existe alors il s'agit
de debian:tomcatV.
* Si le lien /opt/tomcat --> /opt/apache-tomcat-V existe, vérifier
l'existence du script /etc/init.d/tomcatV. Si le script existe, alors
utiliser runs:tomcatV comme profil. Sinon, utiliser runs:tomcat.
* Sinon, aucun profil n'est sélectionné, et il faut spécifier
manuellement les options -d, -U, -G, -V
-d, --catalina-base CATALINA_BASE
Spécifier le répertoire de base des configurations de Tomcat. La valeur
par défaut est celle de CATALINA_HOME. Cette option n'a normalement pas
besoin d'être spécifiée.
-U, --tomcat-user TOMCAT_USER
-G, --tomcat-group TOMCAT_GROUP
Spécifier l'utilisateur et le groupe propriétaires des fichiers de
Tomcat. Ces options n'ont normalement pas besoin d'être spécifiées.
-V, --tomcat-version TOMCAT_VERSION
Spécifier la version de tomcat installée, e.g 8.0.37 pour une version
complète ou simplement 8 si on ne donne que la version majeure.
Cette option peut s'avérer nécessaire avec le profil runs:tomcat bien
que les meilleurs efforts soient faits pour détecter la valeur
effective.
-g, --manager-url MANAGER_URL
Spécifier l'url du manager, e.g http://localhost:8080/manager/text
Par défaut, le fichier server.xml est consulté pour connaitre sur quel
port écoute le serveur.
-u, --user MANAGER_USER
-p, --password MANAGER_PASSWORD
Spécifier le compte et le mot de passe à utiliser pour piloter le
manager Tomcat, notamment pour redémarrer l'application venant d'être
déployée. Ce compte doit avoir le rôle manager-script à partir de Tomcat
6.0.30, et le rôle manager-gui dans les version antérieurs. Par défaut,
le fichier tomcat-users.xml est consulté pour avoir cette information.
-m, --wamap WAMAPS
Ajouter un ou plusieurs mappings de la forme src:dest. Avec ce mapping,
la webapp src est déployée avec le nom dest. Plusieurs mappings peuvent
être spécifiés en les séparant par des virgules. Si src est mentionné
plusieurs fois, e.g src:dest1,src:dest2 alors la webapp src est déployée
plusieurs fois avec des noms distincts.
--exclude EXCLUDES
--replace-excludes EXCLUDES
Spécifier un ensemble de fichier à exclure de la source lors du
déploiement. La variante --replace-excludes permet de construire la
liste des fichiers à exclure depuis zéro. La liste par défaut est:
${DEFAULT_EXCLUDES[*]}
--protect PROTECTS
Spécifier un ensemble de fichier à protéger dans la destination: ils ne
sont jamais écrasés par les fichiers sources. Cela permet de gérer des
applications qui écrivent des fichiers dans leur répertoire.
--rsync-option RSYNC_OPTIONS
--replace-rsync-options RSYNC_OPTIONS
Spécifier les options de rsync à utiliser pour le déploiement. La
variante --replace-rsync-options permet de construire la liste des
options depuis zéro. La liste par défaut est:
${DEFAULT_RSYNC_OPTIONS[*]}
-b, --backup
--no-backup
Avant le déploiement du service numérique, faire (resp. ne pas faire)
une sauvegarde des fichiers actuellement déployés.
-B, --backup-only
Ne pas faire le déploiement. Faire uniquement la sauvegarde.
-n, --no-restart
Après le déploiement de la webapp, ne pas redémarrer l'application.
-r, --restart-only
Ne pas faire le déploiement. Redémarrer uniquement l'application.
--fake
Afficher simplement ce qui serait fait. Ne pas le faire réellement.
--config-template
Créer un modèle de configuration dans le répertoire des webapp
spécifiées. Si aucune webapp n'est spécifiée, créer le fichier dans le
répertoire courant."
}
DEFAULT_EXCLUDES=(/.git/ /.toinst.conf)
DEFAULT_RSYNC_OPTIONS=(-rptL --delete)
VARS=(
TOMCAT_PROFILE
CATALINA_BASE TOMCAT_USER TOMCAT_GROUP TOMCAT_VERSION
MANAGER_URL MANAGER_USER MANAGER_PASSWORD
BACKUP RESTART
)
ARRAYS=(
WAMAPS
EXCLUDES REPLACE_EXCLUDES
PROTECTS
RSYNC_OPTIONS REPLACE_RSYNC_OPTIONS
)
function __reset_vars() {
local var
for var in "${VARS[@]}"; do
eval "$var="
done
for var in "${ARRAYS[@]}"; do
eval "$var=()"
done
}
function __dump_vars() {
local var
for var in "${VARS[@]}"; do
eecho "$(echo_setv2 "$var")"
done
for var in "${ARRAYS[@]}"; do
eecho "$(echo_seta2 "$var")"
done
}
function use_manager_script() {
local v="$TOMCAT_VERSION"
if [ -z "$v" ]; then
return 0
elif [[ "$v" == 6.0.* ]]; then
if [ "${v#6.0.}" -ge 30 ]; then
return 0
else
return 1
fi
elif [ "${v%%.*}" -gt 6 ]; then
return 0
else
return 1
fi
}
function parse_server() {
local -a lines
local serverxml port
serverxml="$CATALINA_BASE/conf/server.xml"
array_from_lines lines "$(xpathtool -g "/Server/Service[@name='Catalina']/Connector/@port" "$serverxml")"
port="${lines[0]}"
if [ -n "$port" ]; then
if use_manager_script; then
MANAGER_URL="http://localhost:$port/manager/text"
else
MANAGER_URL="http://localhost:$port/manager/html"
fi
fi
}
function parse_tomcat_users() {
local -a lines
local usersxml role
usersxml="$CATALINA_BASE/conf/tomcat-users.xml"
if use_manager_script; then
role=manager-script
else
role=manager-gui
fi
array_from_lines lines "$(xpathtool -g "/tomcat-users/user[contains(@roles,'$role')]/@username" "$usersxml")"
MANAGER_USER="${lines[0]}"
if [ -n "$MANAGER_USER" ]; then
array_from_lines lines "$(xpathtool -g "/tomcat-users/user[@username='$MANAGER_USER']/@password" "$usersxml")"
MANAGER_PASSWORD="${lines[0]}"
fi
}
function build_rsync_options() {
local -a excludes protects; local exclude protect
if [ ${#REPLACE_EXCLUDES[*]} -gt 0 ]; then
array_copy excludes REPLACE_EXCLUDES
else
array_copy excludes DEFAULT_EXCLUDES
fi
array_extend excludes EXCLUDES
array_copy protects PROTECTS
if [ ${#REPLACE_RSYNC_OPTIONS[*]} -gt 0 ]; then
array_copy rsync_options REPLACE_RSYNC_OPTIONS
else
array_copy rsync_options DEFAULT_RSYNC_OPTIONS
fi
array_extend rsync_options RSYNC_OPTIONS
local toinstconf="$1/.toinst.conf"
if [ -f "$toinstconf" ]; then
eval "$(
EXCLUDES=()
PROTECTS=()
RSYNC_OPTIONS=()
source "$toinstconf"
array_extend excludes EXCLUDES
array_extend protects PROTECTS
array_extend rsync_options RSYNC_OPTIONS
echo_seta2 excludes
echo_seta2 protects
echo_seta2 rsync_options
)"
fi
for exclude in "${excludes[@]}"; do
array_add rsync_options --exclude "$exclude"
done
for protect in "${PROTECTS[@]}"; do
array_add rsync_options -f "P $protect"
done
}
args=(%
--help '$exit_with display_help'
--config-template action=config-template
--private-parse-server '$action=parse; parse_server=1'
--private-parse-tomcat-users '$action=parse; parse_tomcat_users=1'
--is-tmpdir '$istmpdir=1; tmpdir=.'
-c:,--config: config=
-C:,--config-profile: tomcat_profile=
-d:,--catalina-base:,--catalina-home: catalina_base=
-U:,--tomcat-user: tomcat_user=
-G:,--tomcat-group: tomcat_group=
-V:,--tomcat-version: tomcat_version=
-g:,--manager-url: manager_url=
-u:,--user: manager_user=
-p:,--password: manager_password=
-m:,--wamap: wamaps
--exclude: excludes
--replace-excludes: replace_excludes
--protect: protects
--rsync-option: rsync_options
--replace-rsync-options: replace_rsync_options
-b,--backup backup=1
--no-backup backup=0
-B,--backup-only action=backup
--restart restart=1
-n,--no-restart restart=0
-r,--restart-only action=restart
--fake fake=1
)
parse_args "$@"; set -- "${args[@]}"
[ -n "$action" ] || action=deploy
if [ "$action" == parse ]; then
CATALINA_BASE="$1"
TOMCAT_VERSION="$2"
if [ -n "$parse_server" ]; then
parse_server
echo_setv2 MANAGER_URL
fi
if [ -n "$parse_tomcat_users" ]; then
parse_tomcat_users
echo_setv2 MANAGER_USER
echo_setv2 MANAGER_PASSWORD
fi
exit 0
fi
# Charger la configuration
__reset_vars
if [ -n "$config" ]; then
eval "$(
__reset_vars
CATALINA_HOME=
source "$config" 2>/dev/null || exit 1
[ -n "$CATALINA_BASE" ] || CATALINA_BASE="$CATALINA_HOME"
__dump_vars
)"
fi
# Traiter la ligne de commande
for var in "${VARS[@]}"; do
lvar="${var,,}"
if [ -n "${!lvar}" ]; then
setv "$var" "${!lvar}"
fi
done
[ -n "$RESTART" ] || RESTART=1 # valeur par défaut
normyesvals BACKUP RESTART
for var in "${ARRAYS[@]}"; do
lvar="${var,,}"
if ! array_isempty "$lvar"; then
array_copy "$var" "$lvar"
fi
done
array_fix_paths WAMAPS ,
# Calculer le profil de connexion
if [ -z "$TOMCAT_PROFILE" ]; then
for v in 8 7; do
if [ -d /var/lib/tomcat$v ]; then
TOMCAT_PROFILE=debian:tomcat$v
break
fi
done
fi
if [ -z "$TOMCAT_PROFILE" ]; then
v=
if [ -L /opt/tomcat ]; then
setx v=readlink /opt/tomcat
setx v=basename -- "$v"
else
array_lsdirs ts /opt "apache-tomcat-*"
if [ ${#ts[*]} -gt 0 ]; then
[ -n "$CATALINA_BASE" ] || CATALINA_BASE="${ts[0]}"
v="$CATALINA_BASE"
[ -L "$v" ] && setx v=readlink "$v"
setx v=basename -- "$v"
fi
fi
if [ -n "$v" ] && [[ "$v" == apache-tomcat-* ]]; then
v=${v#apache-tomcat-}
mv=${v%%.*}
if [ -f /etc/init.d/tomcat$mv ]; then
TOMCAT_PROFILE=runs:tomcat$mv
else
TOMCAT_PROFILE=runs:tomcat
fi
[ -z "$TOMCAT_VERSION" ] && TOMCAT_VERSION="$v"
fi
fi
if [ -n "$TOMCAT_PROFILE" ]; then
case "$TOMCAT_PROFILE" in
debian:*|runs:*) ;;
d:*) TOMCAT_PROFILE="debian:tomcat${TOMCAT_PROFILE#d:}";;
*) TOMCAT_PROFILE="runs:$TOMCAT_PROFILE";;
esac
fi
# Calculer les valeurs dérivées du profil de connexion
case "$TOMCAT_PROFILE" in
debian:*)
t="${TOMCAT_PROFILE#debian:}"
v="${t#tomcat}"
[ -z "$CATALINA_BASE" ] && CATALINA_BASE="/var/lib/$t"
eval "$(
setv "${t^^}_USER"
setv "${t^^}_GROUP"
source "/etc/default/$t" 2>/dev/null
eval "echo tomcat_user=\"\$${t^^}_USER\""
eval "echo tomcat_group=\"\$${t^^}_GROUP\""
)"
[ -z "$TOMCAT_USER" ] && TOMCAT_USER="$tomcat_user"
[ -z "$TOMCAT_GROUP" ] && TOMCAT_GROUP="$tomcat_group"
[ -z "$TOMCAT_VERSION" ] && TOMCAT_VERSION="$v"
;;
runs:*)
v="${TOMCAT_PROFILE#runs:tomcat}"
if [ -z "$CATALINA_BASE" -a "$v" != "$TOMCAT_PROFILE" ]; then
array_lsdirs ts /opt "apache-tomcat-$v*"
CATALINA_BASE="${ts[0]}"
fi
if [ -z "$CATALINA_BASE" ]; then
if [ -L /opt/tomcat ]; then
setx CATALINA_BASE=readlink /opt/tomcat
else
array_lsdirs ts /opt "apache-tomcat-*"
CATALINA_BASE="${ts[0]}"
fi
fi
name="${TOMCAT_PROFILE#runs:}"
eval "$(
TOMCAT_USER=
source "/etc/default/$name" 2>/dev/null
echo tomcat_user="$TOMCAT_USER"
)"
[ -z "$TOMCAT_USER" ] && TOMCAT_USER="$tomcat_user"
if [ -z "$TOMCAT_VERSION" ]; then
v="$CATALINA_BASE"
[ -L "$v" ] && setx v=readlink "$v"
setx v=basename -- "$v"
if [[ "$v" == apache-tomcat-* ]]; then
TOMCAT_VERSION="${v#apache-tomcat-}"
fi
fi
;;
esac
# Calculer les valeurs dérivées des fichiers de $CATALINA_BASE
if [ -n "$CATALINA_BASE" -a -n "$TOMCAT_VERSION" ]; then
if [ -z "$MANAGER_URL" -o -z "$MANAGER_USER" ]; then
# lire les fichiers de configuratione et déterminer MANAGER_URL,
# MANAGER_USER et MANAGER_PASSWORD
if is_root; then
[ -z "$MANAGER_URL" ] && parse_server
[ -z "$MANAGER_USER" ] && parse_tomcat_users
else
args=()
[ -z "$MANAGER_URL" ] && array_add args --private-parse-server
[ -z "$MANAGER_USER" ] && array_add args --private-parse-tomcat-users
array_add args "$CATALINA_BASE" "$TOMCAT_VERSION"
eval "$(run_as root --noexec "${args[@]}")"
fi
fi
fi
# A partir de la liste des webapps et de WAMAPS, construire une liste de couples
# waname:src pour la sauvegarde et/ou le déploiement
[ -n "$fake" -o "$action" == config-template ] && will_deploy= || will_deploy=1
if [ $# -eq 0 -a -n "$will_deploy" ]; then
[ -d WEB-INF ] && src=. || src=
read_value "Veuillez entrer la webapp à déployer" src "$src" O
set -- "$src"
elif [ $# -eq 0 -a "$action" == config-template ]; then
[ -d WEB-INF ] && set .
fi
srcs=()
[ -n "$istmpdir" ] || ac_set_tmpdir tmpdir
for src in "$@"; do
if [ -f "$src" ] && is_archive "$src"; then
setx waname=get_archive_appname "$src"
wadir="$tmpdir/$waname"
mkdir "$wadir"
if extract_archive "$src" "$wadir"; then
array_add srcs "$wadir"
else
eerror "$src: erreur lors de l'extraction de l'archive"
fi
elif [ -d "$src" ]; then
array_add srcs "$(abspath "$src")"
elif [ -e "$src" ]; then
eerror "$src: fichier invalide"
else
eerror "$src: fichier ou répertoire introuvable"
fi
done
[ ${#srcs[*]} -gt 0 -o -z "$will_deploy" ] || die
deploymaps=()
for src in "${srcs[@]}"; do
setx waname=basename -- "$src"
found=
for wamap in "${WAMAPS[@]}"; do
splitpair "$wamap" from to
if [ "$waname" == "$from" ]; then
found=1
array_add deploymaps "$to:$src"
fi
done
if [ -z "$found" ]; then
array_add deploymaps "$waname:$src"
fi
done
################################################################################
# Maintenant, nous pouvons faire les actions
if [ "$action" == config-template ]; then
if [ ${#deploymaps[*]} -gt 0 ]; then
toinstconfname=.toinst.conf
else
toinstconfname=toinst.conf
deploymaps=(:.)
fi
for deploymap in "${deploymaps[@]}"; do
splitpair "$deploymap" waname src
toinstconf="$src/$toinstconfname"
if [ -f "$toinstconf" ]; then
estepi "$(ppath "$toinstconf"): configuration déjà existante"
else
estep "$(ppath "$toinstconf")"
echo >"$toinstconf" "# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
# Fichiers à exclure de la source lors du déploiement
#EXCLUDES=()
# Fichiers à protéger dans la destination lors du déploiement
#PROTECTS=()
# Options supplémentaires de rsync à utiliser pour le déploiement
#RSYNC_OPTIONS=()"
fi
done
exit 0
fi
## Sauvegarde
if [ -n "$BACKUP" -o "$action" == backup ]; then
[ -n "$CATALINA_BASE" -o -z "$will_deploy" ] || die "Vous devez spécifier l'option --catalina-base"
home_bckdir="$HOME/tomcat-backups"
if [ -n "$istmpdir" ]; then
# déploiement distant: sauvegarder dans le répertoire utilisateur
default_bckdir="$home_bckdir"
else
# déploiement local: ça dépend de la webapp
default_bckdir=
fi
setx cwd=pwd
etitle "Sauvegarde des webapps"
for deploymap in "${deploymaps[@]}"; do
splitpair "$deploymap" waname src
wadir="$CATALINA_BASE/webapps/$waname"
if [ ! -d "$wadir" ]; then
einfo "$waname: la webapp n'a pas encore été déployée. elle ne sera pas sauvegardée"
continue
fi
bckdir="$default_bckdir"
if [ -z "$bckdir" ]; then
if withinpath "$tmpdir" "$src"; then
bckdir="$home_bckdir"
elif withinpath "$src" "$cwd"; then
setx bckdir=dirname "$src"
else
bckdir=.
fi
fi
mkdir -p "$bckdir"
setx base=date +%y%m%d
i=0
bckname="$base.$profile$i-$waname"
while [ -d "$bckdir/$bckname" ]; do
let i=$i+1
bckname="$base.$profile$i-$waname"
done
if [ -n "$fake" ]; then
evalx qvals rsync -a "$wadir/" "$bckdir/$bckname" // eecho
else
estep "$wadir --> $(ppath "$bckdir/$bckname")"
if ! rsync -a "$wadir/" "$bckdir/$bckname"; then
ewarn "Une erreur s'est produite pendant la sauvegarde"
ask_yesno "Voulez-vous continuer le déploiement?" N || die
fi
fi
done
eend
fi
## Déploiement
if [ "$action" == deploy ]; then
[ -n "$CATALINA_BASE" -o -z "$will_deploy" ] || die "Vous devez spécifier l'option --catalina-base"
if [ -n "$fake" ]; then
# Afficher ce qu'il faut faire
etitle "Configuration globale" __dump_vars
etitle "Déploiements des webapps"
for deploymap in "${deploymaps[@]}"; do
splitpair "$deploymap" waname src
setx srcname=basename -- "$src"
dest="${CATALINA_BASE:-CATALINA_BASE}/webapps/$waname"
etitle "$waname"
if [ -f "$src/.toinst.conf" ]; then
etitle "Configuration de la webapp"
(
EXCLUDES=()
PROTECTS=()
RSYNC_OPTIONS=()
source "$src/.toinst.conf"
for var in EXCLUDES PROTECTS RSYNC_OPTIONS; do
eecho "$(echo_seta2 "$var")"
done
)
eend
fi
build_rsync_options "$src"
evalx qvals rsync "${rsync_options[@]}" "$src/" "$dest" // eecho
evalx qvals chmod -R u=rwX,g=rX,o=rX "$dest" // eecho
if [ -n "$TOMCAT_USER" ]; then
evalx qvals chown -R "$TOMCAT_USER:$TOMCAT_GROUP" "$dest" // eecho
fi
eend
done
eend
elif ! is_root; then
# le déploiement doit être fait en root
args=(
-C "$TOMCAT_PROFILE"
-d "$CATALINA_BASE"
-U "$TOMCAT_USER"
-G "$TOMCAT_GROUP"
-V "$TOMCAT_VERSION"
-g "$MANAGER_URL"
-u "$MANAGER_USER"
-p "$MANAGER_PASSWORD"
-m "$(array_join WAMAPS ,)"
--no-backup
--no-restart
)
run_as root --noexec "${args[@]}" "${srcs[@]}" || die
else
# faire le déploiement
etitle "Déploiements des webapps"
for deploymap in "${deploymaps[@]}"; do
splitpair "$deploymap" waname src
setx srcname=basename -- "$src"
dest="$CATALINA_BASE/webapps/$waname"
etitle "$srcname"
estepi "Déploiement vers $dest"
estep "Copie des fichiers"
build_rsync_options "$src"
if ! rsync "${rsync_options[@]}" "$src/" "$dest"; then
eerror "Une erreur s'est produite pendant la copie des fichiers"
else
error=
estep "Correction des permissions et du propriétaire"
chmod -R u=rwX,g=rX,o=rX "$dest" || error=1
if [ -n "$TOMCAT_USER" ]; then
chown -R "$TOMCAT_USER:$TOMCAT_GROUP" "$dest" || error=1
fi
if [ -n "$error" ]; then
eeror "Une erreur s'est produite pendant la mise à jour"
fi
fi
eend
done
eend
fi
fi
## Redémarrage
if [ -n "$RESTART" -o "$action" == restart ]; then
etitle "Redémarrage des webapps"
if [ -z "$MANAGER_URL" -o -z "$MANAGER_USER" ]; then
ewarn "Impossible de recharger la webapp parce que l'url du manager et/ou le compte admin n'ont pas pu être déterminés."
[ -z "$fake" ] && enote "\
Par défaut, les webapps ne sont rechargées automatiquement que si le fichier web.xml est modifié.
Utilisez les options -g, -u, -p pour spécifier les informations manquantes nécessaires au pilotage du manager."
elif [ -n "$fake" ]; then
estepi "Utilisation du manager à l'adresse $MANAGER_URL"
for deploymap in "${deploymaps[@]}"; do
splitpair "$deploymap" waname src
etitle "$waname"
evalx qvals curl -fsS -u "$MANAGER_USER:$MANAGER_PASSWORD" "$MANAGER_URL/reload?path=/$waname" // eecho
eend
done
else
estepi "Utilisation du manager à l'adresse $MANAGER_URL"
for deploymap in "${deploymaps[@]}"; do
splitpair "$deploymap" waname src
ebegin "$waname"
curl -fsS -u "$MANAGER_USER:$MANAGER_PASSWORD" "$MANAGER_URL/reload?path=/$waname" >/dev/null
eend $?
done
fi
eend
fi