#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8

function display_help() {
    uecho "$scriptname: Déploiement distant avec woinst

USAGE
    $scriptname [-H host] [-T tmproot] <file|archive|dir>... [-- options de woinst]

OPTIONS
    -C  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
    -T 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
        Spécifier le programme à utiliser pour la connection par ssh.
    -H host
        Spécifier un hôte distant sur lequel faire le déploiement. Plusieurs
        options -H peuvent être spécifiées, ou alors on peut séparer plusieurs
        hôtes par ':', e.g. -H host1:host2
        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"
}

source "$(dirname "$0")/ulib/ulib" &&
urequire DEFAULTS woinst ||
exit 1

set_defaults pubkeys

action=deploy
confuser=
tmproot=
hosts=()
SSH=
parse_opts "${PRETTYOPTS[@]}" \
    --help '$exit_with display_help' \
    -C action=configure \
    --configure: '$set@ confuser;action=configure' \
    -T:,--tmproot: tmproot= \
    -S: SSH= \
    -h:,-H:,--host: hosts \
    @ args -- "$@" && set -- "${args[@]}" || die "$args"

function _dot_is_localhost() {
    [ "$1" == "." ] && echo "localhost" || echo "$1"
}
function fix_hosts() {
    # Si hosts contient des éléments multiple, comme a:b, séparés ces
    # éléments. i.e (a b:c) --> (a b c)
    # remplacer aussi les '.' par 'localhost'
    array_fix_paths hosts
    array_map hosts _dot_is_localhost
}

################################################################################
# Configuration de l'accès par clé aux hôtes

if [ "$action" == "configure" ]; then
    args=(${confuser:+--configure "$confuser"})
    for host in "${hosts[@]}"; do
        args=("${args[@]}" -H "$host")
    done
    exec "$scriptdir/ruinst" -C "${args[@]}"
fi

################################################################################
# Déploiement

SSH="${SSH:-ssh}"

## Bundle à déployer
if [ -z "$1" ] || [[ "$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"
fi

## Hôtes sur lesquels faire le déploiement
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 -s "Création du répertoire de travail"
ac_set_tmpdir workdir
bundles=()
while [ -n "$1" ]; do
    if [ "$1" == "--" ]; then
        # début des options de woinst
        shift
        break
    elif [[ "$1" == -* ]] || [[ "$1" == *=* ]]; then
        # début des options de woinst
        break        
    fi

    src="$1"; shift
    if [ -f "$src" ] && is_archive "$src"; then
        estep "$(ppath "$src")"
        cp_R "$src" "$workdir" || die
    elif [ -d "$src" ]; then
        src="$(abspath "$src")"
        if endswith "$src" .framework; then
            is_wofwkdir "$src" || die "Framework invalide: $(ppath "$src")"
        elif endswith "$src" .woa; then
            is_woappdir "$src" || die "Application invalide: $(ppath "$src")"
        else
            die "N'est pas un bundle valide: $(ppath "$src")"
        fi
        estep "$(ppath "$src")"
        cp_R "$src" "$workdir" || die
    else
        die "Fichier ou répertoire introuvable: $src"
    fi

    src="$(abspath "$src")"
    array_add bundles "$(basename "$src")"
done

estep "Copie de l'environnement de déploiement"
ulib_sync "$workdir"
echo '#!/bin/sh
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
if . `dirname "$0"`/ulib/ulibsh; then
    urequire DEFAULTS woinst
else
    exit 1
fi
OENC="$UTF8"
woinst "$@"' >"$workdir/woinst"
chmod +x "$workdir/woinst"

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" -- ./woinst --is-tmpdir "${bundles[@]}" || die

## Déploiement
for host in "${hosts[@]}"; do
    if [ "$host" == "localhost" ]; then
        etitle "Déploiement sur l'hôte local" \
            "$archive" ${tmproot:+--tmproot "$tmproot"} -- "$@"
    else
        if [[ "$host" == *@* ]]; then
            user="${host%%@*}"
            host="${host#*@}"
        else
            user=root
        fi

        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" "\
__estack=$(quoted_arg "$__estack")
__tlevel=$(quoted_arg "$__tlevel")
export __estack __tlevel
${UTOOLS_LANG:+UTOOLS_LANG='$UTOOLS_LANG'; export UTOOLS_LANG
}$(quoted_args "./$archivename" ${tmproot:+--tmproot "$tmproot"} -- MYHOST="$host" "$@")"
        eend
    fi
done