nutools/ulib/uinst

1392 lines
51 KiB
Plaintext
Raw Normal View History

2013-08-27 15:14:44 +04:00
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
## Fonctions de support pour uinst: déploiement local d'un fichier ou d'un répertoire.
##@cooked nocomments
##@require ulib
##@require base
##@require sysinfos
##@require compat
##@require udir
##@require prefixes
##@require nutools/pyulib
##@require uinc
uprovide uinst
urequire ulib base sysinfos compat udir prefixes nutools/pyulib uinc
function uinst() {
# lancer uinst en déclarant les variables locales, de façon à ne pas polluer
# l'environnement de l'appelant.
local UINST_CONFIGURE_FORCE
local UINST_COPY_METHOD
local -a UINST_DEFAULTS
local -a UINST_CONFIG_VARS
local -a UINST_CONFIG_VARCMDS
local -a UINST_PROTECTED_VARS
local UINST_ORIGSRC
local UINST_SRCDIR
local UINST_ISTMPDIR
local UINST_TMPDIR
local UINST_AUTOPREFIX
local -a UDIR_VARS
local -a UDIR_ARRAYS
local UINST_ACTION
local UINST_AUTOSRCDIR
local UINST_PREPARE_DIR UINST_PREPARE_CONF UINST_PREPARE_ULIB
local udir_desc udir_note udir_types
local uinc
local -a uinc_options
local -a uinc_args
local -a preconfig_scripts
local -a configure_variables
local -a configure_dest_for
local -a config_scripts
local install_profiles
local profiledir
local bashrcdir
local defaultdir
local copy_files
local destdir
local srcdir
local -a files
local owner
local -a modes
local -a root_scripts
local uinst2s
uinst_nolocal "$@"
}
function uinst_nolocal() {
# Interface en mode ligne de commande pour uinst. Appeler cette fonction
# avec les paramètres de la ligne de commande, e.g.:
# uinst_nolocal "$@"
function __uinst_display_help() {
uecho "$scriptname: Déployer en local un fichier, une archive, ou un répertoire
USAGE
$scriptname [options] <file|archive|dir>
OPTIONS
var=value
Spécifier la valeur d'une variable ou d'un préfixe, plutôt que de
laisser uprefix l'autodétecter. Utiliser 'uprefix -l' pour avoir une
liste de préfixes valides. Utiliser 'udir --help-vars' pour avoir une
liste de variables valides pour $scriptname.
-d /path/to/destdir
Spécifier le répertoire destination. Equivalent à l'option
destdir=\"/path/to/destdir\"
-a (par défaut) Si la source n'est pas spécifiée, déterminer le répertoire
à déployer automatiquement.
--no-auto
Ne pas déterminer automatiquement le répertoire à déployer.
--prefix
(par défaut) Corriger les chemins srcdir et destdir qui commencent par
des préfixes valides. Utiliser 'uprefix -l' pour avoir une liste de
préfixes valides.
--no-prefix
Ne jamais corriger un chemin.
--include-vcs
Inclure les fichiers de VCS dans les fichiers copiés. Par défaut, les
fichiers de VCS sont exclus.
-C Configurer un répertoire pour le déploiement avec uinst
Ajouter l'option --force pour forcer la reconfiguration"
}
# Définir ULIBDIR, PYULIBDIR et UINST si ce n'est pas le cas.
# Ces variables sont utilisées par les scripts
ULIBDIR="${ULIBDIR:-$scriptdir/ulib}"
PYULIBDIR="${PYULIBDIR:-$scriptdir/pyulib}"
UINST="${UINST:-$script}"
eval "$(utools_local)"
__uinst_init
UINST_ACTION=
UINST_AUTOSRCDIR=1
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with __uinst_display_help' \
--is-tmpdir UINST_ISTMPDIR \
-O: '$__uinst_addvar owner "$value_"' \
-m: '$__uinst_addvar modes "$value_"' \
-d: '$__uinst_addvar destdir $value_' \
-a,--auto UINST_AUTOSRCDIR=1 \
--no-auto UINST_AUTOSRCDIR= \
--prefix UINST_AUTOPREFIX=1 \
--no-prefix UINST_AUTOPREFIX= \
--include-vcs UINST_COPY_METHOD=cpdir \
-C UINST_ACTION=configure \
-f,--force UINST_CONFIGURE_FORCE=1 \
--prepare-1s: UINST_PREPARE_DIR \
--prepare-2s UINST_ACTION=prepare-2s \
--prepare-conf: UINST_PREPARE_CONF \
--prepare-with-ulib UINST_PREPARE_ULIB \
@ args -- "$@" &&
set -- "${args[@]}" || {
eerror "$args"
return 1
}
# configuration de la phase, dans le mode prepare
[ -n "$UINST_PREPARE_DIR" -a -z "$UINST_ACTION" ] && UINST_ACTION=prepare-1s
# action par défaut
[ -n "$UINST_ACTION" ] || UINST_ACTION=uinst
if [ "$UINST_ACTION" == "configure" ]; then
__uinst_configure "${args[@]}" || return 1
elif [ "$UINST_ACTION" == prepare-1s ]; then
UINST_PREPARE_DIR="$(abspath "$UINST_PREPARE_DIR")"
mkdir -p "$UINST_PREPARE_DIR" || return 1
if [ -z "$UINST_PREPARE_CONF" ]; then
UINST_PREPARE_CONF="$UINST_PREPARE_DIR/uinst_prepare.conf"
fi
UINST_PREPARE_CONF="$(abspath "$UINST_PREPARE_CONF")"
__uinst_do "${args[@]}" || return 1
elif [ "$UINST_ACTION" == prepare-2s ]; then
UINST_ISTMPDIR=1
__uinst_do "${args[@]}" || return 1
else
__uinst_do "${args[@]}" || return 1
fi
return 0
}
function __uinst_init() {
UINST_CONFIGURE_FORCE=
UINST_COPY_METHOD="${UINST_COPY_METHOD:-cpdirnovcs}"
UINST_DEFAULTS=(
uinc='release'
uinc_options='()'
uinc_args='()'
preconfig_scripts='()'
configure_variables='(dest)'
configure_dest_for='()'
config_scripts='()'
install_profiles='false'
profiledir='lib/profile.d'
bashrcdir='lib/bashrc.d'
defaultdir='lib/default'
copy_files='true'
destdir='/usr/local'
srcdir='.'
files='()'
owner='root:'
modes='(u=rwX,g=rX,o=rX)'
root_scripts='()'
)
UINST_CONFIG_VARS=()
UINST_CONFIG_VARCMDS=()
UINST_PROTECTED_VARS=(UINST_PROTECTED_VARS UINST_CONFIG_VARS UINST_CONFIG_VARCMDS)
__uinst_protectvars configure_variables \
UINST_ORIGSRC UINST_SRCDIR \
UINST_ISTMPDIR UINST_TMPDIR \
UINST_AUTOPREFIX \
UDIR_VARS UDIR_ARRAYS
UINST_ORIGSRC=
UINST_SRCDIR=
UINST_ISTMPDIR=
UINST_TMPDIR=
UINST_AUTOPREFIX=1
UDIR_VARS=()
UDIR_ARRAYS=()
}
function __uinst_configure() {
# Configurer le répertoire $1 pour installation avec uinst
srcdir="${1:-.}"; shift
[ -d "$srcdir" ] || {
eerror "$srcdir: répertoire inexistant"
return 1
}
srcdir="$(abspath "$srcdir")"
urequire udir
function __uinst_update_types() {
udir_types=("${udir_types[@]}" uinst)
set_array_cmd udir_types
}
function __uinst_should_update() {
local udir_type
for udir_type in "${udir_types[@]}"; do
if [ "$udir_type" == "uinst" ]; then
echo "false"; return
elif [[ "$udir_type" == uinst:* ]]; then
echo "false"; return
fi
done
__uinst_update_types uinst
}
if [ -z "$UINST_CONFIGURE_FORCE" ]; then
if udir_check "$srcdir"; then
# Nous avons déjà un fichier .udir
# Si le répertoire n'est pas du type uinst, le migrer en rajoutant
# les options par défaut
if eval "$(udir_eval "$srcdir" __uinst_should_update)"; then
udir_update "$srcdir" "$(set_array_cmd udir_types)" "${UINST_DEFAULTS[@]}"
enote "Le répertoire $(ppath "$srcdir") a déjà été configuré pour uinst.
Utilisez 'udir -e $(ppath "$srcdir")' pour modifier les paramètres qui ont été rajoutés."
fi
return 0
elif [ -f "$srcdir/.uinst.conf" ]; then
# Nous avons un fichier .uinst.conf
# proposer de migrer le répertoire vers .udir
check_interaction -c && enote "Ce répertoire contient un fichier .uinst.conf"
if ask_yesno "Voulez-vous le migrer vers le format .udir?" N; then
estep "Configuration de $(ppath "$srcdir") pour uinst"
__uinst_migrate_legacy "$srcdir"
__uinst_varcmds=()
for __uinst_v in "${UDIR_VARS[@]}"; do
__uinst_varcmds=("${__uinst_varcmds[@]}" "$(set_var_cmd "$__uinst_v" "${!__uinst_v}")")
done
for __uinst_a in "${UDIR_ARRAYS[@]}"; do
__uinst_varcmds=("${__uinst_varcmds[@]}" "$(set_array_cmd "$__uinst_a")")
done
udir_update "$srcdir" 'udir_types=(uinst)' "${__uinst_varcmds[@]}"
enote "Vous pouvez maintenant supprimer le fichier: rm -f '$(ppath "$srcdir/.uinst.conf")'"
else
estep "Configuration de $(ppath "$srcdir") pour uinst:legacy"
udir_update "$srcdir" 'udir_types=(uinst:legacy)'
fi
return 0
fi
fi
# Sans fichier .udir, faire la configuration par défaut
# Poser des questions pour déterminer le type de configuration à faire
local udir_desc udir_note udir_types
local profiles conf rootconf ulibsync copy_files
eval "$(udir_eval "$srcdir" 'set_var_cmd udir_desc "$udir_desc"; set_var_cmd udir_note "$udir_note"')"
etitle "Description du projet"
check_interaction -c && estepn "La description courte de l'objet de ce projet est affichée avec udir -i"
read_value "Entrez une description de ce projet" udir_desc "$udir_desc" N
check_interaction -c && estepn "La note est affichée quand on entre dans le répertoire du projet.
Elle peut être utilisée pour diriger le visiteur vers des informations importantes."
read_value "Entrez une note associée au répertoire de ce projet" udir_note "$udir_note" N
eend
udir_update "$srcdir" "udir_desc=$(quoted_arg "$udir_desc")" "udir_note=$(quoted_arg "$udir_note")"
estepn "La configuration par défaut permet de créer un projet qui utilise les outils et librairies de nutools.
Ce projet pourra ensuite être installé avec uinst"
if ask_yesno "Voulez-vous utiliser la configuration par défaut?" O; then
udir_types='(uinst)'
etitle "Configuration du module"
ask_yesno "Faut-il installer des profils pour bash?" O && profiles=1
ask_yesno "Faut-il créer un script de configuration?" O && conf=1
ask_yesno "Faut-il créer un script de configuration root?" O && rootconf=1
check_interaction -c && estep "Configuration avancée"
ask_yesno "Faut-il faire une copie locale de ulib?" O && ulibsync=1
ask_yesno "Faut-il déployer le projet dans /usr/local?" O && copy_files=1
eend
[ -n "$ulibsync" ] && ulib_sync "$srcdir"
udir_update "$srcdir" "udir_types=$udir_types" "${UINST_DEFAULTS[@]}"
[ -n "$copy_files" ] && copy_files=true || copy_files=false
udir_update "$srcdir" \
${profiles:+install_profiles=true} \
${conf:+config_scripts='(lib/uinst/conf)'} \
copy_files="$copy_files" \
${rootconf:+root_scripts='(lib/uinst/rootconf)'}
local genfile
if [ -n "$profiles" ]; then
genfile="$srcdir/lib/profile.d/$(basename "$srcdir")"
mkdirof "$genfile"
[ -f "$genfile" ] || echo '# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
__uaddpath "@@dest@@" PATH' >"$genfile"
udir_update "$srcdir" "configure_dest_for=($(quoted_arg "${genfile#"$srcdir/"}"))"
fi
if [ -n "$conf" ]; then
genfile="$srcdir/lib/uinst/conf"
mkdirof "$genfile"
[ -f "$genfile" ] || echo '# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$@" || exit 1
source "$ULIBDIR/ulib" && urequire DEFAULTS || exit 1' >"$genfile"
fi
if [ -n "$rootconf" ]; then
genfile="$srcdir/lib/uinst/rootconf"
mkdirof "$genfile"
[ -f "$genfile" ] || echo '# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$@" || exit 1
source "$ULIBDIR/ulib" && urequire DEFAULTS || exit 1' >"$genfile"
fi
else
local -a udir_typess
udir_typess=(uinst uinst:rsync uinst:python)
udir_types=uinst
simple_menu udir_types udir_typess -t "Choix du type d'installation" -m "Veuillez choisir le type d'installation pour ce projet"
if [ "$udir_types" == uinst ]; then
udir_update "$srcdir" "udir_types=($udir_types)" "${UINST_DEFAULTS[@]}"
elif [ "$udir_types" == uinst:rsync ]; then
local rsync_options
estepn "Les options suivantes sont définies pour la synchronisation par rsync:
-av --exclude CVS --exclude .svn --exclude /.git/
Vous pouvez en définir d'autres"
read_value "Entrez des options de rsync" rsync_options "" N
udir_update "$srcdir" "udir_types=($udir_types)" "${UINST_DEFAULTS[@]}" "rsync_options=($rsync_options)"
elif [ "$udir_types" == uinst:python ]; then
udir_update "$srcdir" "udir_types=($udir_types)"
fi
fi
enote "Le répertoire $(ppath "$srcdir") a été configuré avec les valeurs par défaut pour uinst.
Utilisez 'udir -e $(ppath "$srcdir")' pour modifier les paramètres."
}
function __uinst_defaultvars() {
eval "$(array_join UINST_DEFAULTS ';')"
UDIR_VARS=(uinc install_profiles profiledir bashrcdir defaultdir copy_files destdir srcdir owner)
UDIR_ARRAYS=(uinc_options uinc_args preconfig_scripts configure_variables configure_dest_for config_scripts files modes root_scripts)
}
function __uinst_protectvars() {
local __uinst_var
if [ -n "$*" ]; then
# Enregistrer les noms des variables à protéger de la modification dans
# une fonction qui source un fichier externe
for __uinst_var in "$@"; do
array_set UINST_PROTECTED_VARS "$__uinst_var"
done
else
# Afficher des commandes à lancer pour protéger les variables dans la
# fonction. A utiliser ainsi:
# eval "$(__uinst_protectvars)"
for __uinst_var in "${UINST_PROTECTED_VARS[@]}"; do
if [ "$__uinst_var" == UINST_PROTECTED_VARS ]; then
echo "local $__uinst_var"
else
echo "local $__uinst_var=\"\$$__uinst_var\""
fi
done
fi
}
function __uinst_do() {
# Installer le répertoire $1. L'environnement doit d'abord être initialisé
# avec __uinst_init() et éventuellement uinst()
srcdir=
for __uinst_var in "$@"; do
if [[ "$__uinst_var" == *=* ]]; then
__uinst_name="${__uinst_var%%=*}"
__uinst_value="${__uinst_var#*=}"
__uinst_addvar "$__uinst_name" "$__uinst_value"
elif [ -z "$srcdir" ]; then
srcdir="$__uinst_var"
UINST_ORIGSRC="$srcdir"
else
ewarn "$__uinst_var: cet argument a été ignoré"
fi
done
if [ -z "$srcdir" ]; then
if __uinst_check_dir .; then
srcdir="."
UINST_ORIGSRC="$srcdir"
fi
fi
if [ -z "$srcdir" ]; then
__uinst_found=
if [ -n "$UINST_AUTOSRCDIR" ]; then
parentdirs srcdirs ..
for srcdir in "${srcdirs[@]}"; do
if __uinst_check_dir "$srcdir"; then
__uinst_found=1
break
fi
done
fi
[ -n "$__uinst_found" ] || {
eerror "\
Impossible de déterminer automatiquement le répertoire à installer
Essayez avec 'uinst -C'"
return 1
}
ask_yesno "Le répertoire '$(ppath "$srcdir")' a été calculé automatiquement. Voulez-vous le déployer?" X || return 1
UINST_ORIGSRC="$srcdir"
fi
# Tester s'il faut bootstrapper
if [ -f "$srcdir/.nutools-bootstrap" ]; then
local need_python need_gawk
has_python || need_python=1
has_gawk || need_gawk=1
if check_sysinfos -s linux; then
if [ -n "$need_python" -o -n "$need_gawk" ]; then
eimportant "Il FAUT installer Python et $(get_color y)*GNU*$(get_color z)awk pour que nutools fonctionne correctement."
if check_sysinfos -d debian; then
2013-10-03 09:59:42 +04:00
if ask_yesno "Voulez-vous que ce script essaye d'installer automatiquement ces dépendances (requière les droits root)?" O; then
2013-08-27 15:14:44 +04:00
urequire debian
pkg_install ${need_python:+python} ${need_gawk:+gawk} || {
eerror "Une erreur s'est produite pendant l'installation. Veuillez faire l'installation manuellement"
return 1
}
need_python=
need_gawk=
fi
fi
fi
fi
if [ -n "$need_python" ]; then
eerror "Python est requis. Veuillez faire l'installation avant de relancer ce script."
return 1
fi
if [ -n "$need_gawk" ]; then
ewarn "$(get_color y)*GNU*$(get_color z)awk est requis mais n'est pas installé. Ce script va continuer, mais les résultats ne sont pas garantis."
fi
# s'assurer que les libraries *locales* sont dans PYTHONPATH
source "$ULIBDIR/nutools/pyulib"
fi
if [ -n "$UINST_AUTOPREFIX" ]; then
# initialiser le moteur de préfixes
urequire PREFIXES-DEFAULTS
compute_all_prefixes
srcdir="$(expand_prefix "$srcdir")"
fi
[ -e "$srcdir" ] || {
eerror "$srcdir: fichier ou répertoire introuvable"
return 1
}
UINST_SRCDIR="$(abspath "$srcdir")"
__uinst_addvar srcdir "$UINST_SRCDIR"
__uinst_dispatch
}
function __uinst_addvarnf() {
# Ajouter une variable et sa valeurs, sans l'enregistrer dans la liste des
# variables modifiées par l'utilisateur.
# $1=name, $2=value
if array_contains UINST_PROTECTED_VARS "$1"; then
local OENC="$UTF8"
eerror "La variable $1 est protégée"
return 1
else
array_add UINST_CONFIG_VARCMDS "$(set_var_cmd "$1" "$2")"
set_var "$1" "$2"
if [ "$1" == "MYHOST" ]; then
# cas particulier: initialiser aussi MYHOSTNAME
set_var "MYHOSTNAME" "${2%%.*}"
array_add UINST_CONFIG_VARCMDS "$(set_var_cmd "MYHOSTNAME" "$MYHOSTNAME")"
fi
return 0
fi
}
function __uinst_addvar() {
# Ajouter une variable et sa valeur, et l'enregistrer dans la liste des
# variables spécifiées par l'utilisateur.
# $1=name, $2=value
if __uinst_addvarnf "$@"; then
array_set UINST_CONFIG_VARS "$1"
fi
}
function __uinst_setvar() {
# Evaluer la variable $1 en prenant sa valeur dans CONFIG_VARCMDS
local __uinst_varcmd
for __uinst_varcmd in "${UINST_CONFIG_VARCMDS[@]}"; do
if beginswith "$__uinst_varcmd" "$1="; then
eval "$__uinst_varcmd"
# ne pas faire break, parce que plusieurs occurences peuvent
# exister, les dernières écrasant les premières
fi
done
}
function __uinst_setvars() {
# Evaluer toute les variables de CONFIG_VARCMDS pour initialiser leurs
# valeurs
local __uinst_varcmd
for __uinst_varcmd in "${UINST_CONFIG_VARCMDS[@]}"; do
eval "$__uinst_varcmd"
done
}
function __uinst_printmergedvars() {
# Construire une liste de variables dont il faut afficher la valeur:
# - les variables qui ont été mentionnées sur la ligne de commandes
# - les variables mentionnées dans le tableau configure_variables
# Puis afficher ces variables et leurs valeurs
local -a __uinst_mvars
local __uinst_mvar
array_copy __uinst_mvars UINST_CONFIG_VARS
array_extend __uinst_mvars configure_variables
for __uinst_mvar in "${__uinst_mvars[@]}"; do
estep "$__uinst_mvar=${!__uinst_mvar}"
done
}
function __uinst_check_dir() {
# Tester si le répertoire $1 est installable par uinst
__uinst_check_udir "$1" ||
__uinst_check_legacy "$1" ||
__uinst_check_rsync "$1" ||
__uinst_check_python "$1"
}
function __uinst_check_uinst2s() {
# Vérifier le script de second étage $1 existe, et initialiser la variable
# uinst2s avec le chemin vers le script
uinst2s="$ULIBDIR/support/${1:-uinst2s}"
[ -x "$uinst2s" ] || {
eerror "Script ${uinst2s#$ULIBDIR/support/} introuvable dans '$(dirname "$uinst2s")'"
return 1
}
}
function __uinst_dispatch() {
# Sélectionner la méthode appropriée pour installer $srcdir
if __uinst_check_udir "$srcdir"; then
# Répertoire uinst configuré avec udir
__uinst_udir || return 1
elif __uinst_check_legacy "$srcdir"; then
# Répertoire uinst original
__uinst_legacy || return 1
elif __uinst_check_rsync "$srcdir"; then
# Fichiers à déployer avec rsync
__uinst_rsync || return 1
elif __uinst_check_python "$srcdir"; then
# Package python
__uinst_python || return 1
elif __uinst_check_archive "$srcdir"; then
# Archive
__uinst_archive || return 1
elif [ -f "$srcdir" ]; then
# Fichier simple
__uinst_file || return 1
else
eerror "$srcdir: impossible de déployer un répertoire non préparé.
Veuillez préparer ce répertoire avec 'uinst -C $(ppath "$srcdir")'
Si le répertoire a déjà été préparé, vérifier la présence de l'une des valeurs
'uinst', 'uinst:legacy', 'uinst:rsync' ou 'uinst:python' dans la variable
udir_types."
return 1
fi
}
function __uinst_prepare_workdir() {
# Faire une copie de travail de $srcdir dans $1
# srcdir est modifié pour devenir la nouvelle valeur
local srcname="$(basename "$srcdir")"
estep "Création d'une copie de travail dans $1..."
"${UINST_COPY_METHOD:-cpnovcs}" "$srcdir" "$1/$srcname"
srcdir="$1/$srcname"
chmod -R +w "$srcdir" || return 1
return 0
}
function __uinst_prepare_ulib() {
# Copie l'environnement de déploiement dans $UINST_PREPARE_DIR
estep "Copie de l'environnement de déploiement"
ulib_sync "$UINST_PREPARE_DIR"
pyulib_sync "$UINST_PREPARE_DIR"
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 sysinfos compat uinst udir prefixes uinc
else
exit 1
fi
OENC="$UTF8"
uinst "$@"' >"$UINST_PREPARE_DIR/uinst.sh"
chmod +x "$UINST_PREPARE_DIR/uinst.sh"
}
function __uinst_prepare_conf() {
# créer le fichier de configuration $UINST_PREPARE_CONF avec
# prepare_name=$srcdir
# srcdir est un chemin relatif à $UINST_PREPARE_DIR (si la source était une
# archive, il est possible que ce chemin soit en plusieurs parties
set_var_cmd prepare_name "$(relpath "$srcdir" "$UINST_PREPARE_DIR")" >"$UINST_PREPARE_CONF"
}
################################################################################
# uinst: udir
function __uinst_check_udir() {
# Vérifier si $1 est un répertoire configuré avec udir, installable avec
# uinst
if [ -d "$1" -a -f "$1/.udir" ]; then
udir_eval "$1" 'array_contains udir_types uinst' && return 0
fi
return 1
}
function __uinst_udir() {
# Installer le répertoire $srcdir qui contient la configuration dans le
# fichier .udir
local uinst2s
__uinst_check_uinst2s || return 1
# initialiser les valeurs par défaut, mais penser à restaurer srcdir
__uinst_defaultvars
__uinst_setvar srcdir
# puis charger les valeurs de $srcdir/.udir, mais penser à restaurer srcdir
eval "$(udir_dump "$srcdir")"
__uinst_setvar srcdir
# initialiser UDIR_VARS et UDIR_ARRAYS. cela permettra de construire le
# fichier de configuration pour les scripts et le déploiement
udir_parse "$srcdir"
# puis charger les valeurs de la ligne de commande
__uinst_setvars
# corriger éventuellement destdir
[ -n "$UINST_AUTOPREFIX" ] && destdir="$(expand_prefix "$destdir")"
# afficher les valeurs dignes d'intérêt
__uinst_printmergedvars
# puis lancer le déploiement
__uinst_udir2s
}
function __uinst_udir2s() {
# Installer le répertoire $srcdir
local OENC="$UTF8"
if [ "$UINST_ACTION" == prepare-1s ]; then
: # pas de confirmation en mode prépare
elif is_yes "$copy_files"; then
ask_yesno "Déployer $(ppath "$srcdir") dans $(ppath "$destdir") sur $MYHOST?" O || return 1
else
ask_yesno "Déployer $(ppath "$srcdir") sur $MYHOST?" O || return 1
fi
local origsrcdir="$srcdir" # utilisé par uinc
local srcname="$(basename "$srcdir")"
local dest="$destdir/$srcname"
## Configurer la source: faire éventuellement une copie de travail
if [ -z "$UINST_ISTMPDIR" ]; then
if [ "$UINST_ACTION" == prepare-1s ]; then
# Faire la copie de travail pour le prédéploiement dans le
# répertoire spécifié
__uinst_prepare_workdir "$UINST_PREPARE_DIR" || return 1
else
# Si nous ne sommes pas dans un répertoire temporaire, alors faire
# une copie de travail
ac_set_tmpdir UINST_TMPDIR
__uinst_prepare_workdir "$UINST_TMPDIR" || return 1
fi
fi
## Déplier les inclusions
# Ne déplier les inclusions que maintenant, parce que le répertoire initial
# était peut-être protégé en écriture.
# ne pas déplier si on est dans la deuxième phase de l'étape de préparation
if [ "$UINST_ACTION" != prepare-2s ] && is_yes "$uinc"; then
# uinc doit charger les paramètres de .udir/.uinst.conf, d'où le --auto
# par contre, on doit forcer les paramètres --refdir et -u
etitle "Dépliage des inclusions" \
uinc -y --auto --refdir "$origsrcdir" -C uinst -u "$srcdir"
fi
## Prédéploiement
if [ "$UINST_ACTION" == prepare-1s ]; then
# Fin de traitement si on est dans la première phase de l'étape de
# préparation
[ -n "$UINST_PREPARE_ULIB" ] && __uinst_prepare_ulib
__uinst_prepare_conf
return 0
fi
## Faire le fichier de configuration
local __uinst_configdir __uinst_config __uinst_abort
local __uinst_var
local -a __uinst_vars __uinst_arrays
for __uinst_var in "${UINST_CONFIG_VARS[@]}" "${configure_variables[@]}"; do
if array_contains UDIR_ARRAYS "$var_"; then
array_set __uinst_arrays "$__uinst_var"
else
array_set __uinst_vars "$__uinst_var"
fi
done
for __uinst_var in "${UDIR_VARS[@]}"; do
array_set __uinst_vars "$__uinst_var"
done
for __uinst_var in "${UDIR_ARRAYS[@]}"; do
array_set __uinst_arrays "$__uinst_var"
done
ac_set_tmpdir __uinst_configdir
__uinst_config="$__uinst_configdir/config"
__uinst_abort="$__uinst_configdir/abort"
__uinst_updateconfig="$__uinst_configdir/updateconfig"
set_var_cmd ABORT "$__uinst_abort" >>"$__uinst_config"
set_var_cmd CONFIG "$__uinst_updateconfig" >>"$__uinst_config"
for __uinst_var in "${__uinst_vars[@]}"; do
set_var_cmd "$__uinst_var" "${!__uinst_var}" >>"$__uinst_config"
done
for __uinst_var in "${__uinst_arrays[@]}"; do
set_array_cmd "$__uinst_var" >>"$__uinst_config"
done
set_var_cmd "UINST_ORIGSRC" "$UINST_ORIGSRC" >>"$__uinst_config"
set_var_cmd "UINST_SRCDIR" "$UINST_SRCDIR" >>"$__uinst_config"
set_var_cmd "ULIBDIR" "$ULIBDIR" >>"$__uinst_config"
set_var_cmd "UINST" "$UINST" >>"$__uinst_config"
# ulib recalcule systématiquement la valeur de ULIBDIR. Pareil pour
# nutools/pyulib. Mais cela ne fonctionne pas si nous déployons sur une
# machine avec bash 2.x. Il faut donc forcer l'utilisation de la valeur
# calculée.
set_var_cmd "FORCED_ULIBDIR" "$ULIBDIR" >>"$__uinst_config"
set_var_cmd "FORCED_PYULIBDIR" "$PYULIBDIR" >>"$__uinst_config"
## Lancer les scripts de préconfiguration
function __uinst_preconfig_scripts() {
for preconfig_script in "${preconfig_scripts[@]}"; do
rm -f "$__uinst_abort" "$__uinst_updateconfig"
etitle "$preconfig_script" \
"${BASH:-/bin/sh}" "$srcdir/$preconfig_script" "$__uinst_config"
[ -f "$__uinst_abort" ] && return 1
if [ -f "$__uinst_updateconfig" ]; then
cat "$__uinst_updateconfig" >>"$__uinst_config"
source "$__uinst_updateconfig"
fi
done
return 0
}
etitle "Lancement des scripts de préconfiguration" __uinst_preconfig_scripts || return 1
## Configurer les variables
if [ -n "${configure_variables[*]}" ]; then
function __uinst_config_variables() {
local __uinst_cvar __uinst_cvarname __uinst_cfilespecs
for __uinst_cvarname in "${configure_variables[@]}"; do
__uinst_cvar="${!__uinst_cvarname}"
__uinst_cvar="${__uinst_cvar//,/\\,}"
etitle -s "$__uinst_cvarname"
__uinst_cfilespecs="configure_${__uinst_cvarname}_for[*]"
if [ -n "${!__uinst_cfilespecs}" ]; then
array_copy __uinst_cfilespecs "configure_${__uinst_cvarname}_for"
for __uinst_cfilespec in "${__uinst_cfilespecs[@]}"; do
splitwcs "$__uinst_cfilespec" __uinst_cfilen __uinst_cfilewc
if [ -n "$__uinst_cfilewc" ]; then
# il y a des wildcards
array_from_lines __uinst_cfiles "$(list_files "$srcdir/$__uinst_cfilen" "$__uinst_cfilewc")"
for __uinst_cfile in "${__uinst_cfiles[@]}"; do
__uinst_cfile="$__uinst_cfilen/$__uinst_cfile"
estep "$__uinst_cfile"
if quietgrep "@@${__uinst_cvarname}@@" "$srcdir/$__uinst_cfile"; then
sedi "s|@@${__uinst_cvarname}@@|$__uinst_cvar|g" "$srcdir/$__uinst_cfile"
fi
done
else
# pas de wildcards
__uinst_cfile="$__uinst_cfilespec"
estep "$__uinst_cfile"
if quietgrep "@@${__uinst_cvarname}@@" "$srcdir/$__uinst_cfile"; then
sedi "s|@@${__uinst_cvarname}@@|$__uinst_cvar|g" "$srcdir/$__uinst_cfile"
fi
fi
done
fi
eend
done
}
etitle "Configuration des variables" __uinst_config_variables
fi
## Lancer les scripts de configuration
function __uinst_config_scripts() {
for config_script in "${config_scripts[@]}"; do
rm -f "$__uinst_abort"
etitle "$config_script" \
"${BASH:-/bin/sh}" "$srcdir/$config_script" "$__uinst_config"
[ -f "$__uinst_abort" ] && return 1
done
return 0
}
etitle "Lancement des scripts de configuration" __uinst_config_scripts || return 1
## Installer les profils
if is_yes "$install_profiles"; then
urequire uenv uenv_update
etitle "Installation des profils" \
uenv_install_profiles "$srcdir" "$profiledir" "$bashrcdir" "$defaultdir"
fi
## Déploiement
# seulement s'il y a des copies de fichier ou des scripts roo
if is_yes "$copy_files" || [ -n "${root_scripts[*]}" ]; then
etitle "Lancement du déploiement" runscript_as_root "$uinst2s" "$__uinst_config"
fi
return 0
}
################################################################################
# uinst: rsync
function __uinst_check_rsync() {
# Vérifier si $1 est un répertoire à déployer avec rsync
if [ -d "$1" -a -f "$1/.udir" ]; then
udir_eval "$1" 'array_contains udir_types uinst:rsync' && return 0
fi
return 1
}
function __uinst_rsync() {
# Déployer les fichiers de $srcdir avec rsync
# initialiser les valeurs par défaut, mais penser à restaurer srcdir
force_rsync_options=(-av --exclude CVS --exclude .svn --exclude /.git/)
rsync_options=()
__uinst_defaultvars
__uinst_setvar srcdir
# puis charger les valeurs de $srcdir/.udir, mais penser à restaurer srcdir
eval "$(udir_dump "$srcdir")"
__uinst_setvar srcdir
# puis charger les valeurs de la ligne de commande
__uinst_setvars
# corriger éventuellement destdir
[ -n "$UINST_AUTOPREFIX" ] && destdir="$(expand_prefix "$destdir")"
# les variables de configure_variables ne sont pas prises en compte. pas la
# peine de les afficher
configure_variables=()
# afficher les valeurs dignes d'intérêt
__uinst_printmergedvars
if [ "$UINST_ACTION" == prepare-1s ]; then
# Faire la copie de travail pour le prédéploiement dans le répertoire
# spécifié
__uinst_prepare_workdir "$UINST_PREPARE_DIR" || return 1
[ -n "$UINST_PREPARE_ULIB" ] && __uinst_prepare_ulib
__uinst_prepare_conf
return 0
else
local srcdesc="$(ppath "$srcdir")"
if [ -n "${files[*]}" ]; then
srcdesc="$srcdesc/{$(array_join files ,)}"
fi
ask_yesno "Synchroniser $srcdesc vers $(ppath "$destdir") sur $MYHOST?" O || return
fi
cd "$srcdir" || return 1
local localsync=1
if [[ "$destdir" == *:* ]]; then
# Déploiement distant, on laisse rsync gérer
localsync=
else
# Déploiement local. S'assurer que le répertoire de destination existe
mkdir -p "$destdir" || return 1
fi
local -a cmd tmp_files actual_files copied_files
local file filename
cmd=(rsync "${force_rsync_options[@]}" "${rsync_options[@]}")
if [ -n "${files[*]}" ]; then
for file in "${files[@]}"; do
file="${file#/}" # les chemins sont toujours relatifs
if [ -e "$file" ]; then
tmp_files=("$file")
else
array_from_lines tmp_files "$(list_all . "$file")"
fi
array_extend actual_files tmp_files
done
for file in "${actual_files[@]}"; do
cmd=("${cmd[@]}" "$file")
filename="$(basename "$file")"
copied_files=("${copied_files[@]}" "$destdir/$filename")
done
else
cmd=("${cmd[@]}" ./)
array_from_lines actual_files "$(list_all . "*" ".*")"
for file in "${actual_files[@]}"; do
filename="$(basename "$file")"
copied_files=("${copied_files[@]}" "$destdir/$filename")
done
fi
cmd=("${cmd[@]}" "$destdir")
# Faire la synchro
"${cmd[@]}"
if [ -n "$localsync" ]; then
if [ -n "$owner" -a -n "${copied_files[*]}" ]; then
## Initialiser le propriétaire
estep "Initialisation du propriétaire à $owner"
chown -R "$owner" "${copied_files[@]}" || return 1
fi
if [ -n "${modes[*]}" ]; then
## Initialiser les modes
for mode in "${modes[@]}"; do
file="${mode%:*}"
if [ "$file" != "$mode" ]; then
# une spécification de mode pour un fichier spécifique
mode="${mode##*:}"
estep "Initialisation du mode à $mode pour $file"
chmod "$mode" "$destdir/$file" || return 1
elif [ -n "${copied_files[*]}" ]; then
# une spécification de mode pour tous les fichiers déployés
estep "Initialisation du mode à $mode"
chmod -R "$mode" "${copied_files[@]}" || return 1
fi
done
fi
fi
}
################################################################################
# uinst: legacy
function __uinst_check_legacy() {
# Vérifier si $1 est un répertoire à installer avec la version originale de
# uinst
if [ -d "$1" -a -f "$1/.udir" ]; then
udir_eval "$1" 'array_contains udir_types uinst:legacy' && return
fi
[ -d "$1" -a -f "$1/.uinst.conf" ]
}
function __uinst_migrate_legacy() {
local srcdir # XXX srcdir ne doit pas être écrasé, bien que .uinst.conf
# contienne la variable srcdir. Il faut donc protéger cette
# variable avec 'local srcdir'
local __uinst_srcdir="$1"
# initialiser les valeurs par défaut
update_inc=false
update_inc_options=
update_inc_args=.
configure_variables=dest
configure_dest_for=
config_scripts=
install_profiles=false
profiledir=lib/profile.d
bashrcdir=lib/bashrc.d
defaultdir=lib/default
copy_files=true
destdir=/usr/local
srcdir=.
files=
owner="root:"
modes="u=rwX,g=rX,o=rX"
root_scripts=
# puis charger les valeurs de $srcdir/.uinst.conf
# initialiser aussi UDIR_VARS et UDIR_ARRAYS. cela permettra de construire
# le fichier de configuration pour les scripts et le déploiement
if [ -f "$__uinst_srcdir/.uinst.conf" ]; then
# note: les regex qui sont entre "" au lieu de // le sont à cause d'un bug
# de awk sous macosx
source "$__uinst_srcdir/.uinst.conf"
eval "$(<"$__uinst_srcdir/.uinst.conf" filter_comment -m | awk 'BEGIN {
vars = "UDIR_VARS=("; first_var = 1;
arrays = "UDIR_ARRAYS=("; first_array = 1;
}
/^[ \t]*#/ { next }
$0 ~ /^[ \t]*[a-zA-Z_][a-zA-Z0-9_]*=\(/ {
match($0, /^[ \t]*[a-zA-Z_][a-zA-Z0-9_]*=\(/)
name = substr($0, RSTART, RLENGTH)
sub(/^([ \t]*)?/, "", name)
sub("=\\($", "", name)
if (first_array) first_array = 0
else arrays = arrays " "
arrays = arrays name
next
}
$0 ~ /^[ \t]*[a-zA-Z_][a-zA-Z0-9_]*=/ {
match($0, /^[ \t]*[a-zA-Z_][a-zA-Z0-9_]*=/)
name = substr($0, RSTART, RLENGTH)
sub(/^([ \t]*)?/, "", name)
sub("=$", "", name)
if (first_var) first_var = 0
else vars = vars " "
vars = vars name
next
}
END {
print vars ")"
print arrays ")"
}')"
else
UDIR_VARS=(copy_files destdir srcdir files owner modes update_inc update_inc_options update_inc_args configure_variables configure_dest_for config_scripts install_profiles profiledir bashrcdir defaultdir root_scripts)
UDIR_ARRAYS=()
fi
# traduire les valeurs à la mode udir.
#XXX à commenter tant que l'on ne fait pas clairement la différence entre
# srcdir, le répertoire qu'il faut *copier* et uinstdir (ou projdir), le
# répertoire qu'il faut déployer
#if [ "$srcdir" != "." ]; then
# __uinst_addvar srcdir "$(abspath "$srcdir" "$__uinst_srcdir")"
#fi
uinc="$update_inc"; \
unset update_inc; \
array_del UDIR_VARS update_inc; \
array_set UDIR_VARS uinc
uinc_options=($update_inc_options); \
unset update_inc_options; \
array_del UDIR_VARS update_inc_options; \
array_set UDIR_ARRAYS uinc_options
uinc_args=($update_inc_args); \
unset update_inc_args; \
array_del UDIR_VARS update_inc_args; \
array_set UDIR_ARRAYS uinc_args
for __uinst_a in configure_variables config_scripts root_scripts files; do
array_from_lines "$__uinst_a" "${!__uinst_a}"; \
array_del UDIR_VARS "$__uinst_a"; \
array_set UDIR_ARRAYS "$__uinst_a"
done
for __uinst_cv in "${configure_variables[@]}"; do
__uinst_cv="configure_${__uinst_cv}_for"
array_from_lines "$__uinst_cv" "${!__uinst_cv}"; \
array_del UDIR_VARS "$__uinst_cv"; \
array_set UDIR_ARRAYS "$__uinst_cv"
done
modes=($modes); \
array_del UDIR_VARS modes; \
array_set UDIR_ARRAYS modes
}
function __uinst_legacy() {
# Installer le répertoire $srcdir qui contient la configuration dans le
# fichier .uinst.conf
local uinst2s
__uinst_check_uinst2s || return 1
# charger les valeurs de $srcdir/.uinst.conf
__uinst_migrate_legacy "$srcdir"
# puis charger les valeurs de la ligne de commande
__uinst_setvars
# corriger éventuellement destdir
[ -n "$UINST_AUTOPREFIX" ] && destdir="$(expand_prefix "$destdir")"
# afficher les valeurs dignes d'intérêt
__uinst_printmergedvars
# puis lancer le déploiement
__uinst_udir2s
}
################################################################################
# uinst: python
function __uinst_check_python() {
# Vérifier si $1 est un répertoire d'un produit python à installer avec
# setup.py
[ -d "$1" -a -f "$1/setup.py" ]
}
function __uinst_python() {
# Installer le package python $srcdir
local uinst2s
__uinst_check_uinst2s uinst2s_python || return 1
if [ "$UINST_ACTION" == prepare-1s ]; then
# Faire la copie de travail pour le prédéploiement dans le répertoire
# spécifié
__uinst_prepare_workdir "$UINST_PREPARE_DIR" || return 1
[ -n "$UINST_PREPARE_ULIB" ] && __uinst_prepare_ulib
__uinst_prepare_conf
return 0
else
ask_yesno "Déployer $(ppath "$srcdir") sur $MYHOST?" O || return 1
UINST_ORIGSRC="$srcdir"
UINST_SRCDIR="$(abspath "$srcdir")"
fi
local __uinst_config __uinst_var
ac_set_tmpfile __uinst_config
for __uinst_var in srcdir; do
set_var_cmd "$__uinst_var" "${!__uinst_var}" >>"$__uinst_config"
done
set_var_cmd "UINST_ORIGSRC" "$UINST_ORIGSRC" >>"$__uinst_config"
set_var_cmd "UINST_SRCDIR" "$UINST_SRCDIR" >>"$__uinst_config"
set_var_cmd "ULIBDIR" "$ULIBDIR" >>"$__uinst_config"
set_var_cmd "UINST" "$UINST" >>"$__uinst_config"
runscript_as_root "$uinst2s" "$__uinst_config"
}
################################################################################
# uinst: archive
function __uinst_check_archive() {
# Vérifier si $1 est une archive installable avec uinst
is_archive "$1"
}
function __uinst_archname() {
# essayer de déterminer un nom de base pour le répertoire de destination
# d'une archive à décompresser: l'extension et le numéro de version sont
# supprimés du nom de l'archive
local archname="$(basename "$1")"
# supprimer l'extension
archname="${archname%.zip}"
archname="${archname%.tgz}"
archname="${archname%.tar.gz}"
archname="${archname%.tbz2}"
archname="${archname%.tar.bz2}"
archname="${archname%.tar}"
archname="${archname%.jar}"
archname="${archname%.war}"
# supprimer la version
archname="$(echo "$archname" | awk '{sub(/-[0-9]+(\.[0-9]+)*$/, ""); print}')"
# résultat
echo "${archname:-archive}"
}
function __uinst_archive() {
# Installer l'archive $srcdir. Elle est décompactée pour déterminer le type
# d'installation qu'il faut pour elle
if [ "$UINST_ACTION" == prepare-1s ]; then
# Décompacter l'archive dans le répertoire spécifié
UINST_TMPDIR="$UINST_PREPARE_DIR"
else
# Décompacter l'archive dans un répertoire temporaire
ac_set_tmpdir UINST_TMPDIR
UINST_ORIGSRC="$srcdir"
fi
estep "Décompactage d'une copie de travail dans $UINST_TMPDIR..."
local archdir="$UINST_TMPDIR/$(__uinst_archname "$srcdir")"
mkdir -p "$archdir" || return 1
extract_archive "$srcdir" "$archdir" || return 1
UINST_SRCDIR="$(abspath "$archdir")"
# Décomptacter l'archive dans un répertoire temporaire
# s'il n'y a qu'un seul répertoire dans l'archive, le considérer comme le
# répertoire à déployer
local -a contents_
array_lsall contents_ "$archdir"
if [ "${#contents_[*]}" -eq 1 ]; then
archdir="${contents_[0]}"
fi
UINST_ISTMPDIR=1
__uinst_addvarnf srcdir "$archdir"
__uinst_dispatch
}
################################################################################
# uinst: file
function __uinst_check_file() {
# Vérifier si $1 est un fichier installable avec uinst
[ -f "$1" ]
}
function __uinst_file() {
# Installer le fichier simple $srcdir
local uinst2s
__uinst_check_uinst2s || return 1
__uinst_defaultvars
__uinst_setvars
[ -n "$UINST_AUTOPREFIX" ] && destdir="$(expand_prefix "$destdir")"
__uinst_printmergedvars
if [ "$UINST_ACTION" == prepare-1s ]; then
# Faire la copie de travail pour le prédéploiement dans le répertoire
# spécifié
local srcname="$(basename "$srcdir")"
estep "Création d'une copie de travail dans $UINST_PREPARE_DIR..."
"${UINST_COPY_METHOD:-cpnovcs}" "$srcdir" "$UINST_PREPARE_DIR"
srcdir="$UINST_PREPARE_DIR/$srcname"
chmod +w "$srcdir" || return 1
[ -n "$UINST_PREPARE_ULIB" ] && __uinst_prepare_ulib
__uinst_prepare_conf
return 0
else
ask_yesno "Déployer $(ppath "$srcdir") dans $(ppath "$destdir")?" O || return 1
UINST_ORIGSRC="$srcdir"
UINST_SRCDIR="$(dirname "$(abspath "$srcdir")")"
fi
local __uinst_config __uinst_var
ac_set_tmpfile __uinst_config
for __uinst_var in copy_files destdir srcdir owner modes; do
set_var_cmd "$__uinst_var" "${!__uinst_var}" >>"$__uinst_config"
done
for __uinst_var in files modes; do
set_array_cmd "$__uinst_var" >>"$__uinst_config"
done
set_var_cmd "UINST_ORIGSRC" "$UINST_ORIGSRC" >>"$__uinst_config"
set_var_cmd "UINST_SRCDIR" "$UINST_SRCDIR" >>"$__uinst_config"
set_var_cmd "ULIBDIR" "$ULIBDIR" >>"$__uinst_config"
set_var_cmd "UINST" "$UINST" >>"$__uinst_config"
runscript_as_root "$uinst2s" "$__uinst_config"
}
################################################################################
# uinst2s
function __uinst2s_copy_files() {
# Copier les fichiers files de srcdir dans destdir
# Cette fonction est utilisée par le script uinst2s
srcname="$(basename "$srcdir")"
destdir="$(abspath "$destdir")"
dest="$destdir/$srcname"
copied_files=()
# pour la copie "atomique" du répertoire de destination (en réalité, on
# cherche à minimiser le temps d'indisponibilité du répertoire destination)
atomic=
actualdest=
2013-08-27 15:14:44 +04:00
if [ -f "$srcdir" ]; then
## Copie d'un fichier dans un répertoire
if [ ! -d "$destdir" ]; then
estep "Création de $destdir"
mkdir -p "$destdir" || return 1
fi
estep "Copie de $(ppath "$srcdir") dans $destdir"
cpdir "$srcdir" "$destdir" || return 1
copied_files=("${copied_files[@]}" "$destdir/$(basename "$srcdir")")
elif [ -d "$srcdir" ]; then
## Copie d'un répertoire ou d'une partie de son contenu dans un
## répertoire de destination
if [ -z "${files[*]}" ]; then
# On n'a pas spécifié de liste de fichiers. C'est tout le répertoire
# source qui est copié, et il remplace la destination.
if [ -d "$dest" ]; then
# Le répertoire existe déjà. Tenter de faire une copie la plus
# atomique possible: déployer dans un répertoire temporaire, qui
# sera renommé vers la destination au dernier moment
eimportant "Le répertoire destination $dest sera écrasé"
ebegin "Attente de 3 secondes"
sleep 1; edot
sleep 1; edot
sleep 1; edot
eend
atomic=1
actualdest="$dest"
dest="$actualdest.copy$$"
i=0
while [ -d "$dest" ]; do
dest="$actualdest.copy$$-$i"
i=$(($i + 1))
done
else
enote "Le répertoire destination est $dest"
fi
2013-08-27 15:14:44 +04:00
mkdir -p "$dest" || return 1
2013-08-27 15:14:44 +04:00
estep "Copie de $(ppath "$srcdir")"
cpdir "$srcdir" "$dest" || return 1
copied_files=("${copied_files[@]}" "$dest")
else
# On a spécifié une liste de fichiers. Seuls ces fichiers sont
# copiés, et le répertoire de destination n'est pas écrasé
enote "La copie se fera dans $destdir"
2013-08-27 15:14:44 +04:00
mkdir -p "$destdir" || return 1
for file in "${files[@]}"; do
estep "Copie de $file"
if [ -e "$srcdir/$file" ]; then
# fichier existant
actual_files=("$file")
wildcards=
else
# fichier non existant: c'est peut-être une spécification de
# fichier avec des wildcards
array_from_lines actual_files "$(list_all "$srcdir" "$file")"
wildcards=1
fi
local srcfile srcfilename
for file in "${actual_files[@]}"; do
srcfile="$srcdir/$file"
srcfilename="$(basename "$file")"
[ -n "$wildcards" ] && echo "... $file" 1>&2
if [ -d "$srcfile" ]; then
cpdir "$srcfile" "$destdir/$srcfilename" || return 1
else
cpdir "$srcfile" "$destdir" || return 1
fi
copied_files=("${copied_files[@]}" "$destdir/$srcfilename")
done
done
fi
else
ewarn "$srcdir: fichier ignoré"
fi
if [ -n "$owner" -a -n "${copied_files[*]}" ]; then
## Initialiser le propriétaire
estep "Initialisation du propriétaire à $owner"
chown -R "$owner" "${copied_files[@]}" || return 1
fi
if [ -n "${modes[*]}" ]; then
## Initialiser les modes
for mode in "${modes[@]}"; do
file="${mode%:*}"
if [ "$file" != "$mode" ]; then
# une spécification de mode pour un fichier spécifique
mode="${mode##*:}"
estep "Initialisation du mode à $mode pour $file"
if [ -z "${files[*]}" ]; then
chmod "$mode" "$dest/$file" || return 1
else
chmod "$mode" "$destdir/$file" || return 1
fi
elif [ -n "${copied_files[*]}" ]; then
# une spécification de mode pour tous les fichiers déployés
estep "Initialisation du mode à $mode"
chmod -R "$mode" "${copied_files[@]}" || return 1
fi
done
fi
if [ -n "$atomic" ]; then
tmpdest="$actualdest.tmp$$"
i=0
while [ -d "$tmpdest" ]; do
tmpdest="$actualdest.tmp$$-$i"
i=$(($i + 1))
done
estep "Installation du nouveau répertoire"
mv "$actualdest" "$tmpdest" &&
mv "$dest" "$actualdest" || return 1
estep "Suppression de l'ancien répertoire"
rm -rf "$tmpdest" || return 1
fi
2013-08-27 15:14:44 +04:00
}
function __uinst2s_root_scripts() {
# Lancer les scripts de root_scripts avec les arguments de cette fonction
if is_yes "$copy_files"; then
if [ -d "$dest" ]; then
cd "$dest" || return 1
else
cd "$destdir" || return 1
fi
fi
for root_script in "${root_scripts[@]}"; do
etitle "$root_script" \
"${BASH:-/bin/sh}" "$srcdir/$root_script" "$@"
done
}
function __uinst2s_python_setup() {
# Installer le package python
cd "$srcdir" && python setup.py install
}