diff --git a/lib/completion.d/nutools b/lib/completion.d/nutools
index 5cdc084..f52a598 100644
--- a/lib/completion.d/nutools
+++ b/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
diff --git a/rtoinst b/rtoinst
new file mode 100755
index 0000000..fc7c6ac
--- /dev/null
+++ b/rtoinst
@@ -0,0 +1,230 @@
+#!/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
+        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 'rtoinst'"
+}
+
+__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
+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"
+
+: "${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
+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 DEST webapp rtoinst_deploy "" shell "$webapp")"; then
+            check_interaction -c && einfo "Cette webapp sera déployée vers les hôtes suivants:
+$(array_to_lines host "" "    ")"
+            ask_any "Voulez-vous continuer?" Oq || die
+            array_copy hosts host
+        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 [ -n "$1" ]; do
+    if [ "$1" == "--" ]; then
+        # début des options de toinst
+        shift
+        break
+    elif [[ "$1" == -* ]]; then
+        # début des options de toinst
+        break
+    fi
+
+    src="$1"; shift
+    if [ -f "$src" ] && is_archive "$src"; then
+        estep "$(ppath "$src")"
+        cp_R "$src" "$workdir" || die
+    elif [ -d "$src" ]; then
+        estep "$(ppath "$src")"
+        cp_R "$src" "$workdir" || die
+    elif [ -e "$src" ]; then
+        die "$src: fichier invalide"
+    else
+        die "$src: fichier ou répertoire introuvable"
+    fi
+
+    src="$(abspath "$src")"
+    array_add webapps "$(basename "$src")"
+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 "${webapps[@]}" || 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"} -- "$@"
+        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"} -- MYHOST="$host" "$@")"
+        eend
+    fi
+done
diff --git a/toinst b/toinst
new file mode 100755
index 0000000..dfb53a8
--- /dev/null
+++ b/toinst
@@ -0,0 +1,517 @@
+#!/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.
+    --protect PRMAPS
+    --exclude EXCLUDES
+    --replace-excludes EXCLUDES
+    --rsync-option RSYNC_OPTIONS
+    --replace-rsync-options RSYNC_OPTIONS
+        XXX Options non documentées à implémenter
+    -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."
+}
+
+VARS=(
+    TOMCAT_PROFILE
+    CATALINA_BASE TOMCAT_USER TOMCAT_GROUP TOMCAT_VERSION
+    MANAGER_URL MANAGER_USER MANAGER_PASSWORD
+    BACKUP RESTART
+)
+ARRAYS=(
+    WAMAPS PRMAPS EXCLUDES 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
+        echo_setv2 "$var"
+    done
+    for var in "${ARRAYS[@]}"; do
+        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
+}
+
+action=deploy
+parse_tomcat_users=
+parse_server=
+config=
+tomcat_profile=
+catalina_base=
+tomcat_user=
+tomcat_group=
+tomcat_version=
+manager_url=
+manager_user=
+manager_password=
+wamaps=()
+prmaps=()
+excludes=()
+rsync_options=(-rptL --delete --exclude /.git/)
+replace_rsync_options=()
+backup=
+restart=
+fake=
+args=(
+    --help '$exit_with display_help'
+    --private-parse-server '$action=parse; parse_server=1'
+    --private-parse-tomcat-users '$action=parse; parse_tomcat_users=1'
+    -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
+    -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[@]}"
+
+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
+
+if [ $# -eq 0 ]; then
+    [ -d WEB-INF ] && src=. || src=
+    read_value "Veuillez entrer la webapp à déployer" src "$src" O
+    set -- "$src"
+fi
+
+srcs=()
+for src in "$@"; do
+    if [ -d "$src" ]; then
+        array_add srcs "$(abspath "$src")"
+    elif [ -f "$src" ]; then
+        setx waname=get_archive_appname "$src"
+        ac_set_tmpdir tmpdir
+        tmpdir="$tmpdir/$waname"
+        mkdir "$tmpdir"
+        if extract_archive "$src" "$tmpdir"; then
+            array_add srcs "$tmpdir"
+        else
+            eerror "$src: erreur lors de l'extraction de l'archive"
+        fi
+    else
+        eerror "$src: webapp introuvable"
+    fi
+done
+[ ${#srcs[*]} -gt 0 -o -n "$fake" ] || 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
+
+## Sauvegarde
+if [ -n "$BACKUP" -o "$action" == backup ]; then
+    if [ -n "$fake" ]; then
+        :
+    else
+        :
+    fi
+fi
+
+## Déploiement
+if [ "$action" == deploy ]; then
+    [ -n "$CATALINA_BASE" -o -n "$fake" ] || die "Vous devez spécifier l'option --catalina-base"
+
+    if [ -n "$fake" ]; then
+        # Afficher ce qu'il faut faire
+        etitle "Variables définies" __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"
+            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"
+            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