Intégration de la branche tomcat-deploy

lib/completion.d/nutools

@@ -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

lib/ulib/base.args

@@ -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
 

lib/ulib/base.core

@@ -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
+# Si d'autres arguments que le nom de tableau sont spécifiés, cette fonction se
-# echo_seta()
+# comporte comme echo_seta()
     local __s_var="$1"; shift
     if [[ "$__s_var" == *=* ]]; then
         set -- "${__s_var#*=}" "$@"

lib/ulib/deploy

@@ -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
+    local alv sov sdv slv sof sdf slf
-    eval "set -- $(getopt -ov: -lallow-vars: -- "$@")"
+    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)
+    shell) deploy_dump_values "$t" vs;;
-        [ -n "$5" ] && echo "$t=()"
-        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
 }
 

rtoinst

@@ -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

ruinst

@@ -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
+        Cette option permet de spécifier le nom de la configuration locale de
-        pour effectuer la requête. Par défaut, utiliser le nom 'ruinst'"
+        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 [ $# -eq 0 ] || [[ "$1" == -* ]] || [[ "$1" == *=* ]]; then
-if [ -z "$src" ] || [[ "$src" == -* ]]; 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

rwoinst

@@ -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
 }
 
-################################################################################
+action=deploy
-# Configuration de l'accès par clé aux hôtes
+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
+: "${SSH:=ssh}"
-    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
 
 ## 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"

toinst

@@ -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