déplacer les librairies dans lib/
This commit is contained in:
Jephte CLAIN
@@ -1 +0,0 @@
|
||||
42
|
||||
@@ -1,7 +0,0 @@
|
||||
##@cooked nocomments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
##@include base
|
||||
##@include pretty
|
||||
##@include sysinfos
|
||||
##@include compat
|
||||
uprovide DEFAULTS
|
||||
urequire base pretty sysinfos compat
|
||||
@@ -1,17 +0,0 @@
|
||||
##@cooked nocomments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
##@include prefixes
|
||||
##@include java
|
||||
##@include webobjects
|
||||
##@include apache
|
||||
##@include ldap
|
||||
##@include crontab
|
||||
uprovide PREFIXES-DEFAULTS
|
||||
urequire prefixes java webobjects apache ldap crontab
|
||||
|
||||
function compute_all_prefixes() {
|
||||
compute_java_prefixes
|
||||
compute_webobjects_prefixes
|
||||
compute_apache_prefixes
|
||||
compute_ldap_prefixes
|
||||
compute_crontab_prefixes
|
||||
}
|
||||
687
ulib/apache
687
ulib/apache
@@ -1,687 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion du service apache (démarrage/arrêt), et de sa configuration
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
uprovide apache
|
||||
urequire base sysinfos
|
||||
|
||||
function __apache_prefixes_checkdir() {
|
||||
local dir
|
||||
for dir in "$@"; do
|
||||
if [ -d "$dir" ]; then
|
||||
echo "$dir"
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function __apache_prefixes_checkfile() {
|
||||
local file
|
||||
for file in "$@"; do
|
||||
if [ -f "$file" ]; then
|
||||
echo "$file"
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function __apache_prefixes_checkexec() {
|
||||
local exec
|
||||
for exec in "$@"; do
|
||||
if [ -x "$exec" ]; then
|
||||
echo "$exec"
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function get_default_apachebin_prefix() {
|
||||
__apache_prefixes_checkexec /usr/sbin/{apache2,apache,httpd}
|
||||
}
|
||||
|
||||
function get_default_apacheversion_prefix() {
|
||||
[ -n "$APACHEBIN" ] || return
|
||||
local version="$($APACHEBIN -v | grep version:)"
|
||||
if [[ "$version" == *1.3* ]]; then
|
||||
echo ""
|
||||
elif [[ "$version" == *2.0* ]]; then
|
||||
echo "2"
|
||||
elif [[ "$version" == *2.2* ]]; then
|
||||
echo "2.2"
|
||||
elif [[ "$version" == *2.4* ]]; then
|
||||
echo "2.4"
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_apachectl_prefix() {
|
||||
[ -n "$APACHEBIN" ] || return
|
||||
__apache_prefixes_checkexec "$(dirname "$APACHEBIN")"/apache*ctl
|
||||
}
|
||||
|
||||
function get_default_apachelogdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir /var/log/{apache2,httpd}
|
||||
elif check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
__apache_prefixes_checkdir /var/log/{apache2,apache}
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
__apache_prefixes_checkdir /var/log/httpd
|
||||
elif check_sysinfos -d gentoo; then
|
||||
# XXX à vérifier
|
||||
__apache_prefixes_checkdir /var/log/{apache{2,},httpd}
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_apachesslcertsdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir /etc/{apache2,httpd}/ssl.crt
|
||||
elif check_sysinfos -s linux; then
|
||||
__apache_prefixes_checkdir /etc/ssl/certs /etc/pki/tls/certs /etc/httpd/conf/ssl.crt
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_apachesslkeysdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir /etc/{apache2,httpd}/ssl.key
|
||||
elif check_sysinfos -s linux; then
|
||||
__apache_prefixes_checkdir /etc/ssl/private /etc/pki/tls/private /etc/httpd/conf/ssl.key
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_apacheconfdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir /etc/{apache2,httpd}
|
||||
elif check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
__apache_prefixes_checkdir /etc/{apache{2,,-ssl},httpd}
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
__apache_prefixes_checkdir /etc/httpd
|
||||
elif check_sysinfos -d gentoo; then
|
||||
__apache_prefixes_checkdir /etc/{apache{2,},httpd}
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_apacheconf_prefix() {
|
||||
[ -n "$APACHECONFDIR" ] || return
|
||||
__apache_prefixes_checkfile "$APACHECONFDIR"/{apache2,{,conf/}httpd}.conf
|
||||
}
|
||||
|
||||
function get_default_apacheavsitesdir_prefix() {
|
||||
[ -n "$APACHECONFDIR" ] || return
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir "$APACHECONFDIR/sites_disabled"
|
||||
elif check_sysinfos -d debianlike gentoo; then
|
||||
__apache_prefixes_checkdir "$APACHECONFDIR/sites-available"
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_apachesitesdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir "$APACHECONFDIR/sites"
|
||||
elif check_sysinfos -d debianlike gentoo; then
|
||||
__apache_prefixes_checkdir "$APACHECONFDIR/sites-enabled"
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_htdocsdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir /Library/WebServer/Documents
|
||||
elif check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
__apache_prefixes_checkdir /var/www
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
__apache_prefixes_checkdir /var/www/html
|
||||
elif check_sysinfos -d gentoo; then
|
||||
__apache_prefixes_checkdir /var/www/localhost/htdocs
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_cgibindir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
__apache_prefixes_checkdir /Library/WebServer/CGI-Executables
|
||||
elif check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
__apache_prefixes_checkdir /usr/lib/cgi-bin
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
__apache_prefixes_checkdir /var/www/cgi-bin
|
||||
elif check_sysinfos -d gentoo; then
|
||||
__apache_prefixes_checkdir /var/www/localhost/cgi-bin
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
__apache_prefixes=
|
||||
function __compute_apache_prefixes() {
|
||||
[ -n "$__apache_prefixes" ] && return
|
||||
APACHEBIN="${APACHEBIN:-$(get_default_apachebin_prefix)}"
|
||||
APACHEVERSION="${APACHEVERSION:-$(get_default_apacheversion_prefix)}"
|
||||
APACHECTL="${APACHECTL:-$(get_default_apachectl_prefix)}"
|
||||
APACHELOGDIR="${APACHELOGDIR:-$(get_default_apachelogdir_prefix)}"
|
||||
APACHESSLCERTSDIR="${APACHESSLCERTSDIR:-$(get_default_apachesslcertsdir_prefix)}"
|
||||
APACHESSLKEYSDIR="${APACHESSLKEYSDIR:-$(get_default_apachesslkeysdir_prefix)}"
|
||||
APACHECONFDIR="${APACHECONFDIR:-$(get_default_apacheconfdir_prefix)}"
|
||||
APACHECONF="${APACHECONF:-$(get_default_apacheconf_prefix)}"
|
||||
APACHEAVSITESDIR="${APACHEAVSITESDIR:-$(get_default_apacheavsitesdir_prefix)}"
|
||||
APACHESITESDIR="${APACHESITESDIR:-$(get_default_apachesitesdir_prefix)}"
|
||||
HTDOCSDIR="${HTDOCSDIR:-$(get_default_htdocsdir_prefix)}"
|
||||
CGIBINDIR="${CGIBINDIR:-$(get_default_cgibindir_prefix)}"
|
||||
__apache_prefixes=1
|
||||
}
|
||||
|
||||
UTOOLS_PREFIXES=("${UTOOLS_PREFIXES[@]}" APACHEBIN APACHEVERSION APACHECTL APACHELOGDIR APACHESSLCERTSDIR APACHESSLKEYSDIR APACHECONFDIR APACHECONF APACHEAVSITESDIR APACHESITESDIR HTDOCSDIR CGIBINDIR)
|
||||
|
||||
function compute_apache_prefixes() {
|
||||
__compute_apache_prefixes
|
||||
}
|
||||
|
||||
function recompute_apache_prefixes() {
|
||||
__apache_prefixes=
|
||||
__compute_apache_prefixes
|
||||
}
|
||||
|
||||
function get_APACHEBIN_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHEBIN"
|
||||
}
|
||||
|
||||
function get_APACHEVERSION_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHEVERSION"
|
||||
}
|
||||
|
||||
function get_APACHECTL_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHECTL"
|
||||
}
|
||||
|
||||
function get_APACHELOGDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHELOGDIR"
|
||||
}
|
||||
|
||||
function get_APACHESSLCERTSDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHESSLCERTSDIR"
|
||||
}
|
||||
|
||||
function get_APACHESSLKEYSDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHESSLKEYSDIR"
|
||||
}
|
||||
|
||||
function get_APACHECONFDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHECONFDIR"
|
||||
}
|
||||
|
||||
function get_APACHECONF_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHECONF"
|
||||
}
|
||||
|
||||
function get_APACHEAVSITESDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHEAVSITESDIR"
|
||||
}
|
||||
|
||||
function get_APACHESITESDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$APACHESITESDIR"
|
||||
}
|
||||
|
||||
function get_HTDOCSDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$HTDOCSDIR"
|
||||
}
|
||||
|
||||
function get_CGIBINDIR_prefix() {
|
||||
__compute_apache_prefixes
|
||||
echo "$CGIBINDIR"
|
||||
}
|
||||
|
||||
function __apache_resolvcert() {
|
||||
[ -n "$__rc_dir" ] || __rc_dir="$(dirname "$__rc_conf")"
|
||||
eval "$(
|
||||
source "$__rc_conf"
|
||||
set_var_cmd __rc_cert "$cert"
|
||||
set_var_cmd __rc_key "$key"
|
||||
set_var_cmd __rc_ca "$ca"
|
||||
)"
|
||||
[ -n "$__rc_cert" ] && __rc_cert="$(abspath "$__rc_cert" "$__rc_dir")"
|
||||
[ -n "$__rc_key" ] && __rc_key="$(abspath "$__rc_key" "$__rc_dir")"
|
||||
[ -n "$__rc_ca" ] && __rc_ca="$(abspath "$__rc_ca" "$__rc_dir")"
|
||||
}
|
||||
|
||||
function __apache_checkvars() {
|
||||
if [ -n "$__rc_cert" -a -z "$__rc_key" ]; then
|
||||
local __rc_name __rc_ext
|
||||
splitname "$__rc_cert" __rc_name __rc_ext
|
||||
if [ "$__rc_ext" == "crt" -o "$__rc_ext" == "pem" ]; then
|
||||
__rc_key="$__rc_name.key"
|
||||
enote "La clé privée n'a pas été spécifiée. La valeur $(ppath "$__rc_key") sera utilisée"
|
||||
else
|
||||
eerror "Impossible de trouver la clé privée correspondant au certificat $(ppath "$__rc_cert")"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
if [ -z "$__rc_cert" -a -z "$__rc_ca" ]; then
|
||||
eerror "Vous devez spécifier le certificat à installer"
|
||||
return 1
|
||||
elif [ -z "$__rc_cert" ]; then
|
||||
eattention "Seul le certificat autorité a été spécifié."
|
||||
elif [ -z "$__rc_ca" ]; then
|
||||
ewarn "Aucun certificat autorité n'a pas été spécifié. Cela ne peut marcher que si le certificat est autosigné"
|
||||
fi
|
||||
|
||||
local i
|
||||
for i in "$__rc_cert" "$__rc_key" "$__rc_ca"; do
|
||||
[ -n "$i" ] || continue
|
||||
[ -f "$i" ] || {
|
||||
eerror "$i: Fichier introuvable"
|
||||
return 1
|
||||
}
|
||||
done
|
||||
}
|
||||
|
||||
function apache_resolvecert() {
|
||||
# Calculer l'emplacement des certificats correspondant aux arguments $1 et
|
||||
# $2 (qui correspondent aux options --conf et --dir de apache_addcert()),
|
||||
# puis initialiser les variables $3(=cert), $4(=key) et $5(=ca)
|
||||
local __rc_conf="$1" __rc_dir="$2"
|
||||
local __rc_cert __rc_key __rc_ca
|
||||
|
||||
__apache_resolvcert
|
||||
__apache_checkvars || return 1
|
||||
set_var "${3:-cert}" "$__rc_cert"
|
||||
set_var "${4:-key}" "$__rc_key"
|
||||
set_var "${5:-ca}" "$__rc_ca"
|
||||
}
|
||||
|
||||
function apache_addcert() {
|
||||
function __apache_addcert_display_help() {
|
||||
uecho "apache_addcert: Installer un certificat sur le serveur
|
||||
|
||||
USAGE
|
||||
apache_addcert [options] [cert.pem [cert.key [ca.pem]]]
|
||||
|
||||
OPTIONS
|
||||
--conf certsconf
|
||||
--dir certsdir
|
||||
Spécifier un fichier de configuration et un répertoire depuis lesquels
|
||||
prendre les informations sur les certificats à utiliser.
|
||||
Le fichier de configuration doit définir les variables cert, key et ca
|
||||
avec les noms des fichiers contenant respectivement le certificat, la
|
||||
clé privée, et les certificats autorités, exprimés relativement au
|
||||
répertoire certsdir.
|
||||
Si ces options ne sont pas spécifiées, les fichiers doivent être donnés
|
||||
sur la ligne de commande.
|
||||
|
||||
--out-cert cert
|
||||
--out-key key
|
||||
--out-ca ca
|
||||
Au lieu d'installer les certificats, placer les chemins vers les
|
||||
fichiers correspondant dans les variables spécifiées"
|
||||
}
|
||||
|
||||
eval "$(utools_local)"
|
||||
local action=install
|
||||
local certsconf certsdir cert key ca
|
||||
local __out_cert __out_key __out_ca
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with __apache_addcert_display_help' \
|
||||
-C:,--conf: certsconf= \
|
||||
-d:,--dir: certsdir= \
|
||||
--out-cert: '$set@ __out_cert; action=dump' \
|
||||
--out-key: '$set@ __out_key; action=dump' \
|
||||
--out-ca: '$set@ __out_ca; action=dump' \
|
||||
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
||||
|
||||
local __rc_conf __rc_dir
|
||||
local __rc_cert __rc_key __rc_ca
|
||||
if [ -n "$certsconf" ]; then
|
||||
__rc_conf="$certsconf"
|
||||
__rc_dir="$certsdir"
|
||||
__apache_resolvconf
|
||||
__apache_checkvars || return 1
|
||||
else
|
||||
__rc_cert="$1"
|
||||
__rc_key="$2"
|
||||
__rc_ca="$3"
|
||||
__apache_checkvars || return 1
|
||||
fi
|
||||
cert="$__rc_cert"
|
||||
key="$__rc_key"
|
||||
ca="$__rc_ca"
|
||||
|
||||
if [ -n "$cert" ]; then
|
||||
estepi "Certificat: $(ppath "$cert")"
|
||||
estepi "Clé privée: $(ppath "$key")"
|
||||
fi
|
||||
[ -n "$ca" ] && estepi "CAutorités: $(ppath "$ca")"
|
||||
ask_yesno "Voulez-vous continuer?" O || return 1
|
||||
urequire install
|
||||
|
||||
etitle "Installation des certificats"
|
||||
certsdir="$(get_APACHESSLCERTSDIR_prefix)"
|
||||
keysdir="$(get_APACHESSLKEYSDIR_prefix)"
|
||||
if [ ! -d "$certsdir" ]; then
|
||||
mkdir -p "$certsdir" || return 1
|
||||
chmod 755 "$certsdir" || return 1
|
||||
fi
|
||||
if [ ! -d "$keysdir" ]; then
|
||||
mkdir -p "$keysdir" || return 1
|
||||
chmod 710 "$keysdir" || return 1
|
||||
fi
|
||||
if [ -n "$cert" ]; then
|
||||
copy_replace "$cert" "$certsdir" || return 1
|
||||
chmod 644 "$certsdir/$(basename "$cert")" || return 1
|
||||
copy_replace "$key" "$keysdir" || return 1
|
||||
chmod 640 "$keysdir/$(basename "$key")" || return 1
|
||||
fi
|
||||
if [ -n "$ca" ]; then
|
||||
copy_replace "$ca" "$certsdir" || return 1
|
||||
chmod 644 "$certsdir/$(basename "$ca")" || return 1
|
||||
fi
|
||||
eend
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
function apache_autoconf() {
|
||||
function __apache_autoconf_display_help() {
|
||||
uecho "apache_autoconf: Mettre à jour la configuration d'apache
|
||||
|
||||
USAGE
|
||||
apache_autoconf AUTOCONFDIR [CERTSDIR]
|
||||
|
||||
AUTOCONFDIR peut contenir les fichiers et répertoires suivants, qui sont tous
|
||||
optionnels:
|
||||
- modules.conf la liste des modules qu'il faut activer. Si un module n'existe
|
||||
pas dans ce fichier, ou si ce fichier n'existe pas, aucune modification n'est
|
||||
effectuée. Si un module est de la forme -module, il est désactivé. Si un
|
||||
module est de la forme +module, il est activé. Cette syntaxe permet de
|
||||
supporter les modules dont le nom commencerait par '-'
|
||||
- sites.conf la liste des sites qu'il faut activer. Si un site ne figure pas
|
||||
dans ce fichier, il est désactivé. Si ce fichier n'existe pas, tous les sites
|
||||
existant sont activés.
|
||||
- tous les autres fichiers sont copiés tels quels dans /etc/apache2. Notamment,
|
||||
apache2.conf est le fichier de configuration principal d'apache et ports.conf
|
||||
le fichier de configuration des ports d'écoute.
|
||||
- modules/ le répertoire des configurations de modules à installer. Les fichiers
|
||||
de ce répertoire sont de la forme MODULE.conf et sont installés dans le
|
||||
répertoire /etc/apache2/mods-available. Il faut mentioner le module dans le
|
||||
fichier modules.conf pour l'activer.
|
||||
- sites/ le répertoire des sites à installer. Les fichiers de ce répertoire sont
|
||||
de la forme NAME.conf pour les sites écoutant en clair, et NAME.ssl.conf pour
|
||||
les sites écoutant en https. Pour chaque site NAME.ssl.conf, un fichier
|
||||
NAME-certs.conf doit exister dans certsconf/
|
||||
Dans les fichiers NAME.ssl.conf, les valeurs @@cert@@, @@key@@ et @@ca@@ sont
|
||||
respectivement remplacées par l'emplacement des fichiers de certificats
|
||||
définis dans les fichiers correspondants NAME-certs.conf
|
||||
- cgi-bin/ le répertoire des scripts cgi à installer
|
||||
- www/ le répertoire qui contient les fichiers du serveur web à installer dans
|
||||
l'emplacement par défaut.
|
||||
- certsconf/ le répertoire qui contient la configuration pour les certificats à
|
||||
installer. Si ce répertoire existe, il faut spécifier CERTSDIR
|
||||
Les fichiers de ce répertoire sont de la forme NAME-certs.conf et chacun d'eux
|
||||
correspondant en principe à un fichier NAME.ssl.conf dans sites/
|
||||
- RewriteRules/ le répertoire qui contient la configuration de réécriture. Tous
|
||||
les fichiers RewriteRules*.conf de ce répertoire sont copiés dans /etc/apache2
|
||||
|
||||
IMPORTANT: Cette fonction n'est pour le moment supporté que sur debian
|
||||
|
||||
OPTIONS
|
||||
--confdir CONFDIR
|
||||
Spécifier l'emplacement des fichiers de configuration apache ainsi que
|
||||
modules.conf et sites.conf
|
||||
Par défaut, utiliser AUTOCONFDIR
|
||||
--modulesdir MODULESDIR
|
||||
Spécifier l'emplacement des fichiers de configuration des modules.
|
||||
Par défaut, utiliser AUTOCONFDIR/modules si ce répertoire existe.
|
||||
--sitesdir SITESDIR
|
||||
Spécifier l'emplacement des fichiers de configuration des sites.
|
||||
Par défaut, utiliser AUTOCONFDIR/sites si ce répertoire existe.
|
||||
--cgibindir CGIBINDIR
|
||||
Spécifier l'emplacement des scripts cgi à installer.
|
||||
Par défaut, utiliser AUTOCONFDIR/cgi-bin si ce répertoire existe.
|
||||
--wwwdir WWWDIR
|
||||
Spécifier l'emplacement des fichiers du serveur web
|
||||
Par défaut, utiliser AUTOCONFDIR/www si ce répertoire existe.
|
||||
--certsconfdir CERTSCONFDIR
|
||||
Spécifier l'emplacement des fichiers de configuration des certificats.
|
||||
Par défaut, utiliser AUTOCONFDIR/certsconf si ce répertoire existe.
|
||||
Il faut alors spécifier aussi CERTSDIR, l'emplacement des certificats à
|
||||
installer.
|
||||
--rrdir RRDIR
|
||||
Spécifier l'emplacement des fichiers de réécriture.
|
||||
Par défaut, utiliser AUTOCONFDIR/RewriteRules si ce répertoire existe.
|
||||
--no-restart
|
||||
Ne pas redémarrer apache en cas de modification de la configuration"
|
||||
}
|
||||
|
||||
eval "$(utools_local)"
|
||||
local autoconfdir certsdir confdir modulesdir sitesdir cgibindir wwwdir certsconfdir rrdir
|
||||
local restart=1
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with __apache_autoconf_display_help' \
|
||||
--confdir: confdir= \
|
||||
--modulesdir: modulesdir= \
|
||||
--sitesdir: sitesdir= \
|
||||
--cgibindir: cgibindir= \
|
||||
--wwwdir: wwwdir= \
|
||||
--certsconfdir: certsconfdir= \
|
||||
--rrdir: rrdir= \
|
||||
--no-restart restart= \
|
||||
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
||||
|
||||
if ! check_sysinfos -s linux -d debian; then
|
||||
eerror "apache_autoconf n'est supporté que sur Debian linux"
|
||||
return 1
|
||||
fi
|
||||
urequire install
|
||||
compute_apache_prefixes
|
||||
|
||||
autoconfdir="$1"
|
||||
[ -n "$autoconfdir" ] || {
|
||||
eerror "Vous devez spécifier le répertoire de base de la configuration apache"
|
||||
return 1
|
||||
}
|
||||
certsdir="$2"
|
||||
if [ -z "$confdir" -o -z "$modulesdir" -o -z "$sitesdir" \
|
||||
-o -z "$cgibindir" -o -z "$wwwdir" -o -z "$certsconfdir" \
|
||||
-o -z "$rrdir" ]; then
|
||||
[ -d "$autoconfdir" ] || {
|
||||
eerror "$autoconfdir: répertoire invalide"
|
||||
return 1
|
||||
}
|
||||
fi
|
||||
[ -n "$confdir" ] || confdir="$autoconfdir"
|
||||
[ -n "$modulesdir" ] || modulesdir="$autoconfdir/modules"
|
||||
[ -n "$sitesdir" ] || sitesdir="$autoconfdir/sites"
|
||||
[ -n "$cgibindir" ] || cgibindir="$autoconfdir/cgi-bin"
|
||||
[ -n "$wwwdir" ] || wwwdir="$autoconfdir/www"
|
||||
[ -n "$certsconfdir" ] || certsconfdir="$autoconfdir/certsconf"
|
||||
[ -n "$rrdir" ] || rrdir="$autoconfdir/RewriteRules"
|
||||
if [ -d "$certsconfdir" ]; then
|
||||
if [ -z "$certsdir" ]; then
|
||||
eerror "CERTSDIR est requis si --certsconfdir est spécifié"
|
||||
return 1
|
||||
elif [ ! -d "$certsdir" ]; then
|
||||
eerror "$certsdir: répertoire invalide"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
local modified conf
|
||||
if [ -d "$certsconfdir" ]; then
|
||||
local -a certsconfs
|
||||
local certsconf cert key ca
|
||||
etitle "Installation des certificats"
|
||||
array_lsfiles certsconfs "$certsconfdir" "*.conf"
|
||||
for certsconf in "${certsconfs[@]}"; do
|
||||
apache_resolvecert "$certsconf" "$certsdir" cert key ca || return 1
|
||||
apache_addcert -y "$cert" "$key" "$ca"
|
||||
modified=1
|
||||
done
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -d "$modulesdir" ]; then
|
||||
local -a confs
|
||||
local conf
|
||||
etitle "Installation des configurations des modules"
|
||||
array_from_lines confs "$(list_files "$modulesdir" "*.conf")"
|
||||
for conf in "${confs[@]}"; do
|
||||
estep "$conf"
|
||||
copy_update "$modulesdir/$conf" "$APACHECONFDIR/mods-available/$conf" && modified=1
|
||||
done
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -d "$rrdir" ]; then
|
||||
local -a confs
|
||||
local conf
|
||||
etitle "Installation des règles de réécriture"
|
||||
array_from_lines confs "$(list_files "$rrdir" "RewriteRules*.conf")"
|
||||
for conf in "${confs[@]}"; do
|
||||
estep "$conf"
|
||||
copy_update "$rrdir/$conf" "$APACHECONFDIR/$conf" && modified=1
|
||||
done
|
||||
eend
|
||||
fi
|
||||
|
||||
local -a enablesites disablesites
|
||||
if [ -d "$sitesdir" ]; then
|
||||
local -a confs
|
||||
local conf confname destconf certsconf tmpconf
|
||||
etitle "Installation des sites"
|
||||
array_lsfiles confs "$sitesdir" "*.conf"
|
||||
for conf in "${confs[@]}"; do
|
||||
confname="$(basename "$conf")"
|
||||
destconf="$confname"
|
||||
certsconf=
|
||||
if [ "${destconf%.ssl.conf}" != "$destconf" ]; then
|
||||
if [ -d "$certsconfdir" ]; then
|
||||
certsconf="${destconf%.ssl.conf}-certs.conf"
|
||||
else
|
||||
ewarn "$conf: fichier ignoré parce que --certsconfdir n'a pas été spécifié"
|
||||
fi
|
||||
fi
|
||||
case "$destconf" in
|
||||
default.conf) destconf=default;;
|
||||
default.ssl.conf) destconf=default-ssl;;
|
||||
esac
|
||||
|
||||
if [ -n "$certsconf" ]; then
|
||||
certsconf="$certsconfdir/$certsconf"
|
||||
if [ -f "$certsconf" ]; then
|
||||
apache_resolvecert "$certsconf" "$certsdir" cert key ca || return 1
|
||||
ac_set_tmpfile tmpconf
|
||||
sed "\
|
||||
s#@@cert@@#$APACHESSLCERTSDIR/$(basename "$cert")#g
|
||||
s#@@key@@#$APACHESSLKEYSDIR/$(basename "$key")#g
|
||||
s#@@ca@@#$APACHESSLCERTSDIR/$(basename "$ca")#g
|
||||
" <"$conf" >"$tmpconf"
|
||||
copy_update "$tmpconf" "$APACHEAVSITESDIR/$destconf"
|
||||
else
|
||||
eerror "$(ppath "$certsconf"): fichier introuvable. Il a été ignoré"
|
||||
fi
|
||||
else
|
||||
copy_update "$conf" "$APACHEAVSITESDIR/$destconf"
|
||||
fi
|
||||
enablesites=("${enablesites[@]}" "$destconf")
|
||||
modified=1
|
||||
done
|
||||
eend
|
||||
fi
|
||||
if [ -d "$confdir" ]; then
|
||||
local -a confs
|
||||
local conf
|
||||
etitle "Configuration de base"
|
||||
array_from_lines confs "$(list_files "$confdir")"
|
||||
for conf in "${confs[@]}"; do
|
||||
case "$conf" in
|
||||
modules.conf|sites.conf) continue;;
|
||||
esac
|
||||
estep "$conf"
|
||||
copy_update "$confdir/$conf" "$APACHECONFDIR/$conf" && modified=1
|
||||
done
|
||||
if [ -f "$confdir/modules.conf" ]; then
|
||||
local -a modules
|
||||
local module
|
||||
array_from_lines modules "$(<"$confdir/modules.conf" filter_conf)"
|
||||
for module in "${modules[@]}"; do
|
||||
if [ "${module#-}" != "$module" ]; then
|
||||
module="${module#-}"
|
||||
if a2dismod "$module"; then
|
||||
estep "Désactivation du module $module"
|
||||
modified=1
|
||||
fi
|
||||
else
|
||||
module="${module#+}"
|
||||
if a2enmod "$module"; then
|
||||
estep "Activation du module $module"
|
||||
modified=1
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
if [ -f "$confdir/sites.conf" ]; then
|
||||
local -a sitesconfs; local sitesconf
|
||||
array_from_lines sitesconfs "$(<"$confdir/sites.conf" filter_conf)"
|
||||
if [ ${#sitesconfs[*]} -gt 0 ]; then
|
||||
# si une configuration existe, ignorer la configuration
|
||||
# automatique
|
||||
enablesites=()
|
||||
disablesites=()
|
||||
for sitesconf in "${sitesconfs[@]}"; do
|
||||
if [ "${sitesconf#+}" != "$sitesconf" ]; then
|
||||
array_del disablesites "${sitesconf#+}"
|
||||
array_add enablesites "${sitesconf#+}"
|
||||
elif [ "${sitesconf#-}" != "$sitesconf" ]; then
|
||||
array_del enablesites "${sitesconf#-}"
|
||||
array_add disablesites "${sitesconf#-}"
|
||||
else
|
||||
array_del disablesites "$sitesconf"
|
||||
array_add enablesites "$sitesconf"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
fi
|
||||
eend
|
||||
fi
|
||||
if [ -d "$cgibindir" ]; then
|
||||
etitle "Installation des scripts CGI"
|
||||
cpdirnovcs "$cgibindir" "$CGIBINDIR"
|
||||
eend
|
||||
fi
|
||||
if [ -d "$wwwdir" ]; then
|
||||
etitle "Installation des fichiers du serveur web"
|
||||
cpdirnovcs "$wwwdir" "$HTDOCSDIR"
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -n "${enablesites[*]}" -o -n "${disablesites[*]}" ]; then
|
||||
etitle "(dés)Activation des sites"
|
||||
local site
|
||||
for site in "${enablesites[@]}"; do
|
||||
a2ensite "$site"
|
||||
done
|
||||
for site in "${disablesites[@]}"; do
|
||||
a2dissite "$site"
|
||||
done
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -n "$modified" -a -n "$restart" ]; then
|
||||
estep "Redémarrage d'apache"
|
||||
"$APACHECTL" restart
|
||||
fi
|
||||
}
|
||||
40
ulib/auto
40
ulib/auto
@@ -1,40 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Charger si possible les librairies de ulib depuis /etc/ulib. Sinon, charger
|
||||
## la librairie depuis le répertoire courant. Nécessite bash.
|
||||
##@cooked nocomments
|
||||
|
||||
# Ce fichier doit être *sourcé* depuis un répertoire ulib créé par ulibsync. Si
|
||||
# ce fichier n'est pas sourcé, alors le répertoire ulib doit être placé dans le
|
||||
# répertoire du script qui inclue ce fichier.
|
||||
|
||||
ULIBDIR="${BASH_SOURCE[0]}"
|
||||
if [ -n "$ULIBDIR" -a -f "$ULIBDIR" ]; then
|
||||
# Fichier sourcé
|
||||
ULIBDIR="$(dirname "$ULIBDIR")"
|
||||
else
|
||||
# Fichier non sourcé. Tout exprimer par rapport au script courant
|
||||
ULIBDIR="$(dirname "$0")/ulib"
|
||||
fi
|
||||
|
||||
function __check_ulib_version() {
|
||||
# tester si la version ulib du système est plus récente que la version ulib
|
||||
# du répertoire courant
|
||||
local thisver=0 sysver=0
|
||||
[ -f "$ULIBDIR/.ulib_version" ] && thisver="$(<"$ULIBDIR/.ulib_version")"
|
||||
[ -f "/etc/.ulib_version" ] && sysver="$(<"/etc/.ulib_version")"
|
||||
[ $sysver -gt $thisver ]
|
||||
}
|
||||
|
||||
if [ -f /etc/ulib ] && __check_ulib_version; then
|
||||
unset -f __check_ulib_version
|
||||
. /etc/ulib
|
||||
elif [ -f "$ULIBDIR/ulib" ]; then
|
||||
unset -f __check_ulib_version
|
||||
. "$ULIBDIR/ulib"
|
||||
else
|
||||
echo "error: Unable to find neither $ULIBDIR/ulib nor /etc/ulib" 1>&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
uprovide auto
|
||||
urequire DEFAULTS
|
||||
13
ulib/bash
13
ulib/bash
@@ -1,13 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Relancer le script avec bash si nécessaire
|
||||
##@cooked nocomments
|
||||
if [ `basename "${BASH:-sh}"` = "sh" ]; then
|
||||
bash=`which bash 2>/dev/null`
|
||||
for bash in "$bash" /bin/bash /usr/bin/bash /usr/local/bin/bash; do
|
||||
if [ -x "$bash" ]; then
|
||||
exec "$bash" "$0" "$@"
|
||||
fi
|
||||
done
|
||||
echo "error: this script requires bash"
|
||||
exit 1
|
||||
fi
|
||||
1374
ulib/bash_completion
1374
ulib/bash_completion
File diff suppressed because it is too large
Load Diff
73
ulib/cgi
73
ulib/cgi
@@ -1,73 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonction de support pour CGI
|
||||
##@cooked nocomments
|
||||
uprovide cgi
|
||||
|
||||
function is_cgi() {
|
||||
# Tester si on est lancé comme un script CGI
|
||||
[ -n "$GATEWAY_INTERFACE" ]
|
||||
}
|
||||
|
||||
function ctype_header() {
|
||||
# Générer une en-tête Content-Type: avec la valeur $1[=text/html]
|
||||
local ctype="$1"
|
||||
[ -n "$ctype" ] || ctype="text/html"
|
||||
if [[ "$ctype" == text/* ]]; then
|
||||
[[ "$ctype" == *\;* ]] || ctype="$ctype; charset=utf-8"
|
||||
fi
|
||||
echo "Content-Type: $ctype"
|
||||
}
|
||||
|
||||
function cdisp_header() {
|
||||
# Générer une en-tête Content-Disposition: avec le type $2[=attachment] et
|
||||
# le nom de fichier $1[=result]
|
||||
local filename="${1:-result}" disp="${2:-attachment}"
|
||||
echo "Content-Disposition: $disp; filename=$filename"
|
||||
}
|
||||
|
||||
function nocache_header() {
|
||||
# Générer des en-têtes qui désactivent la mise en cache du contenu
|
||||
echo "Cache-Control: private, no-cache, no-store, must-revalidate, max-age=0"
|
||||
echo "Pragma: no-cache"
|
||||
echo "Expires: Thu, 01 Jan 1970 00:00:00 GMT"
|
||||
}
|
||||
|
||||
function cgicontent() {
|
||||
# Générer les en-têtes nécessaire avant de servir le contenu.
|
||||
# $1(=text/html) est le type de contenu. S'il faut servir le contenu avec
|
||||
# une disposition "attachment", $2 est le nom de fichier à proposer à
|
||||
# l'utilisateur. Si $3 est spécifié, c'est le chemin vers le fichier dont le
|
||||
# contenu doit être servi.
|
||||
# $4..* sont des en-têtes supplémentaires à rajouter
|
||||
local ctype="$1" filename="$2" contentfile="$3"; shift; shift; shift
|
||||
local header
|
||||
|
||||
ctype_header "$ctype"
|
||||
[ -n "$filename" ] && cdisp_header "$filename"
|
||||
for header in "$@"; do
|
||||
echo "$header"
|
||||
done
|
||||
echo ""
|
||||
[ -f "$contentfile" ] && cat "$contentfile"
|
||||
}
|
||||
|
||||
function cgicontent_nocache() {
|
||||
# Générer les en-têtes nécessaire avant de servir le contenu. Rajouter les
|
||||
# entêtes pour désactiver la mise en cache.
|
||||
# $1(=text/html) est le type de contenu. S'il faut servir le contenu avec
|
||||
# une disposition "attachment", $2 est le nom de fichier à proposer à
|
||||
# l'utilisateur. Si $3 est spécifié, c'est le chemin vers le fichier dont le
|
||||
# contenu doit être servi.
|
||||
# $4..* sont des en-têtes supplémentaires à rajouter
|
||||
local ctype="$1" filename="$2" contentfile="$3"; shift; shift; shift
|
||||
local header
|
||||
|
||||
ctype_header "$ctype"
|
||||
[ -n "$filename" ] && cdisp_header "$filename"
|
||||
nocache_header
|
||||
for header in "$@"; do
|
||||
echo "$header"
|
||||
done
|
||||
echo ""
|
||||
[ -f "$contentfile" ] && cat "$contentfile"
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonction de support pour cgiupload
|
||||
##@cooked nocomments
|
||||
##@require ulib
|
||||
uprovide cgiupload
|
||||
urequire ulib
|
||||
|
||||
function cgiupload() { "$ULIBDIR/support/cgiupload.py" "$@"; }
|
||||
378
ulib/compat
378
ulib/compat
@@ -1,378 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
# Code de support pour les architectures autre que Linux
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
uprovide compat
|
||||
urequire base sysinfos
|
||||
|
||||
if check_sysinfos -s macosx; then
|
||||
# implémentation en bash des variantes de readlink
|
||||
function __rlnp() { local p="$1" np f; [ "${p#/}" == "$p" ] && p="$(pwd)/$p"; while [[ "$p" == *//* ]]; do p="${p//\/\///}"; done; p="${p%/}"; p="${p#/}"; np=; while [ -n "$p" ]; do if [[ "$p" == */* ]]; then f="${p%%/*}"; p="${p#*/}"; else f="$p"; p=; fi; if [ "$f" == . ]; then :; elif [ "$f" == .. ]; then if [[ "$np" == */* ]]; then np="${np%/*}"; else np=; fi; else [ -n "$np" ] && np="$np/"; np="$np$f"; fi; done; echo "/$np"; }
|
||||
function readlinkm() { local p="$(__rlnp "$1")" np n; while [ -n "$p" ]; do local max=50; while [ -L "$p" -a $max -gt 0 ]; do n="$(readlink "$p")"; if [ "${n#/}" != "$n" ]; then p="$n"; else p="${p%/*}/$n"; fi; p="$(__rlnp "$p")"; max=$(($max-1)); done; [ -n "$np" ] && np="/$np"; if [[ "$p" == */* ]]; then np="${p##*/}$np"; p="${p%/*}"; else np="$p$np"; p=; fi; done; echo "/$np"; }
|
||||
# la version de awk livrée sur macosx est braindead
|
||||
function _nl2lf() { awk '{ sub(/\r$/, ""); gsub(/\r/, "\n"); print }'; }
|
||||
function _nl2crlf() { _nl2lf | awk '{ print $0 "\r" }'; }
|
||||
function _nl2cr() { _nl2lf | awk 'BEGIN { ORS="" } { print $0 "\r" }'; }
|
||||
# sed -i demande un argument
|
||||
function sedi() { sed -i '' "$@"; }
|
||||
|
||||
## gestion des arguments
|
||||
function __po_check_options() {
|
||||
# émuler gnu getopt puisque qu'il n'est pas disponible sur cette
|
||||
# plateforme
|
||||
local -a options args
|
||||
local option value flag
|
||||
if [ "${opts_#+}" != "$opts_" ]; then
|
||||
# Arrêter au premier argument qui n'est pas une option
|
||||
while [ -n "$*" ]; do
|
||||
if [ "$1" == "--" ]; then
|
||||
shift
|
||||
break
|
||||
elif [[ "$1" == --* ]]; then
|
||||
# option longue
|
||||
option="${1%%=*}"
|
||||
if flag="$(array_find options_ "$option" flags_)"; then
|
||||
if [[ "$flag" == ::* ]]; then
|
||||
# valeur optionnelle
|
||||
if [[ "$1" == *=* ]]; then
|
||||
value="${1#--*=}"
|
||||
else
|
||||
value=
|
||||
fi
|
||||
shift
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
elif [[ "$flag" == :* ]]; then
|
||||
# valeur obligatoire
|
||||
if [[ "$1" == *=* ]]; then
|
||||
value="${1#--*=}"
|
||||
shift
|
||||
elif [ $# -gt 1 ]; then
|
||||
value="$2"
|
||||
shift 2
|
||||
else
|
||||
echo "option requires an argument: $option"
|
||||
return 1
|
||||
fi
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
else
|
||||
# pas de valeur
|
||||
shift
|
||||
options=("${options[@]}" "$option")
|
||||
fi
|
||||
else
|
||||
echo "invalid option: $1"
|
||||
return 1
|
||||
fi
|
||||
|
||||
elif [[ "$1" == -* ]]; then
|
||||
# option courte
|
||||
option="${1:0:2}"
|
||||
if flag="$(array_find options_ "$option" flags_)"; then
|
||||
if [[ "$flag" == ::* ]]; then
|
||||
# valeur optionnelle
|
||||
value="${1:2}"
|
||||
shift
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
elif [[ "$flag" == :* ]]; then
|
||||
# valeur obligatoire
|
||||
if [[ -n "${1:2}" ]]; then
|
||||
value="${1:2}"
|
||||
shift
|
||||
elif [ $# -gt 1 ]; then
|
||||
value="$2"
|
||||
shift 2
|
||||
else
|
||||
echo "option requires an argument: $option"
|
||||
return 1
|
||||
fi
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
else
|
||||
# pas de valeur
|
||||
shift
|
||||
options=("${options[@]}" "$option")
|
||||
fi
|
||||
else
|
||||
echo "invalid option: $1"
|
||||
return 1
|
||||
fi
|
||||
|
||||
else
|
||||
# ce n'est pas une option, on arrête là
|
||||
break
|
||||
fi
|
||||
done
|
||||
args=("$@")
|
||||
elif [ "${opts_#-}" != "$opts_" ]; then
|
||||
# Les options peuvent être situées partout sur la ligne de commande,
|
||||
# mais les arguments ne sont pas réordonnés.
|
||||
while [ -n "$*" ]; do
|
||||
if [ "$1" == "--" ]; then
|
||||
shift
|
||||
break
|
||||
elif [[ "$1" == --* ]]; then
|
||||
# option longue
|
||||
option="${1%%=*}"
|
||||
if flag="$(array_find options_ "$option" flags_)"; then
|
||||
if [[ "$flag" == ::* ]]; then
|
||||
# valeur optionnelle
|
||||
if [[ "$1" == *=* ]]; then
|
||||
value="${1#--*=}"
|
||||
else
|
||||
value=
|
||||
fi
|
||||
shift
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
elif [[ "$flag" == :* ]]; then
|
||||
# valeur obligatoire
|
||||
if [[ "$1" == *=* ]]; then
|
||||
value="${1#--*=}"
|
||||
shift
|
||||
elif [ $# -gt 1 ]; then
|
||||
value="$2"
|
||||
shift 2
|
||||
else
|
||||
echo "option requires an argument: $option"
|
||||
return 1
|
||||
fi
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
else
|
||||
# pas de valeur
|
||||
shift
|
||||
options=("${options[@]}" "$option")
|
||||
fi
|
||||
else
|
||||
echo "invalid option: $1"
|
||||
return 1
|
||||
fi
|
||||
|
||||
elif [[ "$1" == -* ]]; then
|
||||
# option courte
|
||||
option="${1:0:2}"
|
||||
if flag="$(array_find options_ "$option" flags_)"; then
|
||||
if [[ "$flag" == ::* ]]; then
|
||||
# valeur optionnelle
|
||||
value="${1:2}"
|
||||
shift
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
elif [[ "$flag" == :* ]]; then
|
||||
# valeur obligatoire
|
||||
if [[ -n "${1:2}" ]]; then
|
||||
value="${1:2}"
|
||||
shift
|
||||
elif [ $# -gt 1 ]; then
|
||||
value="$2"
|
||||
shift 2
|
||||
else
|
||||
echo "option requires an argument: $option"
|
||||
return 1
|
||||
fi
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
else
|
||||
# pas de valeur
|
||||
shift
|
||||
options=("${options[@]}" "$option")
|
||||
fi
|
||||
else
|
||||
echo "invalid option: $1"
|
||||
return 1
|
||||
fi
|
||||
|
||||
else
|
||||
# ce n'est pas une option, mais l'ajouter aux options parce
|
||||
# qu'on ne réordonne pas
|
||||
options=("${options[@]}" "$1")
|
||||
shift
|
||||
fi
|
||||
done
|
||||
args=("$@")
|
||||
else
|
||||
# Les options peuvent être situées partout sur la ligne de commande.
|
||||
# Les arguments sont réordonnés pour placer les options en premier,
|
||||
# séparées des non-options par '--'
|
||||
while [ -n "$*" ]; do
|
||||
if [ "$1" == "--" ]; then
|
||||
shift
|
||||
break
|
||||
elif [[ "$1" == --* ]]; then
|
||||
# option longue
|
||||
option="${1%%=*}"
|
||||
if flag="$(array_find options_ "$option" flags_)"; then
|
||||
if [[ "$flag" == ::* ]]; then
|
||||
# valeur optionnelle
|
||||
if [[ "$1" == *=* ]]; then
|
||||
value="${1#--*=}"
|
||||
else
|
||||
value=
|
||||
fi
|
||||
shift
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
elif [[ "$flag" == :* ]]; then
|
||||
# valeur obligatoire
|
||||
if [[ "$1" == *=* ]]; then
|
||||
value="${1#--*=}"
|
||||
shift
|
||||
elif [ $# -gt 1 ]; then
|
||||
value="$2"
|
||||
shift 2
|
||||
else
|
||||
echo "option requires an argument: $option"
|
||||
return 1
|
||||
fi
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
else
|
||||
# pas de valeur
|
||||
shift
|
||||
options=("${options[@]}" "$option")
|
||||
fi
|
||||
else
|
||||
echo "invalid option: $1"
|
||||
return 1
|
||||
fi
|
||||
|
||||
elif [[ "$1" == -* ]]; then
|
||||
# option courte
|
||||
option="${1:0:2}"
|
||||
if flag="$(array_find options_ "$option" flags_)"; then
|
||||
if [[ "$flag" == ::* ]]; then
|
||||
# valeur optionnelle
|
||||
value="${1:2}"
|
||||
shift
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
elif [[ "$flag" == :* ]]; then
|
||||
# valeur obligatoire
|
||||
if [[ -n "${1:2}" ]]; then
|
||||
value="${1:2}"
|
||||
shift
|
||||
elif [ $# -gt 1 ]; then
|
||||
value="$2"
|
||||
shift 2
|
||||
else
|
||||
echo "option requires an argument: $option"
|
||||
return 1
|
||||
fi
|
||||
options=("${options[@]}" "$option" "$value")
|
||||
else
|
||||
# pas de valeur
|
||||
shift
|
||||
options=("${options[@]}" "$option")
|
||||
fi
|
||||
else
|
||||
echo "invalid option: $1"
|
||||
return 1
|
||||
fi
|
||||
|
||||
else
|
||||
# ce n'est pas une option, l'ajouter aux arguments
|
||||
args=("${args[@]}" "$1")
|
||||
shift
|
||||
fi
|
||||
done
|
||||
args=("${args[@]}" "$@")
|
||||
fi
|
||||
quoted_args "${options[@]}" -- "${args[@]}"
|
||||
return 0
|
||||
}
|
||||
|
||||
## gestion des dates
|
||||
function __pd_isleap() {
|
||||
# tester si l'année $1 est bissextile
|
||||
[ $(($1 % 4)) -eq 0 -a \( $(($1 % 100)) -ne 0 -o $(($1 % 400)) -eq 0 \) ]
|
||||
}
|
||||
function __pd_fix_month() {
|
||||
# soit $1 le nom d'une variable contenant une année, et $2 le nom d'une
|
||||
# variable contenant un mois, normaliser les valeurs de ces variables, en
|
||||
# ajustant si nécessaire les valeurs.
|
||||
local __pdfm_y="${!1}" __pdfm_m="${!2}"
|
||||
let __pdfm_m=$__pdfm_m-1
|
||||
while [ $__pdfm_m -gt 11 ]; do
|
||||
let __pdfm_m=$__pdfm_m-12
|
||||
let __pdfm_y=$__pdfm_y+1
|
||||
done
|
||||
while [ $__pdfm_m -lt 0 ]; do
|
||||
let __pdfm_m=$__pdfm_m+12
|
||||
let __pdfm_y=$__pdfm_y-1
|
||||
done
|
||||
let __pdfm_m=$__pdfm_m+1
|
||||
eval "$1=$__pdfm_y; $2=$__pdfm_m"
|
||||
}
|
||||
__PD_MONTHDAYS=(0 31 28 31 30 31 30 31 31 30 31 30 31)
|
||||
function __pd_monthdays() {
|
||||
# calculer le nombre de jours du mois $2 de l'année $1
|
||||
local y="$1" m="$2" mds
|
||||
__pd_fix_month y m
|
||||
mds="${__PD_MONTHDAYS[$m]}"
|
||||
[ "$m" -eq 2 ] && __pd_isleap "$y" && let mds=$mds+1
|
||||
echo $mds
|
||||
}
|
||||
function __pd_fix_day() {
|
||||
# soit $1 le nom d'une variable contenant une année, $2 le nom d'une
|
||||
# variable contenant un mois et $3 le nom d'une variable contenant un jour,
|
||||
# normaliser les valeurs de ces variables, en ajustant si nécessaire les
|
||||
# valeurs. cette fonction assume que la valeur de $2 est déjà corrigée avec
|
||||
# __pd_fix_month
|
||||
local __pdfd_y="${!1}" __pdfd_m="${!2}" __pdfd_d="${!3}" __pdfd_mds
|
||||
let __pdfd_d=$__pdfd_d-1
|
||||
let __pdfd_mds=$(__pd_monthdays $__pdfd_y $__pdfd_m)
|
||||
while [ $__pdfd_d -gt $(($__pdfd_mds-1)) ]; do
|
||||
let __pdfd_d=$__pdfd_d-$__pdfd_mds
|
||||
let __pdfd_m=$__pdfd_m+1
|
||||
__pd_fix_month __pdfd_y __pdfd_m
|
||||
let __pdfd_mds=$(__pd_monthdays $__pdfd_y $__pdfd_m)
|
||||
done
|
||||
while [ $__pdfd_d -lt 0 ]; do
|
||||
let __pdfd_m=$__pdfd_m-1
|
||||
__pd_fix_month __pdfd_y __pdfd_m
|
||||
let __pdfd_d=$__pdfd_d-$(__pd_monthdays $__pdfd_y $__pdfd_m)
|
||||
done
|
||||
let __pdfd_d=$__pdfd_d+1
|
||||
eval "$1=$__pdfd_y; $2=$__pdfd_m; $3=$__pdfd_d"
|
||||
}
|
||||
function __pd_fix_date() {
|
||||
# soit $1 le nom d'une variable contenant une année, $2 le nom d'une
|
||||
# variable contenant un mois et $3 le nom d'une variable contenant un jour,
|
||||
# normaliser les valeurs de ces variables, en ajustant si nécessaire les
|
||||
# valeurs.
|
||||
local __pdf_y="${!1}" __pdf_m="${!2}" __pdf_d="${!3}"
|
||||
}
|
||||
function parse_date() {
|
||||
local value="$1" type="${2:-date}"
|
||||
local d m y
|
||||
# date courante
|
||||
eval "$(date +%d/%m/%Y | awk -F/ '{
|
||||
print "d=" $1 "; m=" $2 "; y=" $3
|
||||
}')"
|
||||
if [ "${value#+}" != "$value" ]; then
|
||||
# ajouter $1 jours
|
||||
d="$(($d+${value#+}))"
|
||||
else
|
||||
# parser une nouvelle date, en complétant avec les informations de la
|
||||
# date du jour
|
||||
eval "$(<<<"$value" awkrun FS=/ dn="$dn" mn="$mn" yn="$yn" type="$type" '{
|
||||
d = $1 + 0; if (d < 1) d = dn + 0;
|
||||
m = $2 + 0; if (m < 1) m = mn + 0;
|
||||
if ($3 == "") y = yn + 0;
|
||||
else { y = $3 + 0; if (y < 100) y = y + 2000; }
|
||||
print "d=" d "; m=" m "; y=" y
|
||||
}')"
|
||||
fi
|
||||
# ensuite corriger les champs si nécessaire
|
||||
__pd_fix_month y m
|
||||
__pd_fix_day y m d
|
||||
# enfin formater la date selon les volontés de l'utilisateur
|
||||
case "$type" in
|
||||
d|date)
|
||||
awkrun d="$d" m="$m" y="$y" 'BEGIN { printf "%02i/%02i/%04i\n", d, m, y }'
|
||||
;;
|
||||
l|ldap)
|
||||
awkrun d="$d" m="$m" y="$y" 'BEGIN { printf "%04i%02i%02i000000+0400\n", y, m, d }'
|
||||
;;
|
||||
esac
|
||||
}
|
||||
function myhost() {
|
||||
hostname
|
||||
}
|
||||
function myhostname() {
|
||||
hostname -s
|
||||
}
|
||||
fi
|
||||
746
ulib/conf
746
ulib/conf
@@ -1,746 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion des fichiers de configuration
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide conf
|
||||
urequire base
|
||||
|
||||
################################################################################
|
||||
# Gestion des fichiers de configuration où les directives sont de la forme
|
||||
# 'name=value' et où les commentaires débutent par '#'. C'est typiquement le cas
|
||||
# des scripts de profile du shell
|
||||
|
||||
# Note: #@$*! de MacOS X qui ne supporte pas \(expr\)\? dans sed. Toutes les
|
||||
# lignes sed de la forme '/prefix\(expr\)\?suffix/s/from/to/g' sont remplacées
|
||||
# par une double expression
|
||||
# '/prefixexprsuffix/s/from/to/g
|
||||
# /prefixsuffix/s/from/to/g'
|
||||
|
||||
function conf_enable() {
|
||||
# Dans le fichier de configuration $1, activer les paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name[=value]
|
||||
# Dans tous les cas, toutes les directives de ce nom sont recherchées et
|
||||
# décommentées. Si value est précisée, les directives sont mises à jour. Si
|
||||
# la directive ne figure pas dans le fichier, elle y est rajoutée à la fin
|
||||
# avec la valeur spécifiée.
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value to
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
# Essayer d'abord de décommenter la valeur dans le fichier
|
||||
if quietgrep "^[ $TAB]*##*[ $TAB]*\(export[ $TAB]*\)\?$name[ $TAB]*=" "$conf"; then
|
||||
sedi "\
|
||||
/^[ $TAB]*##*[ $TAB]*export[ $TAB]*$name[ $TAB]*=/s/^[ $TAB]*##*\([ $TAB]*export[ $TAB]*\)/\\1/g
|
||||
/^[ $TAB]*##*[ $TAB]*$name[ $TAB]*=/s/^[ $TAB]*##*//g
|
||||
" "$conf"
|
||||
modified=0
|
||||
elif ! quietgrep "^[ $TAB]*\(export[ $TAB]*\)\?$name[ $TAB]*=" "$conf"; then
|
||||
echo "$name=" >>"$conf"
|
||||
modified=0
|
||||
fi
|
||||
if [ "$name" != "$param" ]; then
|
||||
# Ensuite, mettre à jour le fichier avec la valeur spécifiée
|
||||
to="$(quote_seds "$value")"
|
||||
sedi "\
|
||||
/^[ $TAB]*export[ $TAB]*$name[ $TAB]*=/s/^\([ $TAB]*export[ $TAB]*$name[ $TAB]*=[ $TAB]*\).*\$/\\1$to/
|
||||
/^[ $TAB]*$name[ $TAB]*=/s/^\([ $TAB]*$name[ $TAB]*=[ $TAB]*\).*\$/\\1$to/
|
||||
" "$conf"
|
||||
modified=0
|
||||
fi
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
|
||||
function conf_enableq() {
|
||||
# Comme conf_enable(), mais s'assure que les valeurs sont quotées dans le
|
||||
# fichier. Ceci permet de stocker des valeurs avec des espaces ou des
|
||||
# caractères spéciaux.
|
||||
local args arg name value
|
||||
args=("$1"); shift
|
||||
for arg in "$@"; do
|
||||
splitvar "$arg" name value
|
||||
array_add args "$name=$(quoted_arg "$value")"
|
||||
done
|
||||
conf_enable "${args[@]}"
|
||||
}
|
||||
|
||||
function conf_disable() {
|
||||
# Dans le fichier de configuration $1, désactiver les paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name[=value]
|
||||
# Toutes les directives de ce noms sont recherchées et commentées. La valeur
|
||||
# si elle est spécifiée, est ignorée. Si la directive ne figure pas dans le
|
||||
# fichier, c'est un NOP.
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value from0 from1
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
# Essayer simplement de commenter la directive dans le fichier
|
||||
from0="^[ $TAB]*export[ $TAB]*$name[ $TAB]*="
|
||||
from1="^[ $TAB]*$name[ $TAB]*="
|
||||
if [ "$name" != "$param" ]; then
|
||||
from0="$from0$(quote_seds "$value")\$"
|
||||
from1="$from1$(quote_seds "$value")\$"
|
||||
fi
|
||||
if quietgrep "$from" "$conf"; then
|
||||
sedi "\
|
||||
/$from0/s/^/#/g
|
||||
/$from1/s/^/#/g
|
||||
" "$conf"
|
||||
modified=0
|
||||
fi
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
|
||||
CONF_APPEND_SEP=:
|
||||
|
||||
function conf_append() {
|
||||
# Dans le fichier de configuration $1, augmenter les valeurs des variables
|
||||
# correspondant aux paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une variable du fichier de
|
||||
# configuration, et doit être de la forme name=value
|
||||
# Une ligne 'name="${name:+$name:}$value"' est générée à la fin du fichier
|
||||
# de configuration.
|
||||
# Par défaut, le séparateur CONF_APPEND_SEP vaut ':', mais il est possible
|
||||
# de changer cette valeur, de façon globale
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value from
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
echo "$name=\"\${$name:+\$$name$CONF_APPEND_SEP}$(quote_arg "$value")\"" >>"$conf"
|
||||
modified=0
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
|
||||
|
||||
function conf_array_append() {
|
||||
# Dans le fichier de configuration $1, augmenter les valeurs des variables
|
||||
# de tableau correspondant aux paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une variable du fichier de
|
||||
# configuration, et doit être de la forme name=value
|
||||
# Une ligne name=("${name[@]}" "$value") est générée à la fin du fichier de
|
||||
# configuration
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value from
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
if quietgrep "^[ $TAB]*\(export[ $TAB]*\)\?$name=(" "$conf"; then
|
||||
# variable déjà existante
|
||||
[ "$name" != "$param" ] || continue
|
||||
echo "$name=(\"\${$name[@]}\" $(quoted_arg "$value"))" >>"$conf"
|
||||
else
|
||||
# nouvelle variable
|
||||
if [ "$name" != "$param" ]; then
|
||||
echo "$name=($(quoted_arg "$value"))" >>"$conf"
|
||||
else
|
||||
echo "$name=()" >>"$conf"
|
||||
fi
|
||||
fi
|
||||
modified=0
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
|
||||
function conf_check() {
|
||||
# Dans le fichier de configuration $1, tester si tous les paramètres $2..*
|
||||
# sont présents.
|
||||
# Chaque argument de cette fonction correspond à une variable du fichier de
|
||||
# configuration, et doit être de la forme name[=value]
|
||||
# Si une valeur est spécifiée, vérifier que le fichier contient la valeur
|
||||
# correspondante. Sinon, tester uniquement la présence de la directive.
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local param name value from
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
from="^[ $TAB]*\(export[ $TAB]*\)\?$name[ $TAB]*="
|
||||
if [ "$name" != "$param" ]; then
|
||||
from="$from$(quote_seds "$value")\$"
|
||||
fi
|
||||
quietgrep "$from" "$conf" || return 1
|
||||
done
|
||||
return 0
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Gestion des fichiers de configuration où les directives sont de la forme 'name
|
||||
# value', et où les commentaires débutent par '#'. C'est typiquement le cas des
|
||||
# fichiers de configuration d'apache
|
||||
|
||||
function aconf_enable() {
|
||||
# Dans le fichier de configuration $1, activer les paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name[=value]
|
||||
# Toutes les directives de ce nom sont recherchées et décommentées, et la
|
||||
# valeur mise à jour. Si la directive ne figure pas dans le fichier, elle y
|
||||
# est rajoutée à la fin. A cause du mode opératoire, cette fonction ne
|
||||
# convient pas pour les directives dont le nom peut apparaitre plusieurs
|
||||
# fois dans le fichier
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value to
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
# Essayer d'abord de décommenter la valeur dans le fichier
|
||||
if quietgrep "^[ $TAB]*##*[ $TAB]*$name[ $TAB]*" "$conf"; then
|
||||
sedi "/^[ $TAB]*##*[ $TAB]*$name[ $TAB]*/s/^[ $TAB]*##*\([ $TAB]*\)/\\1/g" "$conf"
|
||||
modified=0
|
||||
elif ! quietgrep "^[ $TAB]*$name[ $TAB]*" "$conf"; then
|
||||
echo "$name" >>"$conf"
|
||||
modified=0
|
||||
fi
|
||||
if [ "$name" != "$param" ]; then
|
||||
# Ensuite, mettre à jour le fichier avec la valeur spécifiée
|
||||
to="$(quote_seds "$value")"
|
||||
sedi "\
|
||||
/^[ $TAB]*$name[ $TAB][ $TAB]*/s/^\([ $TAB]*$name[ $TAB]*\).*$/\\1$to/
|
||||
/^[ $TAB]*$name\$/s/^\([ $TAB]*$name\)\$/\\1 $to/" "$conf"
|
||||
modified=0
|
||||
fi
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
|
||||
function aconf_disable() {
|
||||
# Dans le fichier de configuration $1, désactiver les paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name[=value]
|
||||
# Si la valeur est précisée, la directive correspondant à ce nom et cette
|
||||
# valeur est recherchée et commentée. Sinon, toutes les directives de ce
|
||||
# noms sont recherchées et commentées. Si la directive ne figure pas dans le
|
||||
# fichier, c'est un NOP.
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value from
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
# Essayer simplement de commenter la valeur dans le fichier
|
||||
from="^[ $TAB]*$name[ $TAB]*"
|
||||
if [ "$name" != "$param" ]; then
|
||||
from="$from$(quote_seds "$value")\$"
|
||||
fi
|
||||
if quietgrep "$from" "$conf"; then
|
||||
sedi "/$from/"'s/^/#/g' "$conf"
|
||||
modified=0
|
||||
fi
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
|
||||
function aconf_append() {
|
||||
# Dans le fichier de configuration $1, ajouter des directives correspondant
|
||||
# aux paramètres $2..*
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name=value
|
||||
# Une ligne '$name $value' est ajoutée à la fin du fichier de configuration
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
|
||||
local param name value from
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
echo "$name${value:+ $value}" >>"$conf"
|
||||
modified=0
|
||||
done
|
||||
|
||||
unfix_mode "$conf" "$mode"
|
||||
return $modified
|
||||
}
|
||||
function aconf_array_append() { aconf_append "$@"; }
|
||||
|
||||
function aconf_check() {
|
||||
# Dans le fichier de configuration $1, tester si tous les paramètres $2..*
|
||||
# sont présents.
|
||||
# Chaque argument de cette fonction correspond à une variable du fichier de
|
||||
# configuration, et doit être de la forme name[=value]
|
||||
# Si une valeur est spécifiée, vérifier que le fichier contient la valeur
|
||||
# correspondante. Sinon, tester uniquement la présence de la directive.
|
||||
local conf="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local param name value from
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
from="^[ $TAB]*$name[ $TAB]*"
|
||||
if [ "$name" != "$param" ]; then
|
||||
from="$from$(quote_seds "$value")\$"
|
||||
fi
|
||||
quietgrep "$from" "$conf" || return 1
|
||||
done
|
||||
return 0
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Gestion des fichiers de configuration où les directives sont placées dans des
|
||||
# sections identifiées par une chaine de la forme [section]. Les directives sont
|
||||
# de la forme 'name=value', et les commentaires débutent par '#' ou ';'. C'est
|
||||
# typiquement le cas des fichiers de configuration de MySQL (my.cnf) et de PHP
|
||||
# (php.ini)
|
||||
|
||||
function mconf_enable() {
|
||||
# Dans le fichier de configuration $1, activer les paramètres $3..* de la
|
||||
# section $2
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name[=value]
|
||||
# Toutes les directives de ce nom sont recherchées et décommentées, et la
|
||||
# valeur mise à jour. Si la directive ne figure pas dans le fichier, elle y
|
||||
# est rajoutée à la fin. A cause du mode opératoire, cette fonction ne
|
||||
# convient pas pour les directives dont le nom peut apparaitre plusieurs
|
||||
# fois dans le fichier
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
# Cette fonction nécessite gawk et ignore la locale
|
||||
local conf="$1"; shift
|
||||
local section="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local script i param name value
|
||||
script="BEGIN {
|
||||
modified = 1
|
||||
section = $(quoted_awk "$section")
|
||||
in_section = 0"
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
script="$script
|
||||
names[$i] = $(quoted_awk "$name")"
|
||||
if [ "$name" != "$param" ]; then
|
||||
script="$script
|
||||
hasvalues[$i] = 1
|
||||
values[$i] = $(quoted_awk "$value")"
|
||||
else
|
||||
script="$script
|
||||
hasvalues[$i] = 0
|
||||
values[$i] = \"\""
|
||||
fi
|
||||
script="$script
|
||||
seen[$i] = 0"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script"'
|
||||
}
|
||||
function write_unseen(write_section, wrote_section) {
|
||||
for (i in seen) {
|
||||
if (!seen[i]) {
|
||||
if (write_section && !wrote_section) {
|
||||
print "[" section "]"
|
||||
wrote_section = 1
|
||||
}
|
||||
print names[i] "=" values[i]
|
||||
seen[i] = 1
|
||||
modified = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
/^\[.*\]/ {
|
||||
was_in_section = in_section
|
||||
match($0, /^\[(.*)\]/, vs)
|
||||
in_section = (vs[1] == section)
|
||||
if (!in_section && was_in_section) {
|
||||
write_unseen()
|
||||
}
|
||||
}
|
||||
'
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
script="$script
|
||||
in_section && \$0 ~ /^[ $TAB]*((##*|;;*)[ $TAB]*)?$name[ $TAB]*=/ {
|
||||
\$0 = gensub(/^[ $TAB]*(##*|;;*)[ $TAB]*($name[ $TAB]*=)/, \"\\\\2\", \"\")
|
||||
if (hasvalues[$i]) {
|
||||
\$0 = gensub(/^([ $TAB]*$name[ $TAB]*=[ $TAB]*).*\$/, \"\\\\1\" values[$i], \"\")
|
||||
}
|
||||
seen[$i] = 1
|
||||
modified = 0
|
||||
}"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script
|
||||
{ print }
|
||||
END {
|
||||
write_unseen(!in_section)
|
||||
exit modified
|
||||
}"
|
||||
|
||||
local tmpfile; ac_set_tmpfile tmpfile
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
if <"$conf" >"$tmpfile" cawk "$script"; then
|
||||
cat "$tmpfile" >"$conf"
|
||||
modified=0
|
||||
fi
|
||||
unfix_mode "$conf" "$mode"
|
||||
ac_clean "$tmpfile"
|
||||
return $modified
|
||||
}
|
||||
|
||||
function mconf_disable() {
|
||||
# Dans le fichier de configuration $1, désactiver les paramètres $3..* de la
|
||||
# section $2.
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name[=value]
|
||||
# Si la valeur est précisée, la directive correspondant à ce nom et cette
|
||||
# valeur est recherchée et commentée. Sinon, toutes les directives de ce
|
||||
# noms sont recherchées et commentées. Si la directive ne figure pas dans le
|
||||
# fichier, c'est un NOP.
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
# Cette fonction nécessite gawk et ignore la locale
|
||||
local conf="$1"; shift
|
||||
local section="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local script match
|
||||
script="BEGIN {
|
||||
modified = 1
|
||||
section = $(quoted_awk "$section")
|
||||
in_section = 0
|
||||
"
|
||||
local param name value
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
match="${match:+$match || }\$0 ~ /^[ $TAB]*$name[ $TAB]*="
|
||||
if [ "$name" != "$param" ]; then
|
||||
match="$match[ $TAB]*$(quote_seds "$value")\$"
|
||||
fi
|
||||
match="$match/"
|
||||
done
|
||||
script="$script
|
||||
}"'
|
||||
/^\[.*\]/ {
|
||||
match($0, /^\[(.*)\]/, vs)
|
||||
in_section = (vs[1] == section)
|
||||
}
|
||||
in_section && ('"$match"') {
|
||||
$0 = "#" $0
|
||||
modified = 0
|
||||
}
|
||||
{ print }
|
||||
END {
|
||||
exit modified
|
||||
}
|
||||
'
|
||||
|
||||
local tmpfile; ac_set_tmpfile tmpfile
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
if <"$conf" >"$tmpfile" cawk "$script"; then
|
||||
cat "$tmpfile" >"$conf"
|
||||
modified=0
|
||||
fi
|
||||
unfix_mode "$conf" "$mode"
|
||||
ac_clean "$tmpfile"
|
||||
return $modified
|
||||
}
|
||||
|
||||
function mconf_append() {
|
||||
# Dans le fichier de configuration $1, ajouter des directives correspondant
|
||||
# aux paramètres $3..* dans la section $2
|
||||
# Chaque argument de cette fonction correspond à une directive du fichier de
|
||||
# configuration et doit être de la forme name=value
|
||||
# Une ligne '$name = $value' est ajoutée à la fin de la section, qui est
|
||||
# créée si nécessaire à la fin du fichier de configuration
|
||||
# Retourner 0 si une modification a été faite dans le fichier, 1 sinon
|
||||
# Cette fonction nécessite gawk et ignore la locale
|
||||
local conf="$1"; shift
|
||||
local section="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local script match
|
||||
script="BEGIN {
|
||||
modified = 1
|
||||
section=$(quoted_awk "$section")
|
||||
in_section=0
|
||||
"
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
script="$script
|
||||
names[$i] = $(quoted_awk "$name")
|
||||
values[$i] = $(quoted_awk "$value")
|
||||
seen[$i] = 0"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script"'
|
||||
}
|
||||
function write_vars(write_section, wrote_section) {
|
||||
for (i in seen) {
|
||||
if (!seen[i]) {
|
||||
if (write_section && !wrote_section) {
|
||||
print "[" section "]"
|
||||
wrote_section = 1
|
||||
}
|
||||
print names[i] "=" values[i]
|
||||
seen[i] = 1
|
||||
modified = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
/^\[.*\]/ {
|
||||
was_in_section = in_section
|
||||
match($0, /^\[(.*)\]/, vs)
|
||||
in_section = (vs[1] == section)
|
||||
if (!in_section && was_in_section) {
|
||||
write_vars()
|
||||
}
|
||||
}
|
||||
{ print }
|
||||
END {
|
||||
write_vars(!in_section)
|
||||
exit modified
|
||||
}'
|
||||
|
||||
local tmpfile; ac_set_tmpfile tmpfile
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
if <"$conf" >"$tmpfile" cawk "$script"; then
|
||||
cat "$tmpfile" >"$conf"
|
||||
modified=0
|
||||
fi
|
||||
unfix_mode "$conf" "$mode"
|
||||
ac_clean "$tmpfile"
|
||||
return $modified
|
||||
}
|
||||
function mconf_array_append() { mconf_append "$@"; }
|
||||
|
||||
function mconf_check() {
|
||||
# Dans le fichier de configuration $1, tester si tous les paramètres $3..*
|
||||
# sont présents dans la section $2
|
||||
# Chaque argument de cette fonction correspond à une variable du fichier de
|
||||
# configuration, et doit être de la forme name[=value]
|
||||
# Si une valeur est spécifiée, vérifier que le fichier contient la valeur
|
||||
# correspondante. Sinon, tester uniquement la présence de la directive.
|
||||
# Cette fonction nécessite gawk et ignore la locale
|
||||
local conf="$1"; shift
|
||||
local section="$1"; shift
|
||||
[ -n "$*" ] || return 1
|
||||
|
||||
local script i param name value
|
||||
script="BEGIN {
|
||||
section = $(quoted_awk "$section")
|
||||
in_section = 0"
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
script="$script
|
||||
names[$i] = $(quoted_awk "$name")
|
||||
values[$i] = $(quoted_awk "$value")
|
||||
seen[$i] = 0"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script"'
|
||||
}
|
||||
/^\[.*\]/ {
|
||||
match($0, /^\[(.*)\]/, vs)
|
||||
in_section = (vs[1] == section)
|
||||
}
|
||||
'
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
splitvar "$param" name value
|
||||
script="$script
|
||||
in_section && \$0 ~ /^[ $TAB]*$name[ $TAB]*="
|
||||
if [ "$name" != "$param" ]; then
|
||||
script="$script$(quote_seds "$value")\$"
|
||||
fi
|
||||
script="$script/ {
|
||||
seen[$i] = 1
|
||||
}"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script
|
||||
END {
|
||||
for (i in seen) {
|
||||
if (!seen[i]) exit 1
|
||||
}
|
||||
exit 0
|
||||
}"
|
||||
<"$conf" cawk "$script"
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Gestion de fichiers de configuration générique
|
||||
|
||||
function gconf_addline() {
|
||||
# USAGE
|
||||
# gconf_addline configfile -a BEGIN -z END NEWLINE
|
||||
# Dans le fichier de configuration $1, ajouter la ligne NEWLINE entre les lignes
|
||||
# BEGIN et END.
|
||||
# -a BEGIN
|
||||
# Spécifier une expression pour matcher une ligne de type BEGIN. Si
|
||||
# cette option n'est pas spécifiée, on considère que le début de fichier
|
||||
# matche la ligne BEGIN: la ligne NEWLINE est ajoutée dès que possible.
|
||||
# Les lignes sont matchées dans l'ordre, i.e. avec '-a 1 -a 2', il faut
|
||||
# d'abord trouver la ligne 1 puis la ligne 2, sinon, le test n'est pas
|
||||
# concluant.
|
||||
# -t LINE
|
||||
# Si après avoir matché toutes les lignes BEGIN, la ligne LINE est
|
||||
# rencontrée, alors considérer que la ligne à rajouter existe déjà et
|
||||
# qu'il ne faut pas la rajouter de nouveau
|
||||
# -r LINE
|
||||
# Si après avoir matché toutes les lignes BEGIN, la ligne LINE est
|
||||
# rencontrée, alors considérer que la ligne à rajouter existe et qu'il
|
||||
# faut la mettre à jour. Supprimer la ligne existante et la remplacer
|
||||
# par la nouvelle ligne.
|
||||
# -z END
|
||||
# Spécifier une expression pour matcher la ligne de type END. Que cette
|
||||
# option soit ou non spécifiée, on considère toujours que la fin de
|
||||
# fichier matche la ligne END. Ainsi, si END n'est pas trouvée, la ligne
|
||||
# NEWLINE est ajoutée à la fin du fichier.
|
||||
# Dès que la ligne END est rencontrée, et si aucun des tests -t ou -r
|
||||
# n'est concluant, alors ajouter la nouvelle ligne avant celle-ci
|
||||
# -n MAX[=1]
|
||||
# Ajouter au plus MAX occurences de NEWLINE. Après avoir matché END, le
|
||||
# cycle recommence, au plus MAX-1 fois. Utiliser MAX=-1 pour désactiver
|
||||
# la limite
|
||||
# Cette fonction nécessite gawk et ignore la locale
|
||||
# Retourner 0 si l'ajout s'est fait correctement. Retourner 1 si BEGIN n'a
|
||||
# pas été trouvé, et donc aucun ajout n'a été effectué. Retourner 2 si une
|
||||
# erreur quelconque s'est produite
|
||||
|
||||
eval "$(utools_local)"
|
||||
local -a beginlines newlines
|
||||
local testline replaceline endline max
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
-a:,--begin: beginlines \
|
||||
-t:,--test: testline= \
|
||||
-r:,--replace: replaceline= \
|
||||
-z:,--end: endline= \
|
||||
-n:,--max: max= \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 2
|
||||
}
|
||||
conf="$1"; shift
|
||||
[ -n "$conf" ] || {
|
||||
eerror "Vous devez spécifier le fichier à modifier"
|
||||
return 2
|
||||
}
|
||||
[ -f "$conf" ] || {
|
||||
eerror "$conf: fichier introuvable"
|
||||
return 2
|
||||
}
|
||||
[ $# -gt 0 ] || {
|
||||
eerror "Vous devez spécifier la ligne à rajouter"
|
||||
return 2
|
||||
}
|
||||
[ -n "$max" ] || max=1
|
||||
newlines=("$@")
|
||||
|
||||
# générer le script
|
||||
local script="$(awkdef -f beginlines[@] testline="$testline" replaceline="$replaceline" endline="$endline" max:int="$max" newlines[@])"'
|
||||
BEGIN {
|
||||
searchindex = 1
|
||||
found = 0
|
||||
writeline = 1
|
||||
if (beginlines_count == 0) found = 1
|
||||
modified = 0
|
||||
}
|
||||
function writelines_maybe() {
|
||||
if (writeline) {
|
||||
for (i = 1; i <= newlines_count; i++) {
|
||||
print newlines[i]
|
||||
}
|
||||
writeline = 0
|
||||
modified = 1
|
||||
}
|
||||
}
|
||||
|
||||
max != 0 && !found && searchindex <= length(beginlines) && $0 ~ beginlines[searchindex] {
|
||||
searchindex++
|
||||
if (searchindex > length(beginlines)) {
|
||||
found = 1
|
||||
}
|
||||
print; next
|
||||
}
|
||||
max != 0 && found && writeline && testline != "" && $0 ~ testline {
|
||||
writeline = 0
|
||||
print; next
|
||||
}
|
||||
max != 0 && found && writeline && replaceline != "" && $0 ~ replaceline {
|
||||
writelines_maybe()
|
||||
next
|
||||
}
|
||||
max != 0 && found && writeline && endline != "" && $0 ~ endline {
|
||||
writelines_maybe()
|
||||
searchindex = 1
|
||||
found = 0
|
||||
writeline = 1
|
||||
if (max > 0) max--
|
||||
print; next
|
||||
}
|
||||
{ print }
|
||||
END {
|
||||
if (max != 0 && found && writeline) {
|
||||
writelines_maybe()
|
||||
}
|
||||
if (modified) exit 0
|
||||
else exit 1
|
||||
}
|
||||
'
|
||||
edebug "$script"
|
||||
|
||||
# traiter le fichier
|
||||
local tmpfile; ac_set_tmpfile tmpfile
|
||||
local mode="$(fix_mode "$conf")"
|
||||
local modified=1
|
||||
if <"$conf" >"$tmpfile" cawk "$script"; then
|
||||
cat "$tmpfile" >"$conf"
|
||||
modified=0
|
||||
fi
|
||||
unfix_mode "$conf" "$mode"
|
||||
ac_clean "$tmpfile"
|
||||
return $modified
|
||||
}
|
||||
282
ulib/crontab
282
ulib/crontab
@@ -1,282 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion du fichier crontab
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide crontab
|
||||
urequire base
|
||||
|
||||
# Ajouter la ligne $1 au crontab de l'utilisateur $2
|
||||
# Le code de retour est 123 si la ligne est déjà présente
|
||||
function add_to_crontab() {
|
||||
local -a crontab=(crontab ${2:+-u "$2"})
|
||||
local current="$("${crontab[@]}" -l 2>/dev/null)"
|
||||
local tmpfile
|
||||
ac_set_tmpfile tmpfile
|
||||
if [ -n "$current" ]; then
|
||||
echo "$current" >"$tmpfile"
|
||||
fi
|
||||
local NL=$'\n'
|
||||
if quietgrep -xF "$1$NL#$1" "$tmpfile"; then
|
||||
ac_clean "$tmpfile"
|
||||
return 123
|
||||
else
|
||||
echo "$1" >>"$tmpfile"
|
||||
"${crontab[@]}" "$tmpfile"
|
||||
ac_clean "$tmpfile"
|
||||
fi
|
||||
}
|
||||
# Supprimer la ligne $1 du crontab de l'utilisateur $2
|
||||
# Le code de retour est 123 si la ligne a déjà été supprimée
|
||||
function remove_from_crontab() {
|
||||
local -a crontab=(crontab ${2:+-u "$2"})
|
||||
local current="$("${crontab[@]}" -l 2>/dev/null)"
|
||||
local tmpfile
|
||||
ac_set_tmpfile tmpfile
|
||||
if [ -n "$current" ]; then
|
||||
echo "$current" >"$tmpfile"
|
||||
fi
|
||||
local NL=$'\n'
|
||||
if ! quietgrep -xF "$1$NL#$1" "$tmpfile"; then
|
||||
ac_clean "$tmpfile"
|
||||
return 123
|
||||
else
|
||||
grep -vxF "$1$NL#$1" "$tmpfile" | "${crontab[@]}" -
|
||||
ac_clean "$tmpfile"
|
||||
fi
|
||||
}
|
||||
# Désactiver la ligne $1 du crontab de l'utilisateur $2 en mettant '#' devant. Si
|
||||
# la ligne n'existe pas, elle est ajoutée mais commentée.
|
||||
# Le code de retour est 123 si la ligne est déjà désactivée
|
||||
function disable_in_crontab() {
|
||||
local -a crontab=(crontab ${2:+-u "$2"})
|
||||
local current="$("${crontab[@]}" -l 2>/dev/null)"
|
||||
local tmpfile
|
||||
ac_set_tmpfile tmpfile
|
||||
if [ -n "$current" ]; then
|
||||
echo "$current" >"$tmpfile"
|
||||
fi
|
||||
local NL=$'\n'
|
||||
if ! quietgrep -xF "$1$NL#$1" "$tmpfile"; then
|
||||
echo "#$1" >>"$tmpfile"
|
||||
"${crontab[@]}" "$tmpfile"
|
||||
elif quietgrep -xF "#$1" "$tmpfile"; then
|
||||
ac_clean "$tmpfile"
|
||||
return 123
|
||||
else
|
||||
<"$tmpfile" awkrun line="$1" '$0 == line { $0 = "#" $0 } { print }' | "${crontab[@]}" -
|
||||
ac_clean "$tmpfile"
|
||||
fi
|
||||
}
|
||||
# Activer la ligne $1 du crontab de l'utilisateur $2 en enlevant '#' devant. Si
|
||||
# la ligne n'existe pas, elle est ajoutée.
|
||||
# Le code de retour est 123 si la ligne est déjà activée
|
||||
function enable_in_crontab() {
|
||||
local -a crontab=(crontab ${2:+-u "$2"})
|
||||
local current="$("${crontab[@]}" -l 2>/dev/null)"
|
||||
local tmpfile
|
||||
ac_set_tmpfile tmpfile
|
||||
if [ -n "$current" ]; then
|
||||
echo "$current" >"$tmpfile"
|
||||
fi
|
||||
local NL=$'\n'
|
||||
if ! quietgrep -xF "$1$NL#$1" "$tmpfile"; then
|
||||
echo "$1" >>"$tmpfile"
|
||||
"${crontab[@]}" "$tmpfile"
|
||||
elif quietgrep -xF "$1" "$tmpfile"; then
|
||||
ac_clean "$tmpfile"
|
||||
return 123
|
||||
else
|
||||
<"$tmpfile" awkrun line="$1" '$0 == "#" line { sub(/^#/, "") } { print }' | "${crontab[@]}" -
|
||||
ac_clean "$tmpfile"
|
||||
fi
|
||||
}
|
||||
# Afficher la spécification crontab correspondant à l'heure courante
|
||||
function ctnow() {
|
||||
date +"%-M %-H %-d %-m %u"
|
||||
}
|
||||
# Analyser STDIN qui contient des lignes au format crontab, et afficher des
|
||||
# commandes pour les lignes correspondant à la date courante.
|
||||
# Les commandes sont de la forme "export var=value" pour la définition d'une
|
||||
# variable, "__ctexec 'cmd'" pour exécuter la commande correspondante ou
|
||||
# "__cterror 'msg'" en cas d'erreur de syntaxe sur une ligne. Il faut bien
|
||||
# entendu définir les function __ctexec et __cterror.
|
||||
# Cette fonction s'utilise de cette manière:
|
||||
# function __ctexec() { eval "$*"; }
|
||||
# function __cterror() { die "$*"; }
|
||||
# eval "$(ctresolve <crontab)"
|
||||
function ctresolve() {
|
||||
local -a ctnow
|
||||
eval "ctnow=($(ctnow))"
|
||||
filter_conf | awkrun -f ctnow[@] '
|
||||
function ctmatch(ctval, ref, parts, part, i, j, start, end, step, ok) {
|
||||
ok = 0
|
||||
split(ctval, parts, /,/)
|
||||
for(i = 1; i <= length(parts); i++) {
|
||||
part = parts[i]
|
||||
start = -1; end = -1; step = 1
|
||||
# extraire /step
|
||||
pos = index(part, "/")
|
||||
if (pos != 0) {
|
||||
step = substr(part, pos + 1) + 0
|
||||
part = substr(part, 1, pos - 1)
|
||||
}
|
||||
# traiter start-end
|
||||
pos = index(part, "-")
|
||||
if (pos != 0) {
|
||||
start = substr(part, 1, pos - 1) + 0
|
||||
end = substr(part, pos + 1) + 0
|
||||
} else {
|
||||
start = part + 0
|
||||
end = start
|
||||
}
|
||||
# tester si ça matche
|
||||
#print "start=" start ", end=" end ", step=" step", ref=" ref #DEBUG
|
||||
for (j = start; j <= end; j += step) {
|
||||
if (j == ref) {
|
||||
ok = 1
|
||||
break
|
||||
}
|
||||
}
|
||||
if (ok) break
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
BEGIN {
|
||||
refM = ctnow[1]; refH = ctnow[2]; refdom = ctnow[3]; refmon = ctnow[4]; refdow = ctnow[5]
|
||||
ctref = refM " " refH " " refdom " " refmon " " refdow
|
||||
print "##now: " ctref
|
||||
|
||||
match_ctline = 0
|
||||
match_indented = 0
|
||||
}
|
||||
|
||||
/^(export[ \t]+)?[a-zA-Z_][a-zA-Z0-9_]*[-+%#?]=/ {
|
||||
# manipulation de variables de type PATH
|
||||
match($0, /^(export[ \t]+)?([a-zA-Z_][a-zA-Z0-9_]*)([-+%#?])=(.*)$/, parts)
|
||||
name = parts[2]
|
||||
type = parts[3]
|
||||
value = parts[4]
|
||||
if (type == "+" || type == "%") {
|
||||
print "uaddpath " value " " name
|
||||
} else if (type == "#") {
|
||||
print "uinspath " value " " name
|
||||
} else if (type == "-") {
|
||||
print "udelpath " value " " name
|
||||
} else if (type == "?") {
|
||||
print "[ -n \"$" name "\" ] || " name "=" value
|
||||
}
|
||||
print "export " name
|
||||
next
|
||||
}
|
||||
/^(export[ \t]+)?[a-zA-Z_][a-zA-Z0-9_]*=/ {
|
||||
# spécification de variable
|
||||
sub(/^export[ \t]+/, "", $0)
|
||||
print "export " $0
|
||||
next
|
||||
}
|
||||
/^\$.+/ {
|
||||
# exécution de commande arbitraire
|
||||
if ($0 ~ /^\$\{([ \t]*(#.*)?)?$/) {
|
||||
# commande sur plusieurs lignes
|
||||
getline
|
||||
while ($0 !~ /^\$\}([ \t]*(#.*)?)?$/) {
|
||||
print
|
||||
if (getline <= 0) break
|
||||
}
|
||||
} else {
|
||||
# commande sur une seule ligne
|
||||
sub(/^\$/, "", $0)
|
||||
print
|
||||
}
|
||||
next
|
||||
}
|
||||
/^[ \t]*[-0-9/*,]+[ ]*[-0-9/*,]+[ ]*[-0-9/*,]+[ ]*[-0-9/*,]+[ ]*[-0-9/*,]+/ {
|
||||
# ligne de planification
|
||||
M = $1; H = $2; dom = $3; mon = $4; dow = $5
|
||||
sub(/^[ ]*[^ ]+[ ]+[^ ]+[ ]+[^ ]+[ ]+[^ ]+[ ]+[^ ]+[ ]*/, "", $0)
|
||||
|
||||
if (!match_ctline) match_indented = 0
|
||||
ctline = M " " H " " dom " " mon " " dow
|
||||
|
||||
gsub(/\*/, "0-59", M)
|
||||
Mok = ctmatch(M, refM)
|
||||
|
||||
gsub(/\*/, "0-23", H)
|
||||
Hok = ctmatch(H, refH)
|
||||
|
||||
gsub(/\*/, "1-31", dom)
|
||||
domok = ctmatch(dom, refdom)
|
||||
|
||||
gsub(/\*/, "1-12", mon)
|
||||
monok = ctmatch(mon, refmon)
|
||||
|
||||
gsub(/\*/, "1-7", dow)
|
||||
dowok = ctmatch(dow, refdow)
|
||||
|
||||
if (Mok && Hok && monok && (domok || dowok)) {
|
||||
print "##matches: " ctline
|
||||
match_ctline = 1
|
||||
match_indented = 1
|
||||
}
|
||||
|
||||
if (match_ctline && $0 != "") {
|
||||
print "__ctexec " quote_value($0)
|
||||
match_ctline = 0
|
||||
}
|
||||
next
|
||||
}
|
||||
/^[ \t]+/ {
|
||||
if (match_indented) {
|
||||
# il faut matcher les commandes indentees
|
||||
sub(/^[ \t]+/, "", $0)
|
||||
print "__ctexec " quote_value($0)
|
||||
}
|
||||
next
|
||||
}
|
||||
{
|
||||
print "__cterror " quote_value("ligne de format incorrect: " $0)
|
||||
}
|
||||
'
|
||||
}
|
||||
|
||||
## Préfixes
|
||||
|
||||
function get_default_crontabdir_prefix() {
|
||||
if check_sysinfos -s darwin; then
|
||||
if check_sysinfos -d 10.6+; then
|
||||
echo /var/at/tabs
|
||||
else
|
||||
echo /var/cron/tabs
|
||||
fi
|
||||
elif check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
echo /var/spool/cron/crontabs
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
echo /var/spool/cron
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
__crontab_prefixes=
|
||||
function __compute_crontab_prefixes() {
|
||||
[ -n "$__crontab_prefixes" ] && return
|
||||
CRONTABDIR="${CRONTABDIR:-$(get_default_crontabdir_prefix)}"
|
||||
__crontab_prefixes=1
|
||||
}
|
||||
|
||||
UTOOLS_PREFIXES=("${UTOOLS_PREFIXES[@]}" CRONTABDIR)
|
||||
|
||||
function compute_crontab_prefixes() {
|
||||
__compute_crontab_prefixes
|
||||
}
|
||||
|
||||
function recompute_crontab_prefixes() {
|
||||
__crontab_prefixes=
|
||||
__compute_crontab_prefixes
|
||||
}
|
||||
|
||||
function get_CRONTABDIR_prefix() {
|
||||
__compute_crontab_prefixes
|
||||
echo "$CRONTABDIR"
|
||||
}
|
||||
1104
ulib/debian
1104
ulib/debian
File diff suppressed because it is too large
Load Diff
127
ulib/install
127
ulib/install
@@ -1,127 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Des outils de haut niveau pour installer des fichiers de configuration
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide install
|
||||
urequire base
|
||||
|
||||
# Faut-il afficher le nom des fichiers copié/créés?
|
||||
INSTALL_VERBOSE=1
|
||||
# Faut-il afficher les destinations avec ppath?
|
||||
INSTALL_USES_PPATH=
|
||||
|
||||
function ensure_exists() {
|
||||
# créer le fichier vide "$1" s'il n'existe pas déjà. retourner vrai si le
|
||||
# fichier a été créé sans erreur
|
||||
[ -f "$1" ] || {
|
||||
if [ -n "$INSTALL_VERBOSE" ]; then
|
||||
if [ -n "$INSTALL_USES_PPATH" ]; then
|
||||
estep "$(ppath "$1")"
|
||||
else
|
||||
estep "$1"
|
||||
fi
|
||||
fi
|
||||
mkdirof "$1"
|
||||
touch "$1"
|
||||
return $?
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
function copy_replace() {
|
||||
# Copier de façon inconditionnelle le fichier $1 vers le fichier $2
|
||||
local src="$1" dest="$2"
|
||||
local srcname="$(basename "$src")"
|
||||
|
||||
[ -d "$dest" ] && dest="$dest/$srcname"
|
||||
mkdirof "$dest" || return 1
|
||||
|
||||
if [ -n "$INSTALL_VERBOSE" ]; then
|
||||
local msg destname
|
||||
if [ -n "$INSTALL_USES_PPATH" ]; then
|
||||
msg="$srcname --> $(ppath "$(dirname "$dest")")/"
|
||||
else
|
||||
msg="$srcname --> $(dirname "$dest")/"
|
||||
fi
|
||||
destname="$(basename "$dest")"
|
||||
[ "$srcname" == "$destname" ] || msg="$msg$destname"
|
||||
estep "$msg"
|
||||
fi
|
||||
cp "$src" "$dest"
|
||||
}
|
||||
|
||||
function copy_new() {
|
||||
# copier le fichier "$1" vers le fichier "$2"
|
||||
# Ne pas écraser le fichier destination s'il existe déjà
|
||||
# Retourner vrai si le fichier a été copié sans erreur
|
||||
local src="$1" dest="$2"
|
||||
|
||||
[ -d "$dest" ] && dest="$dest/$(basename "$src")"
|
||||
mkdirof "$dest" || return 1
|
||||
|
||||
if [ ! -e "$dest" ]; then
|
||||
copy_replace "$src" "$dest"
|
||||
else
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function copy_update() {
|
||||
# copier le fichier "$1" vers le fichier "$2", si $2 n'existe pas, ou si $1
|
||||
# a été modifié par rapport à $2.
|
||||
# Retourner vrai si le fichier a été copié sans erreur.
|
||||
local src="$1" dest="$2"
|
||||
|
||||
[ -d "$dest" ] && dest="$dest/$(basename "$src")"
|
||||
mkdirof "$dest" || return 1
|
||||
|
||||
if [ ! -e "$dest" ]; then
|
||||
copy_replace "$src" "$dest"
|
||||
elif testdiff "$src" "$dest"; then
|
||||
copy_replace "$src" "$dest"
|
||||
else
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
|
||||
function copy_update_ask() {
|
||||
# Copier ou mettre à jour le fichier $1 vers le fichier $2.
|
||||
# Si le fichier existe déjà, la différence est affichée, et une confirmation
|
||||
# est demandée pour l'écrasement du fichier.
|
||||
# Retourner vrai si le fichier a été copié sans erreur.
|
||||
local src="$1" dest="$2"
|
||||
|
||||
[ -d "$dest" ] && dest="$dest/$(basename "$src")"
|
||||
mkdirof "$dest" || return 1
|
||||
|
||||
[ -f "$dest" ] || copy_replace "$src" "$dest"
|
||||
if testdiff "$src" "$dest"; then
|
||||
diff -u "$dest" "$src"
|
||||
if ask_yesno -c "Voulez-vous remplacer $(ppath "$dest") par la nouvelle version?" C; then
|
||||
copy_replace "$src" "$dest"
|
||||
return $?
|
||||
fi
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
function copy_tree() {
|
||||
# Copier de façon inconditionnelle l'arborescence $1 dans l'arborescence $2
|
||||
local srcdir="$1" destdir="$2"
|
||||
mkdir -p "$destdir" || return 1
|
||||
cpdirnovcs "$srcdir" "$destdir"
|
||||
}
|
||||
|
||||
function link_new() {
|
||||
# Si $2 n'existe pas, créer le lien symbolique $2 pointant vers $1
|
||||
[ -e "$2" ] && return 0
|
||||
if [ -n "$INSTALL_VERBOSE" ]; then
|
||||
if [ -n "$INSTALL_USES_PPATH" ]; then
|
||||
estep "$(basename "$2") --> $(ppath "$(dirname "$1")")"
|
||||
else
|
||||
estep "$(basename "$2") --> $(dirname "$1")"
|
||||
fi
|
||||
fi
|
||||
ln -s "$1" "$2"
|
||||
}
|
||||
198
ulib/ipcalc
198
ulib/ipcalc
@@ -1,198 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Calculateur d'adresse IP
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide ipcalc
|
||||
urequire base
|
||||
|
||||
function get_random_kvm_macaddr() {
|
||||
# Obtenir une adresse mac au hasard commençant par 52:54:00 pour KVM
|
||||
echo "52:54:00:$(awk 'BEGIN {srand(); printf("%02X:%02X:%02X", rand()*256, rand()*256, rand()*256)}' 2>/dev/null)"
|
||||
}
|
||||
|
||||
function ipcalc_splitipmask() {
|
||||
# Découper $1 de la forme ip[/mask] entre l'adresse ip, qui est placé dans
|
||||
# la variable $2(=ip) et le masque, qui est placée dans la variable
|
||||
# $3(=mask)
|
||||
if [[ "$1" == */* ]]; then
|
||||
set_var "${2:-ip}" "${1%%/*}"
|
||||
set_var "${3:-mask}" "${1#*/}"
|
||||
else
|
||||
set_var "${2:-ip}" "$1"
|
||||
set_var "${3:-mask}"
|
||||
fi
|
||||
}
|
||||
|
||||
function ipcalc_checkip() {
|
||||
# Vérifier l'adresse ip $1 pour voir si elle est valide. Si l'adresse est
|
||||
# valide, l'afficher. Sinon, retourner 1
|
||||
awkrun status=0 '{
|
||||
# si l"adresse ne fait pas la taille voulue, rajouter des .0
|
||||
ip = $0
|
||||
gsub(/[^.]/, "", ip)
|
||||
count = length(ip)
|
||||
while (count < 3) {
|
||||
$0 = $0 ".0"
|
||||
count++
|
||||
}
|
||||
|
||||
# puis tester la validité
|
||||
if ($0 !~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/) {
|
||||
status = 1
|
||||
exit
|
||||
}
|
||||
match($0, /([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/, ps)
|
||||
for (i = 1; i <= 4; i++) {
|
||||
p = 0 + ps[i]
|
||||
if (p > 255) {
|
||||
status = 1
|
||||
exit
|
||||
}
|
||||
}
|
||||
print $0
|
||||
}
|
||||
END { exit status }' <<<"$1"
|
||||
}
|
||||
|
||||
function ipcalc_checkmask() {
|
||||
# vérifier le masque de sous-réseau $1 pour voir si elle est valide. Si oui,
|
||||
# afficher le suffixe (0, 8, 16, 24, 32) associé. Sinon retourner 1
|
||||
case "$1" in
|
||||
0|0.0.0.0) echo 0;;
|
||||
8|255.0.0.0) echo 8;;
|
||||
16|255.255.0.0) echo 16;;
|
||||
24|255.255.255.0) echo 24;;
|
||||
32|255.255.255.255) echo 32;;
|
||||
*) return 1;;
|
||||
esac
|
||||
return 0
|
||||
}
|
||||
|
||||
function ipcalc_netmask() {
|
||||
# à partir d'un suffixe (0, 8, 16, 24, 32) ou d'un masque de sous-réseau,
|
||||
# afficher le masque de sous-réseau. si le suffixe ou le masque ne sont pas
|
||||
# reconnus, retourner 1
|
||||
case "$1" in
|
||||
0|0.0.0.0) echo 0.0.0.0;;
|
||||
8|255.0.0.0) echo 255.0.0.0;;
|
||||
16|255.255.0.0) echo 255.255.0.0;;
|
||||
24|255.255.255.0) echo 255.255.255.0;;
|
||||
32|255.255.255.255) echo 255.255.255.255;;
|
||||
*) return 1;;
|
||||
esac
|
||||
return 0
|
||||
}
|
||||
|
||||
function ipcalc_broadcast() {
|
||||
# Calculer l'adresse de broadcast correspondant à l'adresse ip $1. Le masque
|
||||
# de sous-réseau peut-être indiqué dans l'adresse ip avec le suffixe /n ou
|
||||
# /x.x.x.x ou donné dans l'argument $2. Seuls les suffixes 0, 8, 16, 24, 32
|
||||
# sont supportés.
|
||||
# Retourner 1 si un erreur s'est produite, par exemple si l'adresse ou le
|
||||
# suffixe sont invalides ou non supportés.
|
||||
[ -n "$1" ] || return
|
||||
local ip mask
|
||||
|
||||
ipcalc_splitipmask "$1" ip mask
|
||||
[ -n "$mask" ] || mask="$2"
|
||||
[ -n "$mask" ] || mask=24
|
||||
|
||||
ip="$(ipcalc_checkip "$ip")" || return
|
||||
mask="$(ipcalc_checkmask "$mask")" || return
|
||||
|
||||
case "$mask" in
|
||||
0) echo "255.255.255.255";;
|
||||
8) ip="${ip%.*.*.*}"; echo "$ip.255.255.255";;
|
||||
16) ip="${ip%.*.*}"; echo "$ip.255.255";;
|
||||
24) ip="${ip%.*}"; echo "$ip.255";;
|
||||
32) echo "$ip";;
|
||||
esac
|
||||
}
|
||||
|
||||
function ipcalc_gateway() {
|
||||
# Calculer l'adresse du gateway correspondant à l'adresse ip $1, en
|
||||
# considérant que le gateway est la première adresse du réseau. Le masque de
|
||||
# sous-réseau peut-être indiqué dans l'adresse ip avec le suffixe /n ou
|
||||
# /x.x.x.x ou donné dans l'argument $2. Seuls les suffixes 0, 8, 16, 24, 32
|
||||
# sont supportés.
|
||||
# Retourner 1 si un erreur s'est produite, par exemple si l'adresse ou le
|
||||
# suffixe sont invalides ou non supportés.
|
||||
[ -n "$1" ] || return
|
||||
local ip mask
|
||||
|
||||
ipcalc_splitipmask "$1" ip mask
|
||||
[ -n "$mask" ] || mask="$2"
|
||||
[ -n "$mask" ] || mask=24
|
||||
|
||||
ip="$(ipcalc_checkip "$ip")" || return
|
||||
mask="$(ipcalc_checkmask "$mask")" || return
|
||||
|
||||
case "$mask" in
|
||||
0) echo "0.0.0.1";;
|
||||
8) ip="${ip%.*.*.*}"; echo "$ip.0.0.1";;
|
||||
16) ip="${ip%.*.*}"; echo "$ip.0.1";;
|
||||
24) ip="${ip%.*}"; echo "$ip.1";;
|
||||
32) echo "$ip";;
|
||||
esac
|
||||
}
|
||||
|
||||
function ipcalc_match() {
|
||||
# Vérifier si l'adresse $1 correspond au modèle $2, e.g.:
|
||||
# ipcalc_match 10.75.0.23 10/8 --> TRUE
|
||||
# ipcalc_match 10.75.0.23 10.75.0.0/24 --> TRUE
|
||||
# ipcalc_match 10.75.0.23 10.75.0.28 --> FALSE
|
||||
[ -n "$1" -a -n "$2" ] || return
|
||||
local ip tip tmask
|
||||
|
||||
ipcalc_splitipmask "$2" tip tmask
|
||||
[ -n "$tmask" ] || tmask=32
|
||||
|
||||
ip="$(ipcalc_checkip "$1")" || return
|
||||
tip="$(ipcalc_checkip "$tip")" || return
|
||||
tmask="$(ipcalc_checkmask "$tmask")" || return
|
||||
|
||||
case "$tmask" in
|
||||
0) return 0;;
|
||||
8) [ "${ip%.*.*.*}" == "${tip%.*.*.*}" ];;
|
||||
16) [ "${ip%.*.*}" == "${tip%.*.*}" ];;
|
||||
24) [ "${ip%.*}" == "${tip%.*}" ];;
|
||||
32) [ "$ip" == "$tip" ];;
|
||||
esac
|
||||
}
|
||||
|
||||
function ipcalc_fqdn() {
|
||||
# Calculer si possible le nom pleinement qualifié correspondant à l'hôte $1.
|
||||
# Dans tous les cas, afficher l'hôte, mais retourner 1 si la calcul n'a pas
|
||||
# pu être effectué.
|
||||
local -a ips hosts
|
||||
local ip host
|
||||
if ! ips=("$(ipcalc_checkip "$1")"); then
|
||||
resolv_ips ips "$1"
|
||||
if [ -z "${ips[*]}" ]; then
|
||||
echo "$1"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
for ip in "${ips[@]}"; do
|
||||
resolv_hosts hosts "$ip"
|
||||
if [ -n "${hosts[*]}" ]; then
|
||||
echo "${hosts[0]}"
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
echo "$1"
|
||||
return 1
|
||||
}
|
||||
|
||||
function ipcalc_fqdn_maybe() {
|
||||
# Si $1 *semble* déjà être un nom d'hôte pleinement qualifié, l'afficher tel
|
||||
# quel. Sinon utiliser ipcalc_fqdn() pour afficher le nom d'hôte pleinement
|
||||
# qualifié correspondant.
|
||||
if ipcalc_checkip "$1" >/dev/null; then
|
||||
ipcalc_fqdn "$1"
|
||||
elif [[ "$1" == *.* ]]; then
|
||||
echo "$1"
|
||||
else
|
||||
ipcalc_fqdn "$1"
|
||||
fi
|
||||
}
|
||||
515
ulib/java
515
ulib/java
@@ -1,515 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion de la sélection d'une version de Java
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
uprovide java
|
||||
urequire base sysinfos
|
||||
|
||||
################################################################################
|
||||
# versions installées sur le système
|
||||
JAVA_VMS13=(); JAVA_HOMES13=()
|
||||
JAVA_VMS14=(); JAVA_HOMES14=()
|
||||
JAVA_VMS5=(); JAVA_HOMES5=()
|
||||
JAVA_VMS6=(); JAVA_HOMES6=()
|
||||
JAVA_VMS7=(); JAVA_HOMES7=()
|
||||
# versions locales 32 bits
|
||||
JAVA32_VMS13=(); JAVA32_HOMES13=()
|
||||
JAVA32_VMS14=(); JAVA32_HOMES14=()
|
||||
JAVA32_VMS5=(); JAVA32_HOMES5=()
|
||||
JAVA32_VMS6=(); JAVA32_HOMES6=()
|
||||
JAVA32_VMS7=(); JAVA32_HOMES7=()
|
||||
# versions locales 64 bits
|
||||
JAVA64_VMS5=(); JAVA64_HOMES5=()
|
||||
JAVA64_VMS6=(); JAVA64_HOMES6=()
|
||||
JAVA64_VMS7=(); JAVA64_HOMES7=()
|
||||
# version sélectionnée
|
||||
SELECTED_JAVA_VM=; SELECTED_JAVA_HOME=
|
||||
SELECTED_JAVA=; SELECTED_JAVAC=
|
||||
|
||||
function __java_add() {
|
||||
# Ajouter la valeur $2 à la liste JAVA$3_$1
|
||||
array_add "JAVA${3}_${1}" "$2"
|
||||
}
|
||||
|
||||
function __java_compute_vms() {
|
||||
# calculer la liste de VMs disponibles et initialiser les tableaux
|
||||
# JAVA{,32,64}_{VMS,HOMES}{13,14,5,6,7}
|
||||
[ -z "$__COMPUTED_JAVA_VMS" ] || return
|
||||
|
||||
local vms vm v
|
||||
if check_sysinfos -s linux; then
|
||||
# D'abord chercher dans les JVMs installées manuellement dans
|
||||
# ~/opt/jvm{32,64}
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm32" "sun-jdk-*")"
|
||||
for vm in "${vms[@]}"; do
|
||||
v="${vm#sun-jdk-}"
|
||||
if [ "$v" == 1.4 ]; then
|
||||
__java_add VMS14 "$vm" 32
|
||||
__java_add HOMES14 "$HOME/opt/jvm32/$vm" 32
|
||||
elif [ "$v" == 1.5 ]; then
|
||||
__java_add VMS5 "$vm" 32
|
||||
__java_add HOMES5 "$HOME/opt/jvm32/$vm" 32
|
||||
elif [ "$v" == 1.6 ]; then
|
||||
__java_add VMS6 "$vm" 32
|
||||
__java_add HOMES6 "$HOME/opt/jvm32/$vm" 32
|
||||
elif [ "$v" == 1.7 ]; then
|
||||
__java_add VMS7 "$vm" 32
|
||||
__java_add HOMES7 "$HOME/opt/jvm32/$vm" 32
|
||||
fi
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm32" "j2sdk1.4.2*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS14 "$vm" 32
|
||||
__java_add HOMES14 "$HOME/opt/jvm32/$vm" 32
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm32" "jdk1.5.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS5 "$vm" 32
|
||||
__java_add HOMES5 "$HOME/opt/jvm32/$vm" 32
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm32" "jdk1.6.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS6 "$vm" 32
|
||||
__java_add HOMES6 "$HOME/opt/jvm32/$vm" 32
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm32" "jdk1.7.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS7 "$vm" 32
|
||||
__java_add HOMES7 "$HOME/opt/jvm32/$vm" 32
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm64" "sun-jdk-*")"
|
||||
for vm in "${vms[@]}"; do
|
||||
v="${vm#sun-jdk-}"
|
||||
if [ "$v" == 1.5 ]; then
|
||||
__java_add VMS5 "$vm" 64
|
||||
__java_add HOMES5 "$HOME/opt/jvm64/$vm" 64
|
||||
elif [ "$v" == 1.6 ]; then
|
||||
__java_add VMS6 "$vm" 64
|
||||
__java_add HOMES6 "$HOME/opt/jvm64/$vm" 64
|
||||
elif [ "$v" == 1.7 ]; then
|
||||
__java_add VMS7 "$vm" 64
|
||||
__java_add HOMES7 "$HOME/opt/jvm64/$vm" 64
|
||||
fi
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm64" "jdk1.5.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS5 "$vm" 64
|
||||
__java_add HOMES5 "$HOME/opt/jvm64/$vm" 64
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm64" "jdk1.6.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS6 "$vm" 64
|
||||
__java_add HOMES6 "$HOME/opt/jvm64/$vm" 64
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt/jvm64" "jdk1.7.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS7 "$vm" 64
|
||||
__java_add HOMES7 "$HOME/opt/jvm64/$vm" 64
|
||||
done
|
||||
# Puis chercher dans les JVMs installées manuellement dans ~/opt
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt" "sun-jdk-*")"
|
||||
for vm in "${vms[@]}"; do
|
||||
v="${vm#sun-jdk-}"
|
||||
if [ "$v" == 1.4 ]; then
|
||||
__java_add VMS14 "$vm"
|
||||
__java_add HOMES14 "$HOME/opt/$vm"
|
||||
elif [ "$v" == 1.5 ]; then
|
||||
__java_add VMS5 "$vm"
|
||||
__java_add HOMES5 "$HOME/opt/$vm"
|
||||
elif [ "$v" == 1.6 ]; then
|
||||
__java_add VMS6 "$vm"
|
||||
__java_add HOMES6 "$HOME/opt/$vm"
|
||||
elif [ "$v" == 1.7 ]; then
|
||||
__java_add VMS7 "$vm"
|
||||
__java_add HOMES7 "$HOME/opt/$vm"
|
||||
fi
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt" "j2sdk1.4.2*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS14 "$vm"
|
||||
__java_add HOMES14 "$HOME/opt/$vm"
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt" "jdk1.5.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS5 "$vm"
|
||||
__java_add HOMES5 "$HOME/opt/$vm"
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt" "jdk1.6.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS6 "$vm"
|
||||
__java_add HOMES6 "$HOME/opt/$vm"
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "$HOME/opt" "jdk1.7.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS7 "$vm"
|
||||
__java_add HOMES7 "$HOME/opt/$vm"
|
||||
done
|
||||
# Puis chercher dans les JVMs installées manuellement dans /opt
|
||||
array_from_lines vms "$(list_dirs "/opt" "sun-jdk-*")"
|
||||
for vm in "${vms[@]}"; do
|
||||
v="${vm#sun-jdk-}"
|
||||
if [ "$v" == 1.4 ]; then
|
||||
__java_add VMS14 "$vm"
|
||||
__java_add HOMES14 "/opt/$vm"
|
||||
elif [ "$v" == 1.5 ]; then
|
||||
__java_add VMS5 "$vm"
|
||||
__java_add HOMES5 "/opt/$vm"
|
||||
elif [ "$v" == 1.6 ]; then
|
||||
__java_add VMS6 "$vm"
|
||||
__java_add HOMES6 "/opt/$vm"
|
||||
elif [ "$v" == 1.7 ]; then
|
||||
__java_add VMS7 "$vm"
|
||||
__java_add HOMES7 "/opt/$vm"
|
||||
fi
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "/opt" "j2sdk1.4.2*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS14 "$vm"
|
||||
__java_add HOMES14 "/opt/$vm"
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "/opt" "jdk1.5.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS5 "$vm"
|
||||
__java_add HOMES5 "/opt/$vm"
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "/opt" "jdk1.6.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS6 "$vm"
|
||||
__java_add HOMES6 "/opt/$vm"
|
||||
done
|
||||
array_from_lines vms "$(list_dirs "/opt" "jdk1.7.*" | LANG=C sort -r)"
|
||||
for vm in "${vms[@]}"; do
|
||||
__java_add VMS7 "$vm"
|
||||
__java_add HOMES7 "/opt/$vm"
|
||||
done
|
||||
# Puis chercher dans les JVMs installées par le système dans
|
||||
# /usr/lib/jvm
|
||||
if check_sysinfos -d gentoo; then
|
||||
# sur gentoo
|
||||
array_from_lines vms "$(list_dirs /usr/lib/jvm)"
|
||||
for vm in "${vms[@]}"; do
|
||||
v="${vm#sun-jdk-}"
|
||||
if [ "$v" == 1.4 ]; then
|
||||
__java_add VMS14 "$vm"
|
||||
__java_add HOMES14 "/usr/lib/jvm/$vm"
|
||||
elif [ "$v" == 1.5 ]; then
|
||||
__java_add VMS5 "$vm"
|
||||
__java_add HOMES5 "/usr/lib/jvm/$vm"
|
||||
elif [ "$v" == 1.6 ]; then
|
||||
__java_add VMS6 "$vm"
|
||||
__java_add HOMES6 "/usr/lib/jvm/$vm"
|
||||
elif [ "$v" == 1.7 ]; then
|
||||
__java_add VMS7 "$vm"
|
||||
__java_add HOMES7 "/usr/lib/jvm/$vm"
|
||||
fi
|
||||
done
|
||||
elif check_sysinfos -d debianlike; then
|
||||
# sur debian
|
||||
array_from_lines vms "$(list_dirs /usr/lib/jvm)"
|
||||
for vm in "${vms[@]}"; do
|
||||
v="${vm%-sun}"
|
||||
v="${v#java-}"
|
||||
v="${v#j2sdk}"
|
||||
if [ "$v" == 1.4 ]; then
|
||||
__java_add VMS14 "$vm"
|
||||
__java_add HOMES14 "/usr/lib/jvm/$vm"
|
||||
elif [ "$v" == 1.5 -o "$v" == 1.5.0 ]; then
|
||||
__java_add VMS5 "$vm"
|
||||
__java_add HOMES5 "/usr/lib/jvm/$vm"
|
||||
elif [ "$v" == 6 -o "$v" == 1.6 ]; then
|
||||
__java_add VMS6 "$vm"
|
||||
__java_add HOMES6 "/usr/lib/jvm/$vm"
|
||||
elif [ "$v" == 7 -o "$v" == 1.7 ]; then
|
||||
__java_add VMS7 "$vm"
|
||||
__java_add HOMES7 "/usr/lib/jvm/$vm"
|
||||
fi
|
||||
done
|
||||
if [ -d /usr/lib/j2sdk1.4-sun ]; then
|
||||
__java_add VMS14 j2sdk1.4-sun
|
||||
__java_add HOMES14 /usr/lib/j2sdk1.4-sun
|
||||
fi
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
# XXX sur redhat
|
||||
:
|
||||
fi
|
||||
elif check_sysinfos -s macosx; then
|
||||
if [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/1.3" ]; then
|
||||
__java_add VMS13 "1.3"
|
||||
__java_add HOMES13 "/System/Library/Frameworks/JavaVM.framework/Versions/1.3/Home"
|
||||
fi
|
||||
if [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/1.4" ]; then
|
||||
__java_add VMS14 "1.4"
|
||||
__java_add HOMES14 "/System/Library/Frameworks/JavaVM.framework/Versions/1.4/Home"
|
||||
fi
|
||||
if [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/1.5" ]; then
|
||||
__java_add VMS5 "1.5"
|
||||
__java_add HOMES5 "/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home"
|
||||
fi
|
||||
if [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/1.6" ]; then
|
||||
__java_add VMS6 "1.6"
|
||||
__java_add HOMES6 "/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home"
|
||||
fi
|
||||
if [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/1.7" ]; then
|
||||
__java_add VMS7 "1.7"
|
||||
__java_add HOMES7 "/System/Library/Frameworks/JavaVM.framework/Versions/1.7/Home"
|
||||
fi
|
||||
fi
|
||||
__COMPUTED_JAVA_VMS=1
|
||||
}
|
||||
|
||||
function __java_dump_vms() {
|
||||
local v b i vms homes
|
||||
for v in 13 14 5 6 7; do
|
||||
for b in "" 32 64; do
|
||||
vms="JAVA${b}_VMS${v}[@]"; vms=("${!vms}")
|
||||
homes="JAVA${b}_HOMES${v}[@]"; homes=("${!homes}")
|
||||
i=0
|
||||
while [ $i -lt "${#vms[*]}" ]; do
|
||||
echo "$v${b:+-$b}:${vms[$i]}:${homes[$i]}"
|
||||
i=$(($i + 1))
|
||||
done
|
||||
done
|
||||
done
|
||||
}
|
||||
|
||||
function __java_select_vms() {
|
||||
if [ -z "$2" ]; then
|
||||
array_copy vms "JAVA_VMS$1"
|
||||
if [ -n "${vms[*]}" ]; then
|
||||
array_copy homes "JAVA_HOMES$1"
|
||||
return 0
|
||||
else
|
||||
return 1
|
||||
fi
|
||||
else
|
||||
array_copy vms "JAVA${2}_VMS$1"
|
||||
array_copy homes "JAVA${2}_HOMES$1"
|
||||
custom=1
|
||||
[ -n "${vms[*]}" ] && return 0 || return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function __java_select() {
|
||||
# Sélectionner la version de java $1 (qui peut être 13, 14, 5, 6 ou 7)
|
||||
# Si $2 est défini, il peut s'agit de 32 ou 64 selon que l'on requière la
|
||||
# version 32bits ou 64 bits. Sinon, la version sélectionnée peut être 32bits
|
||||
# ou 64bits selon ce qui est disponible.
|
||||
__java_compute_vms
|
||||
|
||||
local vms homes custom
|
||||
if [ -z "$2" ]; then
|
||||
__java_select_vms "$1" "$MYBITS" ||
|
||||
__java_select_vms "$1" ||
|
||||
__java_select_vms "$1" 32 ||
|
||||
__java_select_vms "$1" 64
|
||||
elif [ "$MYBITS" == "$2" ]; then
|
||||
__java_select_vms "$1" "$2" ||
|
||||
__java_select_vms "$1"
|
||||
else
|
||||
__java_select_vms "$1" "$2"
|
||||
fi
|
||||
if [ -n "${vms[*]}" ]; then
|
||||
SELECTED_JAVA_VM="${vms[0]}"
|
||||
SELECTED_JAVA_HOME="${homes[0]}"
|
||||
SELECTED_JAVA="$SELECTED_JAVA_HOME/bin/java"
|
||||
SELECTED_JAVAC="$SELECTED_JAVA_HOME/bin/javac"
|
||||
if [ -z "$custom" -a "$LINUX_FLAVOUR" == "gentoo" ]; then
|
||||
export GENTOO_VM="$SELECTED_JAVA_VM"
|
||||
export JAVA=java
|
||||
export JAVAC=javac
|
||||
return 0
|
||||
else
|
||||
[ "$LINUX_FLAVOUR" == "gentoo" ] && unset GENTOO_VM
|
||||
export JAVA_HOME="$SELECTED_JAVA_HOME"
|
||||
export JAVA="$SELECTED_JAVA"
|
||||
export JAVAC="$SELECTED_JAVAC"
|
||||
udelpath "$JAVA_HOME/bin"
|
||||
uinspath "$JAVA_HOME/bin"
|
||||
export PATH
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
function __java_select_default() {
|
||||
# Sélectionner la version de java par défaut. Si JAVA_HOME est défini,
|
||||
# prendre cette valeur. Sinon, essayer dans l'ordre 5, 6, 7, puis 14
|
||||
# la version 13 n'est jamais sélectionnée automatiquement
|
||||
if [ -n "$JAVA_HOME" ]; then
|
||||
export JAVA_HOME # s'assurer que cette variable est exportée
|
||||
export JAVA="$JAVA_HOME/bin/java"
|
||||
export JAVAC="$JAVA_HOME/bin/java"
|
||||
udelpath "$JAVA_HOME/bin"
|
||||
uinspath "$JAVA_HOME/bin"
|
||||
export PATH
|
||||
return 0
|
||||
fi
|
||||
local vm
|
||||
for vm in 5 6 7 14; do
|
||||
__java_select "$vm" && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function select_java() {
|
||||
# sélectionner la version *minimum* de java correspondant à $1
|
||||
# $1== 1.3|1.3+|1.4|1.4+|1.5|1.5+|1.6|1.6+|1.7|1.7+
|
||||
# Si $2 est défini, il peut s'agit de 32 ou 64 selon que l'on requière la
|
||||
# version 32bits ou 64 bits
|
||||
local v vms homes
|
||||
|
||||
case "$1" in
|
||||
1.3|1.3+|13|13+)
|
||||
for v in 13 14 5 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.4|1.4+|14|14+)
|
||||
for v in 14 5 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.5|1.5+|5|5+)
|
||||
for v in 5 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.6|1.6+|6|6+)
|
||||
for v in 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.7|1.7+|7|7+)
|
||||
for v in 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
esac
|
||||
return 1
|
||||
}
|
||||
|
||||
function select_java_exact() {
|
||||
# sélectionner la version *exacte* de java correspondant à $1
|
||||
# $1== 1.3|1.4|1.5|1.6|1.7 pour une correspondance exacte
|
||||
# $1== 1.3+|1.4+|1.5+|1.6+|1.7+ pour une version minimum
|
||||
# Si $2 est défini, il peut s'agit de 32 ou 64 selon que l'on requière la
|
||||
# version 32bits ou 64 bits
|
||||
local v vms homes
|
||||
|
||||
case "$1" in
|
||||
1.3|13)
|
||||
__java_select 13 && return 0
|
||||
;;
|
||||
1.3+|13+)
|
||||
for v in 13 14 5 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.4|14)
|
||||
__java_select 14 && return 0
|
||||
;;
|
||||
1.4+|14+)
|
||||
for v in 14 5 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.5|5)
|
||||
__java_select 5 "$2" && return 0
|
||||
;;
|
||||
1.5+|5+)
|
||||
for v in 5 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.6|6)
|
||||
__java_select 6 "$2" && return 0
|
||||
;;
|
||||
1.6+|6+)
|
||||
for v in 6 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
1.7|7)
|
||||
__java_select 7 "$2" && return 0
|
||||
;;
|
||||
1.7+|7+)
|
||||
for v in 7; do
|
||||
__java_select "$v" "$2" && return 0
|
||||
done
|
||||
;;
|
||||
esac
|
||||
return 1
|
||||
}
|
||||
|
||||
function select_java_any() {
|
||||
# Sélectionner la version exacte de java correspondant aux arguments, dans
|
||||
# l'ordre, jusqu'à ce qu'un argument corresponde. DEFAULT correspond à la
|
||||
# valeur actuelle de JAVA_HOME, si elle est définie.
|
||||
# Si aucun argument n'est défini, on assume "DEFAULT 1.5 1.6 1.7 1.4"
|
||||
local v
|
||||
[ -n "$*" ] || set -- DEFAULT 5 6 7 1.4
|
||||
for v in "$@"; do
|
||||
if [ "$v" == DEFAULT ]; then
|
||||
if [ -n "$JAVA_HOME" ]; then
|
||||
__java_select_default && return 0
|
||||
fi
|
||||
else
|
||||
select_java_exact "$v" && return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Gestion des préfixes
|
||||
|
||||
function get_default_javahome_prefix() {
|
||||
local GENTOO_VM JAVA_HOME JAVA JAVAC PATH="$PATH"
|
||||
__java_select_default
|
||||
[ -n "$JAVA_HOME" ] && echo "$JAVA_HOME"
|
||||
}
|
||||
|
||||
function get_javaextensions_prefix() {
|
||||
local javaextensions
|
||||
if check_sysinfos -s linux; then
|
||||
if [ -n "$JAVA_HOME" ]; then
|
||||
javaextensions="$JAVA_HOME/jre/lib/ext"
|
||||
[ -d "$javaextensions" ] || javaextensions="$JAVA_HOME/lib/ext"
|
||||
fi
|
||||
elif check_sysinfos -s darwin; then
|
||||
javaextensions=/Library/Java/Extensions
|
||||
fi
|
||||
|
||||
[ -n "$javaextensions" -a -d "$javaextensions" ] && echo "$javaextensions"
|
||||
}
|
||||
|
||||
__java_prefixes=
|
||||
function __compute_java_prefixes() {
|
||||
[ -n "$__java_prefixes" ] && return
|
||||
[ -n "$JAVA_HOME" ] || JAVA_HOME="$(get_default_javahome_prefix)"
|
||||
JAVAEXTENSIONS="${JAVAEXTENSIONS:-$(get_javaextensions_prefix)}"
|
||||
__java_prefixes=1
|
||||
}
|
||||
|
||||
UTOOLS_PREFIXES=("${UTOOLS_PREFIXES[@]}" JAVA_HOME JAVAEXTENSIONS)
|
||||
|
||||
function compute_java_prefixes() {
|
||||
__compute_java_prefixes
|
||||
}
|
||||
|
||||
function recompute_java_prefixes() {
|
||||
__java_prefixes=
|
||||
__compute_java_prefixes
|
||||
}
|
||||
|
||||
function get_JAVA_HOME_prefix() {
|
||||
__compute_java_prefixes
|
||||
echo "$JAVA_HOME"
|
||||
}
|
||||
|
||||
function get_JAVAEXTENSIONS_prefix() {
|
||||
__compute_java_prefixes
|
||||
echo "$JAVAEXTENSIONS"
|
||||
}
|
||||
@@ -1,113 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion de fichiers de propriétés java
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide javaproperties
|
||||
urequire base
|
||||
|
||||
function read_property() {
|
||||
# Lire la propriété $2 dans le fichier $1, et placer la valeur dans la
|
||||
# variable $3. Si la propriété n'existe pas, prendre la valeur par défaut
|
||||
# $4. Si $3=="", elle est construite à partir de $2 en remplaçant les '.'
|
||||
# par '_'
|
||||
# Retourner 1 si une erreur s'est produite (par exemple si le fichier
|
||||
# n'existe pas ou n'est pas accessible en lecture)
|
||||
[ -f "$1" -a -r "$1" ] || return 1
|
||||
|
||||
local __rp_name __rp_value __rp_found
|
||||
# utiliser cawkrun pour que awk n'essaye pas de traiter les caractères en
|
||||
# unicode (latin1 wrt utf-8)
|
||||
__rp_value="$(<"$1" cawkrun name="$2" '
|
||||
BEGIN {
|
||||
found = 1
|
||||
re_name = name
|
||||
gsub(/\./, "\\.", re_name)
|
||||
re_name = "^[ \t]*" re_name "[ \t]*="
|
||||
}
|
||||
$0 ~ re_name {
|
||||
sub(re_name, "")
|
||||
value = $0
|
||||
sub(/^[ \t]*/, "", value)
|
||||
while (substr(value, length(value), 1) == "\\") {
|
||||
getline
|
||||
sub(/^[ \t]*/, "")
|
||||
value = substr(value, 1, length(value) - 1) $0
|
||||
}
|
||||
print value
|
||||
found = 0
|
||||
exit
|
||||
}
|
||||
END { exit found }')" && __rp_found=1
|
||||
if [ -n "$3" ]; then
|
||||
__rp_name="$3"
|
||||
else
|
||||
__rp_name="${2//./_}"
|
||||
fi
|
||||
if [ -n "$__rp_found" ]; then
|
||||
set_var "$__rp_name" "$(tooenc "$__rp_value" "$LATIN1")"
|
||||
else
|
||||
set_var "$__rp_name" "$4"
|
||||
fi
|
||||
}
|
||||
|
||||
function write_property() {
|
||||
# Ecrire la propriété $2 dans le fichier $1 avec la valeur $3.
|
||||
# Retourner 1 si une erreur s'est produite (par exemple si le fichier
|
||||
# n'existe pas ou n'est pas accessible en écriture)
|
||||
[ -f "$1" -a -w "$1" ] || return 1
|
||||
|
||||
local status tmpfile
|
||||
ac_set_tmpfile tmpfile
|
||||
# utiliser cawkrun pour que awk n'essaye pas de traiter les caractères en
|
||||
# unicode (utf-8 wrt latin1)
|
||||
<"$1" >"$tmpfile" cawkrun name="$2" value="$(tooenc "$3" "" "$LATIN1")" '
|
||||
function write_value() {
|
||||
# XXX attention, le découpage n"est potentiellement pas fait
|
||||
# correctement si la valeur contient des espaces
|
||||
line = name "=" value
|
||||
prefix = ""
|
||||
max_len = 75
|
||||
if (length(line) > max_len) {
|
||||
do {
|
||||
print prefix substr(line, 1, max_len) "\\"
|
||||
line = substr(line, max_len + 1)
|
||||
prefix = " "
|
||||
max_len = 71
|
||||
} while (length(line) > max_len)
|
||||
}
|
||||
print prefix line
|
||||
}
|
||||
BEGIN {
|
||||
found = 0
|
||||
re_name = name
|
||||
gsub(/\./, "\\.", re_name)
|
||||
re_name = "^[ \t]*" re_name "[ \t]*="
|
||||
}
|
||||
!found && $0 ~ re_name {
|
||||
line = $0
|
||||
while (substr(line, length(line), 1) == "\\") {
|
||||
getline
|
||||
line = line $0
|
||||
}
|
||||
write_value()
|
||||
found = 1
|
||||
next
|
||||
}
|
||||
{ print }
|
||||
END { if (!found) write_value() }
|
||||
' && cat "$tmpfile" >"$1"
|
||||
status=$?
|
||||
ac_clean "$tmpfile"
|
||||
return $status
|
||||
}
|
||||
|
||||
function write_properties() {
|
||||
# Ecrire les propriétés $2..* dans le fichier $1. Les propriétés sont de la
|
||||
# forme "name=value"
|
||||
local __wp_propfile="$1"; shift
|
||||
local __wp_prop __wp_name __wp_value
|
||||
for __wp_prop in "$@"; do
|
||||
splitvar "$__wp_prop" __wp_name __wp_value
|
||||
write_property "$__wp_propfile" "$__wp_name" "$__wp_value"
|
||||
done
|
||||
}
|
||||
31
ulib/json
31
ulib/json
@@ -1,31 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## gestion de contenu au format json
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide json
|
||||
urequire base
|
||||
|
||||
function json_filter() {
|
||||
# traiter un flux json pour que chaque valeur soit sur une ligne séparée,
|
||||
# facilitant le traitement par un script bash
|
||||
awk '{
|
||||
gsub(/}\][ ]*$/, "\n&")
|
||||
gsub(/},[ ]*$/, "\n&")
|
||||
gsub(/[][{]/, "&\n")
|
||||
gsub(/,[ ]*"/, ",\n\"")
|
||||
gsub(/"}/, "\",\n}")
|
||||
print
|
||||
}'
|
||||
}
|
||||
|
||||
JSONFUNCS='
|
||||
function json_get(line) {
|
||||
if (!line) line = $0
|
||||
match(line, /^[^"]*"[^"]*":[ ]*"?/); line = substr(line, RSTART + RLENGTH)
|
||||
match(line, /"?[ ]*,?[ ]*$/); line = substr(line, 1, RSTART - 1)
|
||||
return line
|
||||
}
|
||||
'
|
||||
function awkjson() {
|
||||
json_filter | awkrun -f "$JSONFUNCS" "$@"
|
||||
}
|
||||
240
ulib/ldap
240
ulib/ldap
@@ -1,240 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion du service slapd (démarrage/arrêt), et de sa configuration
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
uprovide ldap
|
||||
urequire base sysinfos
|
||||
|
||||
function get_default_ldapconfdir_prefix() {
|
||||
# Calculer et afficher la valeur par défaut de LDAPCONFDIR, ou une chaine
|
||||
# vide si l'on n'a pas pu le détecter automatiquement.
|
||||
if check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
[ -d /etc/ldap ] && echo /etc/ldap
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
[ -d /etc/openldap ] && echo /etc/openldap
|
||||
elif check_sysinfos -d gentoo; then
|
||||
[ -d /etc/openldap ] && echo /etc/openldap
|
||||
fi
|
||||
elif check_sysinfos -s darwin; then
|
||||
[ -d /etc/openldap ] && echo /etc/openldap
|
||||
fi
|
||||
}
|
||||
|
||||
function get_default_ldapowner_prefix() {
|
||||
# Calculer et afficher la valeur par défaut de LDAPOWNER, ou une chaine
|
||||
# vide si l'on n'a pas pu le détecter automatiquement.
|
||||
if check_sysinfos -s linux; then
|
||||
if check_sysinfos -d debianlike; then
|
||||
echo openldap:openldap
|
||||
elif check_sysinfos -d redhatlike; then
|
||||
echo ldap:ldap
|
||||
elif check_sysinfos -d gentoo; then
|
||||
echo ldap:ldap
|
||||
fi
|
||||
elif check_sysinfos -s darwin; then
|
||||
echo root:wheel
|
||||
fi
|
||||
}
|
||||
|
||||
__ldap_prefixes=
|
||||
function __compute_ldap_prefixes() {
|
||||
[ -n "$__ldap_prefixes" ] && return
|
||||
LDAPCONFDIR="${LDAPCONFDIR:-$(get_default_ldapconfdir_prefix)}"
|
||||
LDAPOWNER="${LDAPOWNER:-$(get_default_ldapowner_prefix)}"
|
||||
__ldap_prefixes=1
|
||||
}
|
||||
|
||||
UTOOLS_PREFIXES=("${UTOOLS_PREFIXES[@]}" LDAPCONFDIR LDAPOWNER)
|
||||
|
||||
function compute_ldap_prefixes() {
|
||||
__compute_ldap_prefixes
|
||||
}
|
||||
|
||||
function recompute_ldap_prefixes() {
|
||||
__ldap_prefixes=
|
||||
__compute_ldap_prefixes
|
||||
}
|
||||
|
||||
function get_LDAPCONFDIR_prefix() {
|
||||
__compute_ldap_prefixes
|
||||
echo "$LDAPCONFDIR"
|
||||
}
|
||||
|
||||
function get_LDAPOWNER_prefix() {
|
||||
__compute_ldap_prefixes
|
||||
echo "$LDAPOWNER"
|
||||
}
|
||||
|
||||
function split_ldapuri() {
|
||||
# spliter le ldapuri $1 en $2(=proto), $3(=host) et $4(=port)
|
||||
local ldapuri="$1" protoname="${2:-proto}" hostname="${3:-host}" portname="${4:-port}"
|
||||
local tmp
|
||||
if [ -z "$ldapuri" ]; then
|
||||
set_var "$protoname" ""
|
||||
set_var "$hostname" ""
|
||||
set_var "$portname" ""
|
||||
return 0
|
||||
fi
|
||||
tmp="$ldapuri"
|
||||
if [ "${tmp#ldap://}" != "$tmp" ]; then
|
||||
set_var "$protoname" ldap
|
||||
tmp="${tmp#ldap://}"
|
||||
elif [ "${tmp#ldaps://}" != "$tmp" ]; then
|
||||
set_var "$protoname" ldaps
|
||||
tmp="${tmp#ldaps://}"
|
||||
elif [ "${tmp#ldapi://}" != "$tmp" ]; then
|
||||
set_var "$protoname" ldapi
|
||||
tmp="${tmp#ldapi://}"
|
||||
else
|
||||
set_var "$protoname" ""
|
||||
set_var "$hostname" ""
|
||||
set_var "$portname" ""
|
||||
eerror "invalid ldapuri: $ldapuri"
|
||||
return 1
|
||||
fi
|
||||
tmp="${tmp%%/*}"
|
||||
local tmphost="${tmp%%:*}"
|
||||
set_var "$hostname" "$tmphost"
|
||||
tmp="${tmp#$tmphost}"
|
||||
set_var "$portname" "${tmp#:}"
|
||||
return 0
|
||||
}
|
||||
|
||||
function get_suffixes() {
|
||||
# obtenir les suffixes de connexion du serveur avec l'uri $1, un par ligne
|
||||
# retourner 1 si la valeur n'a pas pu être obtenue
|
||||
local ncs
|
||||
ncs="$(ldapsearch -x ${1:+-H "$1"} -b "" -LLL -s base namingContexts)" || return 1
|
||||
<<<"$ncs" grep namingContexts: | sed 's/namingContexts: //'
|
||||
}
|
||||
|
||||
function get_anysuffix() {
|
||||
# obtenir le *premier* suffixe du serveur avec l'uri $1
|
||||
# retourner 1 si la valeur n'a pas pu être obtenue
|
||||
local suffix
|
||||
suffix="$(get_suffixes "$1")" || return 1
|
||||
<<<"$suffix" head -n1
|
||||
}
|
||||
|
||||
function get_dcsuffix() {
|
||||
# obtenir le *premier* suffixe du serveur avec l'uri $1 qui se termine par
|
||||
# dc=TLD où TLD est une valeur quelconque. A priori, c'est un suffixe d'une
|
||||
# base de donnée non administrative.
|
||||
# retourner 1 si la valeur n'a pas pu être obtenue
|
||||
local suffix
|
||||
suffix="$(get_suffixes "$1" | awk '/(^|,)dc=[^,]+/ { print }')" || return 1
|
||||
<<<"$suffix" head -n1
|
||||
}
|
||||
|
||||
function get_suffix() {
|
||||
# obtenir le *premier* suffixe du serveur avec l'uri $1 qui se termine si
|
||||
# possible par dc=TLD où TLD est une valeur quelconque. Dans le cas normal,
|
||||
# le suffixe affiché est celui d'une base non administrative.
|
||||
# retourner 1 si la valeur n'a pas pu être obtenue
|
||||
local suffixes suffix
|
||||
suffixes="$(get_suffixes "$1")" || return 1
|
||||
suffix="$(<<<"$suffixes" awk '/(^|,)dc=[^,]+/ { print }')"
|
||||
[ -n "$suffix" ] || suffix="$suffixes"
|
||||
<<<"$suffix" head -n1
|
||||
}
|
||||
|
||||
function reldn() {
|
||||
local suffix="${2:-$SUFFIX}"
|
||||
|
||||
# exprimer le dn $1 relativement au suffixe $2(=$SUFFIX)
|
||||
if [ -z "$suffix" ]; then
|
||||
echo "$1"
|
||||
elif [ -z "$1" -o "$1" == "$suffix" ]; then
|
||||
echo ""
|
||||
elif [ "${1%,$suffix}" != "$1" ]; then
|
||||
# absolu, enlever $suffix
|
||||
echo "${1%,$suffix}"
|
||||
else
|
||||
# relatif
|
||||
echo "$1"
|
||||
fi
|
||||
}
|
||||
|
||||
function _absdn() {
|
||||
local suffix="$2"
|
||||
|
||||
# obtenir le dn absolu correspondant au dn $1, le dn de base étant $2
|
||||
if [ -z "$suffix" ]; then
|
||||
echo "$1"
|
||||
elif [ -z "$1" -o "$1" == "$suffix" ]; then
|
||||
echo "$suffix"
|
||||
elif [ "${1%,$suffix}" != "$1" ]; then
|
||||
# absolu
|
||||
echo "$1"
|
||||
else
|
||||
# relatif, ajouter $suffix
|
||||
echo "$1,$suffix"
|
||||
fi
|
||||
}
|
||||
|
||||
function absdn() {
|
||||
# obtenir le dn absolu correspondant au dn $1, le dn de base étant
|
||||
# $2(=$SUFFIX)
|
||||
_absdn "$1" "${2:-$SUFFIX}"
|
||||
}
|
||||
|
||||
function subof() {
|
||||
# tester si le dn absolu $1 est $2 ou un enfant de $2
|
||||
[ "$1" == "$2" -o "${1%,$2}" != "$1" ]
|
||||
}
|
||||
|
||||
function rabsdn() {
|
||||
# comme absdn, mais tient compte de la valeur de $3(=$SEARCHBASE)
|
||||
# Si le dn commence par "~/", le dn est relatif à $2(=$SUFFIX)
|
||||
# Si le dn commence par "/", le dn est absolu
|
||||
# Sinon, le dn est relatif à $3
|
||||
local dn="$1" suffix="${2:-$SUFFIX}" searchbase="${3:-$SEARCHBASE}"
|
||||
|
||||
# corriger les expansions éventuelles du shell
|
||||
if [ "$dn" == "$HOME" ]; then
|
||||
dn="~"
|
||||
elif [ "${dn#$HOME}" != "$dn" ]; then
|
||||
dn="~${dn#$HOME}"
|
||||
fi
|
||||
# calculer le dn absolu
|
||||
if [ "${dn#/}" != "$dn" ]; then
|
||||
echo "${dn#/}"
|
||||
elif [ "$dn" == "~" ]; then
|
||||
echo "$SUFFIX"
|
||||
elif [ "${dn#\~/}" != "$dn" ]; then
|
||||
_absdn "${dn#\~/}" "$suffix"
|
||||
else
|
||||
_absdn "$dn" "$searchbase"
|
||||
fi
|
||||
}
|
||||
|
||||
function pdn() {
|
||||
# corriger pour *affichage* un dn *absolu*. pour la racine "", afficher
|
||||
# '/'. pour $2(=$SUFFIX), afficher '~'. sinon, afficher le dn relativement à
|
||||
# $2
|
||||
local suffix="${2:-$SUFFIX}"
|
||||
if [ -z "$1" ]; then
|
||||
echo "/"
|
||||
elif [ "$1" == "$suffix" ]; then
|
||||
echo "~"
|
||||
elif [ "${1%,$suffix}" != "$1" ]; then
|
||||
echo "$(reldn "$1")"
|
||||
else
|
||||
echo "/$1"
|
||||
fi
|
||||
}
|
||||
|
||||
function filter_slapdconf() {
|
||||
# Traiter un fichier de configuration slapd.conf en fusionnant les lignes
|
||||
# qui sont découpées. Ceci permet de faire des traitements sur le contenu.
|
||||
# Ce filtre s'utilisera normalement avec filter_conf, e.g.:
|
||||
# <slapd.conf filter_slapdconf | filter_conf >result.conf
|
||||
awk '
|
||||
BEGIN { line = ""; valid = 0; }
|
||||
/^[ \t]/ { line = line $0; next; }
|
||||
{ if (valid) print line; line = $0; valid = 1; }
|
||||
END { if (valid) print line; }
|
||||
'
|
||||
}
|
||||
579
ulib/legacy
579
ulib/legacy
@@ -1,579 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonctions "récupérées" de utools, pas encore classées ou réécrites, mais
|
||||
## gardées pour compatibilité.
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide legacy
|
||||
urequire base
|
||||
|
||||
function file_get_vars() {
|
||||
# lire les variables dans un fichier
|
||||
local OENC="$UTF8"
|
||||
local done_ prefix_ whole_file_ file_ vars_ var_ script_
|
||||
|
||||
# traiter les arguments
|
||||
done_=
|
||||
while [ -z "$done_" ]; do
|
||||
case "$1" in
|
||||
--prefix|-p)
|
||||
# prefixe pour la variable
|
||||
prefix_="$2"
|
||||
shift; shift
|
||||
;;
|
||||
--whole-file|-w)
|
||||
# lire les variables dans le fichier en entier, et pas seulement
|
||||
# dans l'en-tête.
|
||||
whole_file_=1
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
done_=1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
# obtenir le nom du fichier
|
||||
file_="$1"; shift
|
||||
if [ ! -f "$file_" ]; then
|
||||
# fichier inexistant
|
||||
ewarn "Fichier inexistant: $file_"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# initialiser les valeurs par défaut
|
||||
vars_=
|
||||
while [ -n "$1" ]; do
|
||||
var_="$1"; shift
|
||||
vars_="${vars_:+$vars_ }$var_"
|
||||
set_var "$var_" "$1"; shift
|
||||
done
|
||||
|
||||
# puis parcourir le fichier pour initialiser la valeur définitive des
|
||||
# variables
|
||||
if [ -z "$whole_file_" ]; then
|
||||
script_="/^ *$/ { exit }
|
||||
"
|
||||
fi
|
||||
|
||||
for var_ in $vars_; do
|
||||
script_="$script_
|
||||
"'$0 ~ "^ *#* *" prefix "'"$var_"'=" {
|
||||
# enlever les caractères inutiles
|
||||
sub(" *#* *" prefix "'"$var_"'=", "")
|
||||
# enlever éventuellement les quotes autour de la valeur
|
||||
if ($0 ~ /^".*" *$/) {
|
||||
$0 = substr($0, 2) # premier quote
|
||||
match($0, /" *$/)
|
||||
$0 = substr($0, 1, RSTART - 1) # dernier quote
|
||||
}
|
||||
# remplacer dans les valeurs les occurences de quotes
|
||||
gsub("\"", "\\\"")
|
||||
# afficher la ligne à évaluer
|
||||
print "'"$var_"'=\"" $0 "\""
|
||||
}
|
||||
'
|
||||
done
|
||||
|
||||
eval "$(awkrun prefix="$prefix_" "$script_" <"$file_")"
|
||||
}
|
||||
|
||||
function file_set_vars() {
|
||||
# écrire les variables dans un fichier. Le fichier *doit exister*
|
||||
local OENC="$UTF8"
|
||||
local done_ quote_ comment_ prefix_ whole_file_ file_ var_ script_
|
||||
|
||||
# traiter les arguments
|
||||
done_=
|
||||
while [ -z "$done_" ]; do
|
||||
case "$1" in
|
||||
--quote-always|-q)
|
||||
# toujours mettre les valeurs entre quotes
|
||||
quote_=1
|
||||
shift
|
||||
;;
|
||||
--comment-prefix|-c)
|
||||
# commentaire à préfixer
|
||||
comment_="$2"
|
||||
shift; shift
|
||||
;;
|
||||
--prefix|-p)
|
||||
# prefixe pour la variable
|
||||
prefix_="$2"
|
||||
shift; shift
|
||||
;;
|
||||
--whole-file|-w)
|
||||
# écrire les variables dans le fichier en entier, et pas seulement
|
||||
# dans l'en-tête.
|
||||
whole_file_=1
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
done_=1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
# obtenir le nom du fichier
|
||||
file_="$1"; shift
|
||||
if [ ! -f "$file_" ]; then
|
||||
# fichier inexistant
|
||||
ewarn "Fichier inexistant: $file_"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# puis parcourir le fichier pour mettre à jour les valeurs
|
||||
script_='BEGIN {
|
||||
# faut-il mettre à jour les variables?
|
||||
update_vars = 1'
|
||||
for var_ in "$@"; do
|
||||
script_="$script_
|
||||
${var_}_done = 0"
|
||||
done
|
||||
script_="$script_
|
||||
}"
|
||||
|
||||
script_="$script_"'
|
||||
function quote_value_maybe(value) {
|
||||
if (quote_always || index(value, " ") != 0) {
|
||||
return "\"" value "\""
|
||||
} else {
|
||||
return value
|
||||
}
|
||||
}
|
||||
|
||||
function write_all_remaining_vars() {'
|
||||
for var_ in "$@"; do
|
||||
value="${!var_}"
|
||||
script_="$script_"'
|
||||
if (! '"$var_"'_done) {
|
||||
print comment prefix "'"$var_"'=" quote_value_maybe("'"${value//\"/\\\"}"'")
|
||||
'"$var_"'_done = 1
|
||||
}'
|
||||
done
|
||||
script_="$script_
|
||||
}"
|
||||
|
||||
if [ -z "$whole_file_" ]; then
|
||||
script_="$script_"'
|
||||
/^[ \t]*$/ {
|
||||
write_all_remaining_vars()
|
||||
update_vars = 0
|
||||
}'
|
||||
fi
|
||||
|
||||
script_="$script_"'
|
||||
update_vars && comment == "" && $0 ~ "^ *#* *.*=.*$" {
|
||||
#comment = gensub("^( *#* *).*=.*$", "\\1", 1)
|
||||
comment = ""
|
||||
if (match($0, /^ *#* */) != 0) {
|
||||
comment = substr($0, RSTART, RLENGTH)
|
||||
}
|
||||
}'
|
||||
|
||||
for var_ in "$@"; do
|
||||
value="${!var_}"
|
||||
script_="$script_"'
|
||||
update_vars && ! '"$var_"'_done && $0 ~ "^ *#* *" prefix "'"$var_"'=" {
|
||||
#$0 = gensub("^( *#* *" prefix "'"$var_"'=).*$", "\\1", 1)
|
||||
match($0, "^ *#* *" prefix "'"$var_"'=")
|
||||
$0 = substr($0, RSTART, RLENGTH)
|
||||
$0 = $0 quote_value_maybe("'"${value//\"/\\\"}"'")
|
||||
print
|
||||
'"$var_"'_done = 1
|
||||
next
|
||||
}'
|
||||
done
|
||||
|
||||
script_="$script_"'
|
||||
{
|
||||
print
|
||||
}
|
||||
END {
|
||||
if (update_vars) {
|
||||
write_all_remaining_vars()
|
||||
}
|
||||
}'
|
||||
|
||||
doinplace "$file_" awkrun quote_always="$quote_" comment="$comment_" prefix="$prefix_" "$script_"
|
||||
}
|
||||
|
||||
function file_get_properties() {
|
||||
# lire les propriétés d'un fichier de propriété java ou xml
|
||||
if endswith "$1" .xml; then
|
||||
file_get_xml_properties "$@"
|
||||
else
|
||||
file_get_java_properties "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
function file_set_properties() {
|
||||
# écrire les propriétés d'un fichier de propriété java ou xml
|
||||
local done_ create_
|
||||
while [ -z "$done_" ]; do
|
||||
case "$1" in
|
||||
--create|-c)
|
||||
create_=1
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
done_=1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
if endswith "$1" .xml; then
|
||||
file_set_xml_properties ${create_:+-c} "$@"
|
||||
else
|
||||
file_set_java_properties ${create_:+-c} "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
|
||||
function file_get_java_properties() {
|
||||
# lire les propriétés d'un fichier de propriétés java. note: les noms de
|
||||
# propriété java peuvent contenir le caractère "." mais pas les noms de
|
||||
# variable bash. La conversion est faite automatiquement. Par exemple::
|
||||
# file_get_properties build.properties path.to.package "default value"
|
||||
# charge la valeur de la propriété dans la variable path_to_package
|
||||
|
||||
# $1=nom du fichier de propriété
|
||||
# $2..n=propriétés qu'il faut lire et valeurs par défaut de ces propriétés
|
||||
# $__2*i __=nom de la propriété
|
||||
# $__2*i+1__=valeur par défaut de la propriété si la valeur n'existe pas
|
||||
# dans le fichier
|
||||
local OENC="$UTF8"
|
||||
local file_="$1"; shift
|
||||
if [ ! -f "$file_" ]; then
|
||||
# fichier inexistant
|
||||
ewarn "Fichier de propriété inexistant: $file_"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local var_ sh_var_ awk_var_
|
||||
local script
|
||||
while [ -n "$1" ]; do
|
||||
# pour chacune des variables...
|
||||
var_="$1"; shift
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
awkre_var_="${var_//./\\.}" # nom de la variable pour une expression régulière awk
|
||||
|
||||
# initialiser la valeur par défaut
|
||||
set_var "$sh_var_" "$1"; shift
|
||||
|
||||
# et créer le script qui affichera sa valeur
|
||||
script="$script"'
|
||||
$0 ~ "^[ \t]*'"$(quote_awk "$awkre_var_")"'=" {
|
||||
# enlever les caractères de début
|
||||
sub("^[ \t]*'"$(quote_awk "$awkre_var_")"'=", "")
|
||||
value = $0
|
||||
# éventuellement ajouter les lignes de continuation
|
||||
while (substr(value, length(value), 1) == "\\") {
|
||||
getline
|
||||
sub("^[ \t]*", "")
|
||||
value = substr(value, 1, length(value) - 1) $0
|
||||
}
|
||||
gsub("\"", "\\\"", value)
|
||||
print "'"$sh_var_"'=\"" value "\""
|
||||
}
|
||||
'
|
||||
done
|
||||
|
||||
eval "$(awk "$script" <"$file_")"
|
||||
}
|
||||
|
||||
function file_set_java_properties() {
|
||||
# écrire des propriétés dans un fichier de propriétés java.
|
||||
|
||||
# $1=nom du fichier de propriété
|
||||
# $2..n=propriétés qu'il faut écrire et valeurs de ces propriétés
|
||||
# $__2*i __=nom de la propriété
|
||||
# $__2*i+1__=valeur de la propriété
|
||||
# traiter les arguments
|
||||
local OENC="$UTF8"
|
||||
local done_ create_
|
||||
while [ -z "$done_" ]; do
|
||||
case "$1" in
|
||||
--create|-c)
|
||||
# créer le fichier s'il n'existe pas
|
||||
create_=1
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
done_=1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
local file_="$1"; shift
|
||||
if [ ! -f "$file_" ]; then
|
||||
if [ -n "$create_" ]; then
|
||||
touch "$file_"
|
||||
else
|
||||
# fichier inexistant
|
||||
ewarn "Fichier de propriété inexistant: $file_"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# récupérer les noms des propriétés et leur valeur
|
||||
local var_ arg_ sh_var_ awkre_var_ value_
|
||||
local -a vars_ values_
|
||||
value_=vars_
|
||||
for arg_ in "$@"; do
|
||||
array_add "$value_" "$arg_"
|
||||
if [ "$value_" == "vars_" ]; then
|
||||
value_=values_
|
||||
else
|
||||
value_=vars_
|
||||
fi
|
||||
done
|
||||
|
||||
# créer le script qui va parcourir le fichier pour mettre à jour les valeurs
|
||||
script_="BEGIN {"
|
||||
for var_ in "${vars_[@]}"; do
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
script_="$script_
|
||||
${sh_var_}_done = 0"
|
||||
done
|
||||
script_="$script_"'
|
||||
}
|
||||
function write_all_remaining_vars() {'
|
||||
local i=0
|
||||
while [ $i -lt ${#vars_[*]} ]; do
|
||||
var_="${vars_[$i]}"
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
awkre_var_="${var_//./\\.}" # nom de la variable pour une expression régulière awk
|
||||
value_="${values_[$i]}"
|
||||
|
||||
script_="$script_"'
|
||||
if (! '"$sh_var_"'_done) {
|
||||
print "'"$var_"'=" "'"${value_//\"/\\\"}"'"
|
||||
'"$sh_var_"'_done = 1
|
||||
}'
|
||||
i=$((i + 1))
|
||||
done
|
||||
script_="$script_
|
||||
}"
|
||||
|
||||
local i=0
|
||||
while [ $i -lt ${#vars_[*]} ]; do
|
||||
var_="${vars_[$i]}"
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
awkre_var_="${var_//./\\.}" # nom de la variable pour une expression régulière awk
|
||||
value_="${values_[$i]}"
|
||||
script_="$script_"'
|
||||
! '"$sh_var_"'_done && $0 ~ "^[ \t]*'"$awkre_var_"'=" {
|
||||
#name = gensub("^([ \t]*'"$awkre_var_"'=).*$", "\\1", 1)
|
||||
match($0, "^[ \t]*'"$awkre_var_"'=")
|
||||
name = substr($0, RSTART, RLENGTH)
|
||||
value = substr($0, length(name) + 1)
|
||||
|
||||
while (substr(value, length(value), 1) == "\\") {
|
||||
getline
|
||||
value = value $0
|
||||
}
|
||||
line = name "'"${value_//\"/\\\"}"'"
|
||||
prefix = ""
|
||||
max_len = 75
|
||||
if (length(line) > max_len) {
|
||||
do {
|
||||
print prefix substr(line, 1, max_len) "\\"
|
||||
line = substr(line, max_len + 1)
|
||||
prefix = " "
|
||||
max_len = 71
|
||||
} while (length(line) > max_len)
|
||||
}
|
||||
print prefix line
|
||||
'"$sh_var_"'_done = 1
|
||||
next
|
||||
}'
|
||||
i=$((i + 1))
|
||||
done
|
||||
|
||||
script_="$script_
|
||||
{
|
||||
print
|
||||
}
|
||||
END {
|
||||
write_all_remaining_vars()
|
||||
}"
|
||||
|
||||
doinplace "$file_" awk "$script_"
|
||||
}
|
||||
|
||||
function file_get_xml_properties() {
|
||||
# lire les propriétés d'un fichier de propriétés xml. Limitation: les
|
||||
# propriétés ne doivent pas être continuées sur plusieurs lignes. Les
|
||||
# propriétés doivent être écrites sous la forme::
|
||||
# <propname>propvalue</propname>
|
||||
|
||||
# note: les noms de propriété java peuvent contenir le caractère "." mais
|
||||
# pas les noms de variable bash. La conversion est faite
|
||||
# automatiquement. Par exemple::
|
||||
# file_get_properties build.properties path.to.package "default value"
|
||||
# charge la valeur de la propriété dans la variable path_to_package
|
||||
|
||||
# $1=nom du fichier de propriété
|
||||
# $2..n=propriétés qu'il faut lire et valeurs par défaut de ces propriétés
|
||||
# $__2*i __=nom de la propriété
|
||||
# $__2*i+1__=valeur par défaut de la propriété si la valeur n'existe pas
|
||||
# dans le fichier
|
||||
local OENC="$UTF8"
|
||||
local file_="$1"; shift
|
||||
if [ ! -f "$file_" ]; then
|
||||
# fichier inexistant
|
||||
ewarn "Fichier de propriété inexistant: $file_"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local var_ sh_var_ awk_var_
|
||||
local script
|
||||
while [ -n "$1" ]; do
|
||||
# pour chacune des variables...
|
||||
var_="$1"; shift
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
awkre_var_="${var_//./\\.}" # nom de la variable pour une expression régulière awk
|
||||
|
||||
# initialiser la valeur par défaut
|
||||
set_var "$sh_var_" "$1"; shift
|
||||
|
||||
# et créer le script qui affichera sa valeur
|
||||
script="$script"'
|
||||
$0 ~ /^[ \t]*<'"$awkre_var_"'>.*<\/'"$awkre_var_"'>/ {
|
||||
sub(/^[ \t]*<'"$awkre_var_"'>/, "")
|
||||
sub(/<\/'"$awkre_var_"'>.*$/, "")
|
||||
gsub("\"", "\\\"", $0)
|
||||
print "'"$sh_var_"'=\"" $0 "\""
|
||||
}
|
||||
'
|
||||
done
|
||||
|
||||
eval "$(awk "$script" <"$file_")"
|
||||
}
|
||||
|
||||
function file_set_xml_properties() {
|
||||
# écrire des propriétés dans un fichier de propriétés java.
|
||||
|
||||
# $1=nom du fichier de propriété
|
||||
# $2..n=propriétés qu'il faut écrire et valeurs de ces propriétés
|
||||
# $__2*i __=nom de la propriété
|
||||
# $__2*i+1__=valeur de la propriété
|
||||
# traiter les arguments
|
||||
local OENC="$UTF8"
|
||||
local done_ create_
|
||||
while [ -z "$done_" ]; do
|
||||
case "$1" in
|
||||
--create|-c)
|
||||
# créer le fichier s'il n'existe pas
|
||||
create_=1
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
done_=1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
local file_="$1"; shift
|
||||
if [ ! -f "$file_" ]; then
|
||||
if [ -n "$create_" ]; then
|
||||
touch "$file_"
|
||||
else
|
||||
# fichier inexistant
|
||||
ewarn "Fichier de propriété inexistant: $file_"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# récupérer les noms des propriétés et leur valeur
|
||||
local var_ arg_ sh_var_ awkre_var_ value_
|
||||
local -a vars_ values_
|
||||
value_=vars_
|
||||
for arg_ in "$@"; do
|
||||
array_add "$value_" "$arg_"
|
||||
if [ "$value_" == "vars_" ]; then
|
||||
value_=values_
|
||||
else
|
||||
value_=vars_
|
||||
fi
|
||||
done
|
||||
|
||||
# créer le script qui va parcourir le fichier pour mettre à jour les valeurs
|
||||
script_='BEGIN {
|
||||
rootElement = ""'
|
||||
for var_ in "${vars_[@]}"; do
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
script_="$script_
|
||||
${sh_var_}_done = 0"
|
||||
done
|
||||
script_="$script_"'
|
||||
}
|
||||
function write_all_remaining_vars() {'
|
||||
local i=0
|
||||
while [ $i -lt ${#vars_[*]} ]; do
|
||||
var_="${vars_[$i]}"
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
awkre_var_="${var_//./\\.}" # nom de la variable pour une expression régulière awk
|
||||
value_="${values_[$i]}"
|
||||
|
||||
script_="$script_"'
|
||||
if (! '"$sh_var_"'_done) {
|
||||
print "<'"$var_"'>'"${value_//\"/\\\"}"'</'"$var_"'>"
|
||||
'"$sh_var_"'_done = 1
|
||||
}'
|
||||
i=$((i + 1))
|
||||
done
|
||||
script_="$script_
|
||||
}"'
|
||||
rootElement == "" {
|
||||
match($0, /<.*>/)
|
||||
element = substr($0, RSTART + 1, RLENGTH - 2)
|
||||
firstChar = substr(element, 1, 1)
|
||||
if (firstChar != "?" && firstChar != "!") {
|
||||
rootElement = element
|
||||
}
|
||||
}'
|
||||
|
||||
local i=0
|
||||
while [ $i -lt ${#vars_[*]} ]; do
|
||||
var_="${vars_[$i]}"
|
||||
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
||||
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
||||
awkre_var_="${var_//./\\.}" # nom de la variable pour une expression régulière awk
|
||||
value_="${values_[$i]}"
|
||||
script_="$script_"'
|
||||
rootElement != "" && ! '"$sh_var_"'_done && $0 ~ /^[ \t]*<'"$awkre_var_"'>.*<\/'"$awkre_var_"'>/ {
|
||||
match($0, /^[ \t]*<'"$awkre_var_"'>/)
|
||||
first = substr($0, RSTART, RLENGTH)
|
||||
value = substr($0, length(first) + 1)
|
||||
match(value, /<\/'"$awkre_var_"'>.*$/)
|
||||
last = substr(value, RSTART, RLENGTH)
|
||||
value = substr(value, 1, RSTART)
|
||||
|
||||
print first "'"${value_//\"/\\\"}"'" last
|
||||
'"$sh_var_"'_done = 1
|
||||
next
|
||||
}'
|
||||
i=$((i + 1))
|
||||
done
|
||||
|
||||
script_="$script_"'
|
||||
rootElement != "" && $0 ~ "</" rootElement ">" {
|
||||
rootElement = ""
|
||||
write_all_remaining_vars()
|
||||
}
|
||||
{
|
||||
print
|
||||
}
|
||||
END {
|
||||
write_all_remaining_vars()
|
||||
}'
|
||||
|
||||
doinplace "$file_" awk "$script_"
|
||||
}
|
||||
118
ulib/macosx
118
ulib/macosx
@@ -1,118 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Outils pour MacOS X
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
##@require compat
|
||||
uprovide macosx
|
||||
urequire base sysinfos compat
|
||||
|
||||
################################################################################
|
||||
# Gestion des utilisateurs
|
||||
|
||||
function local_shellfix() {
|
||||
# Modifier le compte local $1 pour qu'il utilise bash au lieu de sh
|
||||
local username="${1:-root}"
|
||||
local shell="$(dscl localhost read "/Local/Default/Users/$username" UserShell | sed 's/^UserShell: //g')"
|
||||
if [ "$shell" != "/bin/bash" ]; then
|
||||
dscl localhost change "/Local/Default/Users/$username" UserShell "$shell" /bin/bash
|
||||
fi
|
||||
}
|
||||
|
||||
function local_usercheck() {
|
||||
# Vérifier si le user local $1 existe
|
||||
if check_sysinfos -s macosx -d 10.5+; then
|
||||
[ -n "$(dscl localhost list /Local/Default/Users | grep "$username")" ]
|
||||
elif check_sysinfos -s macosx -d 10.4; then
|
||||
[ -n "$(nicl . -list /users | grep "$username")" ]
|
||||
else
|
||||
return 123
|
||||
fi
|
||||
}
|
||||
|
||||
function local_useradd() {
|
||||
# Créer le user local $1
|
||||
# USAGE: local_useradd username [gecos [passwd]]
|
||||
# OPTIONS
|
||||
# -s Créer l'utilisateur avec les droits d'administrateur
|
||||
# -m Créer le home directory
|
||||
local -a args
|
||||
local admin create_home
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
-s,--admin admin=1 \
|
||||
-m,--create-home create_home=1 \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
local uid gid
|
||||
local username="$1" gecos="$2" passwd="$3"
|
||||
[ -n "$passwd" ] || passwd="${username:0:3}+def"
|
||||
local_usercheck "$username" && {
|
||||
eerror "$username: ce compte existe déjà"
|
||||
return 1
|
||||
}
|
||||
|
||||
if check_sysinfos -s macosx -d 10.5+; then
|
||||
[ -n "$uid" ] || uid=$(($(dscl localhost list /Local/Default/Users UniqueID | awk '{print $2}' | sort -rn | head -n 1) + 1))
|
||||
[ -n "$gid" ] || gid=20
|
||||
echo "\
|
||||
cd /Local/Default/Users
|
||||
create $username UniqueID $uid
|
||||
create $username PrimaryGroupID $gid
|
||||
create $username RealName \"$gecos\"
|
||||
create $username UserShell /bin/bash
|
||||
create $username NFSHomeDirectory /Users/$username
|
||||
create $username _writers_passwd $username
|
||||
passwd $username $passwd
|
||||
${admin:+
|
||||
cd /Local/Default/Groups
|
||||
merge admin GroupMembership $username
|
||||
}" | dscl -q localhost
|
||||
|
||||
elif check_sysinfos -s macosx -d 10.4; then
|
||||
local create_group
|
||||
[ -n "$uid" ] || uid="$(($(nicl . -list /users uid | awk '{print $2}' | sort -rn | head -n 1) + 1))"
|
||||
|
||||
if [ -z "$gid" ]; then
|
||||
gid="$(($(nicl . -list /groups gid | awk '{print $2}' | sort -rn | head -n 1) + 1))"
|
||||
[ "$gid" -lt 501 ] && gid=501
|
||||
fi
|
||||
[ -z "$(nicl . -list /groups gid | awk '{print $2}' | grep "$gid")" ] && create_group=1 || create_group=
|
||||
|
||||
echo "\
|
||||
${create_group:+cd /groups
|
||||
create $username gid $gid
|
||||
create $username passwd *
|
||||
}cd /users
|
||||
create $username uid $uid
|
||||
create $username gid $gid
|
||||
${gecos:+create $username realname \"$gecos\"
|
||||
}create $username shell /bin/bash
|
||||
create $username home /Users/$username
|
||||
create $username _writers_passwd $username
|
||||
${admin:+
|
||||
cd /groups
|
||||
merge admin users $username
|
||||
}" | nicl -q .
|
||||
echo 'spawn passwd '"$username"'
|
||||
expect "password:"
|
||||
send "'"$passwd"'\r"
|
||||
expect "password:"
|
||||
send "'"$passwd"'\r"
|
||||
expect eof
|
||||
' | expect
|
||||
|
||||
else
|
||||
return 123
|
||||
fi
|
||||
|
||||
if [ -n "$create_home" ]; then
|
||||
local homedir="/Users/$username"
|
||||
ditto "/System/Library/User Template/French.lproj" "$homedir"
|
||||
chown -R $uid:$gid "$homedir"
|
||||
chmod 755 "$homedir"
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonction de support pour mkcrypt: cryptage de mots de passe
|
||||
##@cooked nocomments
|
||||
##@require ulib
|
||||
##@require nutools/pyulib
|
||||
uprovide mkcrypt
|
||||
urequire ulib nutools/pyulib
|
||||
|
||||
function mkcrypt() { "$ULIBDIR/support/mkcrypt.py" "$@"; }
|
||||
169
ulib/modeline
169
ulib/modeline
@@ -1,169 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonctions pour gérer les modelines dans les fichiers
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide modeline
|
||||
urequire base
|
||||
|
||||
MODELINE="@prefix@-*- coding: utf-8 @mode@-*- vim:sw=@tabsize@:sts=@tabsize@:et:ai:si:sta:fenc=utf-8"
|
||||
|
||||
# modèles de modes à copier dans les fonctions __ml_* ci-dessous
|
||||
#CSS=.css|css
|
||||
#JS=.js|js|javascript
|
||||
#JAVA=.java|java
|
||||
#HTML=.html|.htm|html|html4|html5
|
||||
#XML=.xml|xml
|
||||
#PHP=.php|.phps|php|php4|php5
|
||||
#SH=.sh|sh|shell
|
||||
#PYTHON=.py|.pyw|py|python
|
||||
#TEXT=.txt|txt|text
|
||||
#CONF=.conf|conf
|
||||
#MARKDOWN=.mdt|.mdwn|.md|.text|.twp|markdown
|
||||
#PUML=.puml|puml|plantuml
|
||||
#IUML=.iuml|iuml|plantumlinc
|
||||
#SQL=.sql|sql
|
||||
|
||||
function __ml_getprefix() {
|
||||
case "$1" in
|
||||
.css|css|.js|js|javascript|.java|java) echo "/* ";;
|
||||
.html|.htm|html|html4|html5) echo "<!-- ";;
|
||||
.php|.phps|php|php4|php5) echo "<?php # ";;
|
||||
.sh|sh|shell|.py|.pyw|py|python|.txt|txt|text|.conf|conf) echo "# ";;
|
||||
.mdt|.mdwn|.md|.text|.twp|markdown|.puml|puml|plantuml) echo "# ";;
|
||||
.iuml|iuml|plantumlinc) echo "'' ";;
|
||||
.sql|sql) echo "-- ";;
|
||||
*) # par défaut, utiliser le préfixe '# ', même si ce n'est pas forcément
|
||||
# approprié
|
||||
echo "# "
|
||||
;;
|
||||
esac
|
||||
}
|
||||
function __ml_getmode() {
|
||||
case "$1" in
|
||||
.html|.htm|html|html4|html5) echo html;;
|
||||
.php|.phps|php|php5) echo php;;
|
||||
.sh|sh|shell) echo sh;;
|
||||
.py|.pyw|py|python) echo python;;
|
||||
.txt|txt|text) echo text;;
|
||||
.conf|conf) echo conf;;
|
||||
.mdt|.mdwn|.md|.text|.twp|markdown) echo markdown;;
|
||||
.puml|puml|plantuml|.iuml|iuml|plantumlinc) echo text;;
|
||||
.sql|sql) echo sql;;
|
||||
esac
|
||||
}
|
||||
function __ml_gettabsize() {
|
||||
case "$1" in
|
||||
.php|.phps|php|php5) echo 2;;
|
||||
*) echo 4;;
|
||||
esac
|
||||
}
|
||||
function __ml_getmodeline() {
|
||||
local prefix="$(__ml_getprefix "$1")"
|
||||
local mode="$(__ml_getmode "$1")"
|
||||
local tabsize="$(__ml_gettabsize "$1")"
|
||||
[ -n "$mode" ] && mode="mode: $mode "
|
||||
local modeline="$MODELINE"
|
||||
modeline="${modeline//@prefix@/$prefix}"
|
||||
modeline="${modeline//@mode@/$mode}"
|
||||
modeline="${modeline//@tabsize@/$tabsize}"
|
||||
echo "$modeline"
|
||||
}
|
||||
function __ml_getsuffix() {
|
||||
case "$1" in
|
||||
.css|css|.js|js|javascript|.java|java) echo "*/";;
|
||||
.html|.htm|html|html4|html5) echo "-->";;
|
||||
.php|.phps|php|php4|php5) echo "?>";;
|
||||
esac
|
||||
}
|
||||
|
||||
function printml() {
|
||||
local atype=auto
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with display_help' \
|
||||
-t:,--type: atype= \
|
||||
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
||||
|
||||
local mode modeline suffix type
|
||||
if [ "$atype" == "auto" ]; then
|
||||
local basename ext
|
||||
splitname "$(basename "$1")" basename ext
|
||||
type="${ext:+.$ext}"
|
||||
type="${type:-shell}"
|
||||
else
|
||||
type="$atype"
|
||||
fi
|
||||
modeline="$(__ml_getmodeline "$type")"
|
||||
suffix="$(__ml_getsuffix "$type")"
|
||||
|
||||
echo "$modeline${suffix:+
|
||||
$suffix}"
|
||||
}
|
||||
|
||||
function addml() {
|
||||
local atype=auto
|
||||
local edit=auto
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with display_help' \
|
||||
-t:,--type: atype= \
|
||||
-e,--edit edit=1 \
|
||||
-n,--noedit edit= \
|
||||
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
||||
|
||||
if [ "$edit" == "auto" ]; then
|
||||
[ $# -eq 1 ] && edit=1 || edit=
|
||||
fi
|
||||
|
||||
local mode modeline suffix type
|
||||
local -a edits
|
||||
for file in "$@"; do
|
||||
if [ "$atype" == "auto" ]; then
|
||||
local basename ext
|
||||
splitname "$(basename "$file")" basename ext
|
||||
type="${ext:+.$ext}"
|
||||
type="${type:-shell}"
|
||||
else
|
||||
type="$atype"
|
||||
fi
|
||||
mode="$(__ml_getmode "$type")"
|
||||
modeline="$(__ml_getmodeline "$type")"
|
||||
suffix="$(__ml_getsuffix "$type")"
|
||||
|
||||
if [ ! -e "$file" ]; then
|
||||
ask_yesno "Le fichier $file n'existe pas. Faut-il le créer?" O || continue
|
||||
touch "$file"
|
||||
fi
|
||||
array_add edits "$file"
|
||||
doinplacef "$file" awkrun mode="$mode" modeline="$modeline" suffix="$suffix" '
|
||||
BEGIN { run = 1; done = 0; nextline = 0 }
|
||||
run == 1 {
|
||||
if (substr($0, length($0) - length(modeline) + 1) == modeline) {
|
||||
run = 0; done = 1; nextline = 0
|
||||
} else if (nextline) {
|
||||
print modeline
|
||||
if (suffix != "") print suffix
|
||||
run = 0; done = 1; nextline = 0
|
||||
} else if (mode == "shell" && $0 ~ /^#!/) {
|
||||
nextline = 1
|
||||
} else if (mode == "shell" && $0 ~ /^#/) {
|
||||
print modeline
|
||||
if (suffix != "") print suffix
|
||||
done = 1; run = 0
|
||||
} else if (!done) {
|
||||
print modeline
|
||||
if (suffix != "") print suffix
|
||||
done = 1; run = 0
|
||||
} else {
|
||||
run = 0
|
||||
}
|
||||
}
|
||||
{ print }
|
||||
END {
|
||||
if (run || nextline) {
|
||||
print modeline
|
||||
if (suffix != "") print suffix
|
||||
}
|
||||
}
|
||||
'
|
||||
done
|
||||
[ -n "$edit" ] && "${EDITOR:-vi}" "${edits[@]}"
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonctions spécifiques au service network-manager
|
||||
##@cooked nocomments
|
||||
##@require service
|
||||
uprovide network-manager
|
||||
urequire service
|
||||
|
||||
SERVICE_OVERRIDE_network_manager_stopx=1
|
||||
function SERVICE_OVERRIDE_network_manager_stopx() {
|
||||
# désactiver network-manager avant de l'arrêter, ce qui permet de s'assurer
|
||||
# que chaque chaque connexion est arrêtée proprement
|
||||
if service network-manager check; then
|
||||
if [ "$(LANG=C nmcli -t -f STATE nm 2>/dev/null)" != asleep ]; then
|
||||
nmcli nm sleep
|
||||
sleep 2
|
||||
fi
|
||||
service network-manager stop
|
||||
fi
|
||||
}
|
||||
|
||||
SERVICE_OVERRIDE_network_manager_startx=1
|
||||
function SERVICE_OVERRIDE_network_manager_startx() {
|
||||
# cette fonction est le pendant de stopx: penser à relancer network-manager
|
||||
# après avoir démarré le service
|
||||
if ! service network-manager check; then
|
||||
service network-manager start
|
||||
sleep 2
|
||||
fi
|
||||
if [ "$(LANG=C nmcli -t -f STATE nm 2>/dev/null)" == asleep ]; then
|
||||
nmcli nm wakeup
|
||||
fi
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
# Utiliser 'udir --help-vars' pour une description de la signification des
|
||||
# variables suivantes:
|
||||
udir_desc="Ce répertoire contient les scripts privés de nutools, à inclure avec uinc"
|
||||
udir_note=""
|
||||
udir_types=()
|
||||
@@ -1,6 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Donner accès à l'outil plbck.py
|
||||
##@cooked nocomments
|
||||
urequire nutools/pyulib
|
||||
|
||||
function plbck() { python "$PYULIBDIR/src/uapps/plbck.py" "$@"; }
|
||||
@@ -1,6 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Donner accès à l'outil plver.py
|
||||
##@cooked nocomments
|
||||
urequire nutools/pyulib
|
||||
|
||||
function plver() { python "$PYULIBDIR/src/uapps/plver.py" "$@"; }
|
||||
@@ -1,37 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Accéder aux librairies python *locales* de pyulib
|
||||
##@cooked nocomments
|
||||
|
||||
# Modifier PYTHONPATH de façon que les librairies de pyulib *locales* soient
|
||||
# accessibles. N'utiliser ce fichier que dans le cas où la librairie pyulib
|
||||
# n'est pas installée sur le système.
|
||||
|
||||
# Ce fichier doit être *sourcé*. Si ce fichier n'est pas sourcé, alors le
|
||||
# répertoire pyulib doit être disponible dans le répertoire du script qui inclue
|
||||
# ce fichier. Ceci peut-être fait avec 'ulibsync -p'
|
||||
|
||||
## Calculer l'emplacement de pyulib
|
||||
|
||||
# il est possible de forcer la valeur de PYULIBDIR avec FORCED_PYULIBDIR. ceci
|
||||
# est utile avec bash 2.x qui ne supporte pas la variable BASH_SOURCE
|
||||
PYULIBDIR="$FORCED_PYULIBDIR"
|
||||
|
||||
if [ -z "$PYULIBDIR" ]; then
|
||||
PYULIBDIR="${BASH_SOURCE[0]}"
|
||||
if [ -n "$PYULIBDIR" -a -f "$PYULIBDIR" ]; then
|
||||
# Fichier sourcé
|
||||
PYULIBDIR="$(dirname "$PYULIBDIR")/../../pyulib"
|
||||
else
|
||||
# Fichier non sourcé. Tout exprimer par rapport au script courant
|
||||
PYULIBDIR="$(dirname "$0")/pyulib"
|
||||
fi
|
||||
fi
|
||||
PYULIBDIR="$(cd "$PYULIBDIR"; pwd)"
|
||||
|
||||
export PYTHONPATH="$PYULIBDIR/src${PYTHONPATH:+:$PYTHONPATH}"
|
||||
|
||||
function pyulib_sync() {
|
||||
# Synchroniser les librairies pyulib dans le répertoire $1
|
||||
destdir="$(abspath "${1:-.}")"
|
||||
[ "$destdir/pyulib" != "$PYULIBDIR" ] && cpdirnovcs "$PYULIBDIR" "$destdir/pyulib"
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Donner accès à l'outil uencdetect.py
|
||||
##@cooked nocomments
|
||||
urequire nutools/pyulib
|
||||
|
||||
function uencdetect() { python "$PYULIBDIR/src/uapps/uencdetect.py" "$@"; }
|
||||
@@ -1,6 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Donner accès à l'outil umail.py
|
||||
##@cooked nocomments
|
||||
urequire nutools/pyulib
|
||||
|
||||
function umail() { python "$PYULIBDIR/src/uapps/umail.py" "$@"; }
|
||||
@@ -1,99 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion de mots de passe
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide password
|
||||
urequire base
|
||||
|
||||
function random_index() {
|
||||
# Afficher un index au hasard dans le tableau $1
|
||||
[ -n "$1" ] || return
|
||||
local -a __rn_array; array_copy __rn_array "$1"
|
||||
[ ${#__rn_array[*]} -gt 0 ] || return
|
||||
echo $(($RANDOM % ${#__rn_array[*]}))
|
||||
}
|
||||
|
||||
function random_value() {
|
||||
# Afficher une valeur au hasard dans le tableau $1
|
||||
local __rv_index="$(random_index "$1")"
|
||||
[ -n "$__rv_index" ] || return
|
||||
eval "echo \${$1[$__rv_index]}"
|
||||
}
|
||||
|
||||
function random_char() {
|
||||
# Afficher un caractère au hasard dans la chaine $1
|
||||
local section="$1"
|
||||
[ ${#section} -gt 0 ] || return
|
||||
local index=$(($RANDOM % ${#section}))
|
||||
echo "${section:$index:1}"
|
||||
}
|
||||
|
||||
GENPASS_UPPER="AZERTYUIOPQSDFGHJKLMWXCVBN"
|
||||
GENPASS_LOWER="azertyuiopqsdfghjklmwxcvbn"
|
||||
GENPASS_NUMBERS="1234567890"
|
||||
GENPASS_SYMBOLS="&\"'(-_)=^\$*!:;,?./%+#{[|\\]}"
|
||||
GENPASS_LEN=10
|
||||
GENPASS_SECTIONS=("$GENPASS_UPPER" "$GENPASS_LOWER" "$GENPASS_UPPER$GENPASS_LOWER" "$GENPASS_NUMBERS" "$GENPASS_SYMBOLS" "$GENPASS_NUMBERS$GENPASS_SYMBOLS")
|
||||
GENPASS_COUNTS=(0 0 4 0 0 1)
|
||||
|
||||
function genpass() {
|
||||
# Générer un mot de passe au hasard avec les paramètres GENPASS_*
|
||||
local -a indexes parts
|
||||
local count index hascount part password
|
||||
|
||||
[ "${#GENPASS_SECTIONS[*]}" -eq "${#GENPASS_COUNTS[*]}" ] || die "GENPASS_COUNTS et GENPASS_SECTIONS doivent être de même taille"
|
||||
|
||||
# indexes contient les indexes dans le tableau SECTIONS, avec comme poids le
|
||||
# nombre de caractères minimum de chaque sections
|
||||
indexes=()
|
||||
index=0
|
||||
for count in "${GENPASS_COUNTS[@]}"; do
|
||||
while [ $count -ge 0 ]; do
|
||||
array_add indexes "$index"
|
||||
count=$(($count - 1))
|
||||
done
|
||||
index=$(($index + 1))
|
||||
done
|
||||
|
||||
# générer chaque caractère du mot de passe au hasard
|
||||
parts=()
|
||||
while true; do
|
||||
# vérifier s'il reste encore des sections avec un nombre minimum
|
||||
hascount=
|
||||
for count in "${GENPASS_COUNTS[@]}"; do
|
||||
[ "$count" -gt 0 ] && {
|
||||
hascount=1
|
||||
break
|
||||
}
|
||||
done
|
||||
[ -n "$hascount" ] || break
|
||||
# calculer la prochaine section à générer
|
||||
while true; do
|
||||
index=$(random_index GENPASS_SECTIONS)
|
||||
[ ${GENPASS_COUNTS[$index]} -gt 0 ] && break
|
||||
done
|
||||
# générer un caractère au hasard
|
||||
part="$(random_char "${GENPASS_SECTIONS[$index]}")"
|
||||
array_add parts "$part"
|
||||
GENPASS_COUNTS[$index]=$((${GENPASS_COUNTS[$index]} - 1))
|
||||
done
|
||||
# générer les autres caractères jusqu'à GENPASS_LEN
|
||||
while [ "${#parts[*]}" -lt "$GENPASS_LEN" ]; do
|
||||
index=$(random_value indexes)
|
||||
part="$(random_char "${GENPASS_SECTIONS[$index]}")"
|
||||
array_add parts "$part"
|
||||
done
|
||||
|
||||
# puis générer le mot de passe en prenant chaque partie au hasard
|
||||
password=
|
||||
while [ ${#parts[*]} -gt 0 ]; do
|
||||
index=$(random_index parts)
|
||||
password="$password${parts[$index]}"
|
||||
before=()
|
||||
[ $index -gt 0 ] && before=("${parts[@]:0:$index}")
|
||||
after=("${parts[@]:$((index + 1))}")
|
||||
parts=("${before[@]}" "${after[@]}")
|
||||
done
|
||||
|
||||
echo "$password"
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion de chemins standardisés
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
uprovide prefixes
|
||||
urequire base sysinfos
|
||||
|
||||
UTOOLS_PREFIXES=(USER HOME)
|
||||
|
||||
function get_USER_prefix() {
|
||||
echo "$USER"
|
||||
}
|
||||
function get_HOME_prefix() {
|
||||
echo "$HOME"
|
||||
}
|
||||
|
||||
function has_prefix() {
|
||||
array_contains UTOOLS_PREFIXES "$1" && return 0
|
||||
local prefix
|
||||
for prefix in "${UTOOLS_PREFIXES[@]}"; do
|
||||
if beginswith "$1" "$prefix/"; then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function expand_prefix() {
|
||||
local prefix
|
||||
for prefix in "${UTOOLS_PREFIXES[@]}"; do
|
||||
if beginswith "$1" "$prefix/" || [ "$1" == "$prefix" ]; then
|
||||
echo "$(get_${prefix}_prefix)${1#$prefix}"
|
||||
return
|
||||
fi
|
||||
done
|
||||
echo "$1"
|
||||
}
|
||||
|
||||
function list_prefixes() {
|
||||
local prefix
|
||||
for prefix in "${UTOOLS_PREFIXES[@]}"; do
|
||||
echo "$prefix"
|
||||
done
|
||||
}
|
||||
|
||||
function dump_prefixes() {
|
||||
local prefix
|
||||
for prefix in "${UTOOLS_PREFIXES[@]}"; do
|
||||
echo "$prefix=$(expand_prefix "$prefix")"
|
||||
done
|
||||
}
|
||||
303
ulib/pretty
303
ulib/pretty
@@ -1,303 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Affichage en couleur, et support de niveaux de "verbosité" et d'interaction
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide pretty
|
||||
urequire base
|
||||
|
||||
################################################################################
|
||||
# Gestion des couleurs
|
||||
|
||||
function __get_color() {
|
||||
[ -z "$*" ] && set RESET
|
||||
echo_ $'\e['
|
||||
local sep
|
||||
while [ -n "$1" ]; do
|
||||
[ -n "$sep" ] && echo_ ";"
|
||||
case "$1" in
|
||||
z|RESET) echo_ "0";;
|
||||
o|BLACK) echo_ "30";;
|
||||
r|RED) echo_ "31";;
|
||||
g|GREEN) echo_ "32";;
|
||||
y|YELLOW) echo_ "33";;
|
||||
b|BLUE) echo_ "34";;
|
||||
m|MAGENTA) echo_ "35";;
|
||||
c|CYAN) echo_ "36";;
|
||||
w|WHITE) echo_ "37";;
|
||||
DEFAULT) echo_ "39";;
|
||||
O|BLACK_BG) echo_ "40";;
|
||||
R|RED_BG) echo_ "41";;
|
||||
G|GREEN_BG) echo_ "42";;
|
||||
Y|YELLOW_BG) echo_ "43";;
|
||||
B|BLUE_BG) echo_ "44";;
|
||||
M|MAGENTA_BG) echo_ "45";;
|
||||
C|CYAN_BG) echo_ "46";;
|
||||
W|WHITE_BG) echo_ "47";;
|
||||
DEFAULT_BG) echo_ "49";;
|
||||
@|BOLD) echo_ "1";;
|
||||
-|FAINT) echo_ "2";;
|
||||
_|UNDERLINED) echo_ "4";;
|
||||
~|REVERSE) echo_ "7";;
|
||||
n|NORMAL) echo_ "22";;
|
||||
esac
|
||||
sep=1
|
||||
shift
|
||||
done
|
||||
echo_ "m"
|
||||
}
|
||||
function get_color() {
|
||||
[ -n "$NO_COLORS" ] && return
|
||||
__get_color "$@"
|
||||
}
|
||||
function __set_no_colors() {
|
||||
if [ -z "$1" ]; then
|
||||
if [ -n "$UTOOLS_NO_COLORS" ]; then NO_COLORS=1
|
||||
elif out_isatty && err_isatty; then NO_COLORS=
|
||||
else NO_COLORS=1
|
||||
fi
|
||||
else
|
||||
is_yes "$1" && NO_COLORS=1 || NO_COLORS=
|
||||
fi
|
||||
COULEUR_ROUGE="$(get_color RED BOLD)"
|
||||
COULEUR_VERTE="$(get_color GREEN BOLD)"
|
||||
COULEUR_JAUNE="$(get_color YELLOW BOLD)"
|
||||
COULEUR_BLEUE="$(get_color BLUE BOLD)"
|
||||
COULEUR_BLANCHE="$(get_color WHITE BOLD)"
|
||||
COULEUR_NORMALE="$(get_color RESET)"
|
||||
}
|
||||
__set_no_colors
|
||||
|
||||
function __eerror() { tooenc "$(__edate)${__tlevel}${COULEUR_ROUGE}* error:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __ewarn() { tooenc "$(__edate)${__tlevel}${COULEUR_JAUNE}* warning:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __enote() { tooenc "$(__edate)${__tlevel}${COULEUR_VERTE}* note:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __ebanner() {
|
||||
local maxi="${COLUMNS:-80}"
|
||||
local -a lines
|
||||
local psfix line
|
||||
|
||||
psfix="$(__edate)${__tlevel}"
|
||||
while [ ${#psfix} -lt $maxi ]; do psfix="$psfix="; done
|
||||
|
||||
tooenc "$COULEUR_ROUGE$psfix"
|
||||
maxi=$(($maxi - 1))
|
||||
array_from_xlines lines "$1"
|
||||
for line in "" "${lines[@]}" ""; do
|
||||
line="$(__edate)${__tlevel}= $line"
|
||||
if [ ${#line} -le $maxi ]; then
|
||||
while [ ${#line} -lt $maxi ]; do line="$line "; done
|
||||
line="$line="
|
||||
fi
|
||||
tooenc "$line"
|
||||
done
|
||||
tooenc "$psfix$COULEUR_NORMALE"
|
||||
}
|
||||
function __eimportant() { tooenc "$(__edate)${__tlevel}${COULEUR_ROUGE}* important:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __eattention() { tooenc "$(__edate)${__tlevel}${COULEUR_JAUNE}* attention:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __einfo() { tooenc "$(__edate)${__tlevel}${COULEUR_BLEUE}* info:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __edebug() { tooenc "$(__edate)${__tlevel}${COULEUR_BLANCHE}* debug:${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estep() { tooenc "$(__edate)${__tlevel}${COULEUR_BLANCHE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepe() { tooenc "$(__edate)${__tlevel}${COULEUR_ROUGE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepw() { tooenc "$(__edate)${__tlevel}${COULEUR_JAUNE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepn() { tooenc "$(__edate)${__tlevel}${COULEUR_VERTE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepi() { tooenc "$(__edate)${__tlevel}${COULEUR_BLEUE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estep_() { tooenc_ "$(__edate)${__tlevel}${COULEUR_BLANCHE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepe_() { tooenc_ "$(__edate)${__tlevel}${COULEUR_ROUGE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepw_() { tooenc_ "$(__edate)${__tlevel}${COULEUR_JAUNE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepn_() { tooenc_ "$(__edate)${__tlevel}${COULEUR_VERTE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __estepi_() { tooenc_ "$(__edate)${__tlevel}${COULEUR_BLEUE}*${COULEUR_NORMALE} $(__indent "$1")"; }
|
||||
function __etitle() { tooenc "$(__edate)${__tlevel}${COULEUR_BLEUE}+++ $(get_color _)$(__indent "$1")${COULEUR_NORMALE}"; }
|
||||
function __ebegin() { tooenc_ "$(__edate)${__tlevel}${COULEUR_BLANCHE}*${COULEUR_NORMALE} $(__indent "$1"): "; }
|
||||
function __edoto() { echo_ "."; }
|
||||
function __edotw() { echo_ "${COULEUR_JAUNE}w${COULEUR_NORMALE}"; }
|
||||
function __edotx() { echo_ "${COULEUR_ROUGE}x${COULEUR_NORMALE}"; }
|
||||
function __edotp() { echo_ "${COULEUR_JAUNE}+${COULEUR_NORMALE}"; }
|
||||
function __edotd() { tooenc "($1)"; }
|
||||
function __eendo() { echo "${COULEUR_VERTE}[ok]${COULEUR_NORMALE}"; }
|
||||
function __eendx() { echo "${COULEUR_ROUGE}[error]${COULEUR_NORMALE}"; }
|
||||
|
||||
# 5=afficher les messages de debug; 4=afficher les message verbeux;
|
||||
# 3=afficher les message informatifs; 2=afficher les warnings et les notes;
|
||||
# 1=afficher les erreurs; 0=ne rien afficher
|
||||
export __verbosity
|
||||
[ -z "$__verbosity" ] && __verbosity=3
|
||||
function set_verbosity() {
|
||||
[ -z "$__verbosity" ] && __verbosity=3
|
||||
case "$1" in
|
||||
-Q|--very-quiet) __verbosity=0;;
|
||||
-q|--quiet) [ "$__verbosity" -gt 0 ] && let __verbosity=$__verbosity-1;;
|
||||
-v|--verbose) [ "$__verbosity" -lt 5 ] && let __verbosity=$__verbosity+1;;
|
||||
-c|--default) __verbosity=3;;
|
||||
-D|--debug) __verbosity=5; DEBUG=1;;
|
||||
*) return 1;;
|
||||
esac
|
||||
return 0
|
||||
}
|
||||
# 3=interaction maximale; 2=interaction par défaut
|
||||
# 1= interaction minimale; 0=pas d'interaction
|
||||
export __interaction
|
||||
[ -z "$__interaction" ] && __interaction=2
|
||||
function set_interaction() {
|
||||
[ -z "$__interaction" ] && __interaction=2
|
||||
case "$1" in
|
||||
-b|--batch) __interaction=0;;
|
||||
-y|--automatic) [ "$__interaction" -gt 0 ] && let __interaction=$__interaction-1;;
|
||||
-i|--interactive) [ "$__interaction" -lt 3 ] && let __interaction=$__interaction+1;;
|
||||
-c|--default) __interaction=2;;
|
||||
*) return 1;;
|
||||
esac
|
||||
return 0
|
||||
}
|
||||
# Variable à inclure pour lancer automatiquement set_verbosity et
|
||||
# set_interaction en fonction des arguments de la ligne de commande. A utiliser
|
||||
# de cette manière:
|
||||
# parse_opts ... "${PRETTYOPTS[@]}" @ args -- ...
|
||||
PRETTYOPTS=(
|
||||
-L:,--log-to: '$elogto $value_'
|
||||
-Q,--very-quiet,-q,--quiet,-v,--verbose,-D,--debug '$set_verbosity $option_'
|
||||
-b,--batch,-y,--automatic,-i,--interactive '$set_interaction $option_'
|
||||
)
|
||||
|
||||
function show_error() { [ "$__verbosity" -ge 1 ]; }
|
||||
function show_warn() { [ "$__verbosity" -ge 2 ]; }
|
||||
function show_info() { [ "$__verbosity" -ge 3 ]; }
|
||||
function show_verbose() { [ "$__verbosity" -ge 4 ]; }
|
||||
function show_debug() { [ -n "$DEBUG" -o "$__verbosity" -ge 5 ]; }
|
||||
# Vérifier le niveau de verbosité actuel par rapport à l'argument. $1 peut valoir:
|
||||
# -Q retourner true si on peut afficher les messages d'erreur
|
||||
# -q retourner true si on peut afficher les messages d'avertissement
|
||||
# -c retourner true si on peut afficher les message normaux
|
||||
# -v retourner true si on peut afficher les messages verbeux
|
||||
# -D retourner true si on peut afficher les messages de debug
|
||||
function check_verbosity() {
|
||||
case "$1" in
|
||||
-Q|--very-quiet) [ "$__verbosity" -ge 1 ];;
|
||||
-q|--quiet) [ "$__verbosity" -ge 2 ];;
|
||||
-c|--default) [ "$__verbosity" -ge 3 ];;
|
||||
-v|--verbose) [ "$__verbosity" -ge 4 ];;
|
||||
-D|--debug) [ -n "$DEBUG" -o "$__verbosity" -ge 5 ];;
|
||||
*) return 0;;
|
||||
esac
|
||||
}
|
||||
# Retourner l'option correspondant au niveau de verbosité actuel
|
||||
function get_verbosity_option() {
|
||||
case "$__verbosity" in
|
||||
0) echo --very-quiet;;
|
||||
1) echo --quiet --quiet;;
|
||||
2) echo --quiet;;
|
||||
4) echo --verbose;;
|
||||
5) echo --debug;;
|
||||
esac
|
||||
}
|
||||
# Vérifier le niveau d'interaction autorisé par rapport à l'argument. Par
|
||||
# exemple, 'check_interaction -y' signifie "Il ne faut interagir avec
|
||||
# l'utilisateur qu'à partir du niveau d'interaction -y. Suis-je dans les
|
||||
# condition voulues pour autoriser l'interaction?"
|
||||
# $1 peut valoir:
|
||||
# -b retourner true
|
||||
# -y retourner true si on est au moins en interaction minimale
|
||||
# -c retourner true si on est au moins en interaction normale
|
||||
# -i retourner true si on est au moins en interaction maximale
|
||||
function check_interaction() {
|
||||
case "$1" in
|
||||
-b|--batch) return 0;;
|
||||
-y|--automatic) [ -n "$__interaction" -a "$__interaction" -ge 1 ];;
|
||||
-c|--default) [ -n "$__interaction" -a "$__interaction" -ge 2 ];;
|
||||
-i|--interactive) [ -n "$__interaction" -a "$__interaction" -ge 3 ];;
|
||||
*) return 0;;
|
||||
esac
|
||||
}
|
||||
# Vérifier le niveau d'interaction dans lequel on se trouve actuellement. $1
|
||||
# peut valoir:
|
||||
# -b retourner true si l'une des options -b ou -yy a été spécifiée
|
||||
# -Y retourner true si l'une des options -b, -yy, ou -y a été spécifiée
|
||||
# -y retourner true si l'option -y a été spécifiée
|
||||
# -c retourner true si aucune option n'a été spécifiée
|
||||
# -i retourner true si l'option -i a été spécifiée
|
||||
# -C retourner true si aucune option ou l'option -i ont été spécifiés
|
||||
function is_interaction() {
|
||||
case "$1" in
|
||||
-b|--batch) [ -n "$__interaction" -a "$__interaction" -eq 0 ];;
|
||||
-Y) [ -n "$__interaction" -a "$__interaction" -le 1 ];;
|
||||
-y|--automatic) [ -n "$__interaction" -a "$__interaction" -eq 1 ];;
|
||||
-c|--default) [ -n "$__interaction" -a "$__interaction" -eq 2 ];;
|
||||
-i|--interactive) [ -n "$__interaction" -a "$__interaction" -eq 3 ];;
|
||||
-C) [ -n "$__interaction" -a "$__interaction" -ge 2 ];;
|
||||
*) return 1;;
|
||||
esac
|
||||
}
|
||||
# Retourner l'option correspondant au niveau d'interaction actuel
|
||||
function get_interaction_option() {
|
||||
case "$__interaction" in
|
||||
0) echo --batch;;
|
||||
1) echo --automatic;;
|
||||
3) echo --interactive;;
|
||||
esac
|
||||
}
|
||||
|
||||
##XXX les fonctions ci-dessous restent à migrer
|
||||
##function edot() {
|
||||
## # Une étape d'une opération commencée par ebegin, matérialisée par un "."
|
||||
## # Si l'argument est un fichier, utiliser -f pour que "$HOME" et "$(pwd)/"
|
||||
## # soient remplacés respectivement par "~" et "" (afin que les chemins soient
|
||||
## # plus courts)
|
||||
## # Si l'argument est un commentaire, utiliser -m pour le spécifier. -w
|
||||
## # indique que l'argument est un warning: un x jaune est affiché, avec le
|
||||
## # message associé si on est en mode debug.
|
||||
## # Sinon, l'argument est un status. 0 affiche un ".", sinon on affiche un "x"
|
||||
## local status=$?
|
||||
## local warn= color=
|
||||
##
|
||||
## if [ -n "$utools_edot_first_" ]; then
|
||||
## # au premier dot, afficher un espace d'abord
|
||||
## echo_ " "
|
||||
## utools_edot_first_=
|
||||
## fi
|
||||
##
|
||||
## eval `check_verbosity --action "$1" 2`
|
||||
## if is_debug; then
|
||||
## local msg paths path
|
||||
## if [ "$1" = "-f" ]; then
|
||||
## # chemins
|
||||
## shift
|
||||
## for path in "$@"; do
|
||||
## paths="${paths:+$paths,}$(ppath "$path")"
|
||||
## done
|
||||
## msg="$paths"
|
||||
## elif [ "$1" = "-m" -o "$1" = "-w" ]; then
|
||||
## # message
|
||||
## [ "$1" = "-w" ] && warn=1 # message de warning
|
||||
## shift
|
||||
## msg="$(tooenc "$*")"
|
||||
## else
|
||||
## # status
|
||||
## [ -n "$1" ] && status="$1"
|
||||
## fi
|
||||
##
|
||||
## [ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
|
||||
## if [ "$status" -eq 0 -a -z "$warn" ]; then
|
||||
## echo_ "${msg:+
|
||||
## }.${msg:+($msg)}"
|
||||
## else
|
||||
## color="$COULEUR_ROUGE"
|
||||
## [ -n "$warn" ] && color="$COULEUR_JAUNE"
|
||||
## echo_ "${msg:+
|
||||
## }${color}x${COULEUR_NORMALE}${msg:+($msg)}"
|
||||
## fi
|
||||
## else
|
||||
## if [ "$1" = "-f" -o "$1" = "-m" -o "$1" = "-w" ]; then
|
||||
## [ "$1" = "-w" ] && warn=1 # message de warning
|
||||
## shift
|
||||
## else
|
||||
## [ -n "$1" ] && status="$1"
|
||||
## fi
|
||||
##
|
||||
## [ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
|
||||
## if [ "$status" -eq 0 -a -z "$warn" ]; then
|
||||
## echo_ "."
|
||||
## else
|
||||
## color="$COULEUR_ROUGE"
|
||||
## [ -n "$warn" ] && color="$COULEUR_JAUNE"
|
||||
## echo_ "${color}x${COULEUR_NORMALE}"
|
||||
## fi
|
||||
## fi
|
||||
##}
|
||||
78
ulib/redhat
78
ulib/redhat
@@ -1,78 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Outils pour les distributions redhat
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
##@require service
|
||||
uprovide redhat
|
||||
urequire base sysinfos service
|
||||
|
||||
################################################################################
|
||||
# Gestion des packages
|
||||
|
||||
function pkg_check() {
|
||||
# Vérifier que les packages sont installés sur le système
|
||||
local pkg
|
||||
for pkg in "$@"; do
|
||||
rpm -q "$pkg" >/dev/null || return 1
|
||||
done
|
||||
return 0
|
||||
}
|
||||
|
||||
function pkg_update() {
|
||||
# Mettre à jour la liste des packages silencieusement sans confirmation
|
||||
LANG=C yum check-update -q
|
||||
}
|
||||
|
||||
function pkg_upgrade() {
|
||||
# Mettre à jour la liste des packages silencieusement sans confirmation
|
||||
LANG=C yum update -qy
|
||||
}
|
||||
|
||||
function pkg_install() {
|
||||
# Installer les packages silencieusement et sans confirmation
|
||||
if check_sysinfos -v rhel4 centos4 redhat4 -b 64; then
|
||||
LANG=C up2date --channel=rhel-x86_64-es-4 "${pkgs[@]}"
|
||||
#elif check_sysinfos -v rhel4 centos4 redhat4 -b 32; then
|
||||
# LANG=C up2date --channel=rhel-i386-es-4 "${pkgs[@]}"
|
||||
else
|
||||
LANG=C yum install -qy "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
function pkg_installm() {
|
||||
# Installer les packages silencieusement et sans confirmation
|
||||
# Retourner 0 si au moins un des packages a été installé. Sinon, les
|
||||
# packages n'ont pas été instllés, soit parce qu'ils sont déjà installé,
|
||||
# soit parce qu'il y a eu une erreur.
|
||||
if ! pkg_check "$@"; then
|
||||
# essayer d'installer les packages
|
||||
pkg_install "$@"
|
||||
else
|
||||
# aucun package n'a été installé
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Gestion des services
|
||||
|
||||
function service_disable() {
|
||||
# Désactiver le service $1 pour qu'il ne se lance pas automatiquement au
|
||||
# démarrage
|
||||
chkconfig "$1" off
|
||||
}
|
||||
|
||||
function service_enable() {
|
||||
# Activer le service $1 pour qu'il se lance automatiquement au démarrage
|
||||
chkconfig "$1" on
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Gestion des interfaces réseau
|
||||
|
||||
function create_bridge() {
|
||||
# Créer un nouveau pont nommé $1 avec les paramètres $2
|
||||
eerror "non implémenté"
|
||||
return 1
|
||||
}
|
||||
231
ulib/semver
231
ulib/semver
@@ -1,231 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Versionnage sémantique
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide semver
|
||||
urequire base
|
||||
|
||||
function __semver_check_version() { [ -z "${1//[a-zA-Z0-9.+-]/}" ]; }
|
||||
function __semver_check_prelease() { [ -z "${1//[a-zA-Z0-9.-]/}" ]; }
|
||||
function __semver_check_metadata() { [ -z "${1//[a-zA-Z0-9.-]/}" ]; }
|
||||
|
||||
function semver_parse() {
|
||||
local __p_ver="$1"
|
||||
local __p_ma="${2:-major}" __p_mi="${3:-minor}" __p_pl="${4:-patchlevel}"
|
||||
local __p_pr="${5:-prelease}" __p_md="${6:-metadata}" __p_va="${7:-valid}"
|
||||
local __p_tmp
|
||||
set_var "$__p_ma" ""
|
||||
set_var "$__p_mi" ""
|
||||
set_var "$__p_pl" ""
|
||||
array_new "$__p_pr"
|
||||
array_new "$__p_md"
|
||||
set_var "$__p_va" ""
|
||||
|
||||
# vérifier les caractères valides
|
||||
__semver_check_version "$__p_ver" || return 1
|
||||
|
||||
# extraire major
|
||||
__p_tmp=
|
||||
while [ "${__p_ver/#[0-9]/}" != "$__p_ver" ]; do
|
||||
__p_tmp="$__p_tmp${__p_ver:0:1}"
|
||||
__p_ver="${__p_ver:1}"
|
||||
done
|
||||
[ "${__p_ver:0:1}" == . ] || return 1
|
||||
__p_ver="${__p_ver:1}"
|
||||
set_var "$__p_ma" "$__p_tmp"
|
||||
|
||||
# extraire minor
|
||||
__p_tmp=
|
||||
while [ "${__p_ver/#[0-9]/}" != "$__p_ver" ]; do
|
||||
__p_tmp="$__p_tmp${__p_ver:0:1}"
|
||||
__p_ver="${__p_ver:1}"
|
||||
done
|
||||
[ "${__p_ver:0:1}" == . ] || return 1
|
||||
__p_ver="${__p_ver:1}"
|
||||
set_var "$__p_mi" "$__p_tmp"
|
||||
|
||||
# extraire patchlevel
|
||||
__p_tmp=
|
||||
while [ "${__p_ver/#[0-9]/}" != "$__p_ver" ]; do
|
||||
__p_tmp="$__p_tmp${__p_ver:0:1}"
|
||||
__p_ver="${__p_ver:1}"
|
||||
done
|
||||
[ -z "$__p_ver" -o "${__p_ver:0:1}" == - -o "${__p_ver:0:1}" == + ] || return 1
|
||||
set_var "$__p_pl" "$__p_tmp"
|
||||
|
||||
# extraire prelease
|
||||
if [ "${__p_ver:0:1}" == - ]; then
|
||||
__p_ver="${__p_ver:1}"
|
||||
if [[ "$__p_ver" == *+* ]]; then
|
||||
__p_tmp="${__p_ver%%+*}"
|
||||
__p_ver="+${__p_ver##*+}"
|
||||
else
|
||||
__p_tmp="$__p_ver"
|
||||
__p_ver=
|
||||
fi
|
||||
__semver_check_prelease "$__p_tmp" || return 1
|
||||
array_split "$__p_pr" "$__p_tmp" .
|
||||
fi
|
||||
|
||||
# extraire metadata
|
||||
if [ "${__p_ver:0:1}" == + ]; then
|
||||
__p_ver="${__p_ver:1}"
|
||||
__p_tmp="$__p_ver"
|
||||
__p_ver=
|
||||
__semver_check_metadata "$__p_tmp" || return 1
|
||||
array_split "$__p_md" "$__p_tmp" .
|
||||
fi
|
||||
|
||||
# on doit avoir tout analysé
|
||||
[ -z "$__p_ver" ] || return 1
|
||||
|
||||
set_var "$__p_va" 1
|
||||
return 0
|
||||
}
|
||||
|
||||
function semver_incmajor() {
|
||||
set_var "$1" $((${!1} + 1))
|
||||
set_var "$2" 0
|
||||
set_var "$3" 0
|
||||
array_new "$4"
|
||||
}
|
||||
|
||||
function semver_incminor() {
|
||||
set_var "$2" $((${!2} + 1))
|
||||
set_var "$3" 0
|
||||
array_new "$4"
|
||||
}
|
||||
|
||||
function semver_incpatchlevel() {
|
||||
set_var "$3" $((${!3} + 1))
|
||||
array_new "$4"
|
||||
}
|
||||
|
||||
function semver_setversion() {
|
||||
local __sv_ma __sv_mi __sv_svl __sv_svr __sv_md __sv_va
|
||||
semver_parse "$1" __sv_ma __sv_mi __sv_pl __sv_pr __sv_md __sv_va
|
||||
[ -n "$__sv_va" ] || return 1
|
||||
set_var "$2" "$__sv_ma"
|
||||
set_var "$3" "$__sv_mi"
|
||||
set_var "$4" "$__sv_pl"
|
||||
return 0
|
||||
}
|
||||
|
||||
function semver_setprelease() {
|
||||
if [ -n "$1" ]; then
|
||||
__semver_check_prelease "$1" || return 1
|
||||
array_split "$5" "$1" .
|
||||
else
|
||||
array_new "$5"
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
function semver_compare_prelease() {
|
||||
local -a __cp_pr1 __cp_pr2 __cp_len i __cp_v1 __cp_v2
|
||||
array_copy __cp_pr1 "$1"
|
||||
array_copy __cp_pr2 "$2"
|
||||
if [ ${#__cp_pr1[*]} -eq 0 -a ${#__cp_pr2[*]} -eq 0 ]; then
|
||||
# final == final
|
||||
echo eq; return
|
||||
elif [ ${#__cp_pr1[*]} -gt 0 -a ${#__cp_pr2[*]} -eq 0 ]; then
|
||||
# prelease < final
|
||||
echo lt; return
|
||||
elif [ ${#__cp_pr1[*]} -eq 0 -a ${#__cp_pr2[*]} -gt 0 ]; then
|
||||
# final > prelease
|
||||
echo gt; return
|
||||
fi
|
||||
# calculer le nombre d'éléments à comparer dans les deux tableaux soit
|
||||
# min(len(__cp_pr1), len(__cp_pr2))
|
||||
__cp_len=${#__cp_pr1[*]}
|
||||
[ ${#__cp_pr2[*]} -lt $__cp_len ] && __cp_len=${#__cp_pr2[*]}
|
||||
# comparer __cp_len éléments
|
||||
i=0
|
||||
while [ $i -lt $__cp_len ]; do
|
||||
__cp_v1="${__cp_pr1[$i]}"
|
||||
__cp_v2="${__cp_pr2[$i]}"
|
||||
if [ "$__cp_v1" == "$__cp_v2" ]; then
|
||||
:
|
||||
elif isnum "$__cp_v1" && isnum "$__cp_v2"; then
|
||||
if [ $__cp_v1 -lt $__cp_v2 ]; then
|
||||
echo lt; return
|
||||
elif [ $__cp_v1 -gt $__cp_v2 ]; then
|
||||
echo gt; return
|
||||
fi
|
||||
elif isnum "$__cp_v1"; then
|
||||
echo lt; return
|
||||
elif isnum "$__cp_v2"; then
|
||||
echo gt; return
|
||||
else
|
||||
# comparaison chaine
|
||||
if [ "$(echo "$__cp_v1"$'\n'"$__cp_v2" | LANG=C sort | head -n1)" == "$__cp_v1" ]; then
|
||||
echo lt; return
|
||||
else
|
||||
echo gt; return
|
||||
fi
|
||||
fi
|
||||
i=$(($i + 1))
|
||||
done
|
||||
# comparer ce qui reste
|
||||
__cp_pr1=("${__cp_pr1[@]:$__cp_len}")
|
||||
__cp_pr2=("${__cp_pr2[@]:$__cp_len}")
|
||||
if [ ${#__cp_pr1[*]} -gt 0 ]; then
|
||||
echo gt; return
|
||||
elif [ ${#__cp_pr2[*]} -gt 0 ]; then
|
||||
echo lt; return
|
||||
fi
|
||||
# en définitive, c'est égal
|
||||
echo eq
|
||||
}
|
||||
|
||||
function semver_setmetadata() {
|
||||
if [ -n "$1" ]; then
|
||||
__semver_check_metadata "$1" || return 1
|
||||
array_split "$6" "$1" .
|
||||
else
|
||||
array_new "$5"
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
function semver_compare_metadata() {
|
||||
# même algo que pour prelease
|
||||
semver_compare_prelease "$@"
|
||||
}
|
||||
|
||||
function semver_copy() {
|
||||
set_var "$1" "${!6}"
|
||||
set_var "$2" "${!7}"
|
||||
set_var "$3" "${!8}"
|
||||
array_copy "$4" "$9"
|
||||
array_copy "$5" "${10}"
|
||||
}
|
||||
|
||||
function semver_build() {
|
||||
echo_ "${!1}.${!2}.${!3}"
|
||||
array_isempty "$4" || rawecho_ "-$(array_join "$4" .)"
|
||||
array_isempty "$5" || rawecho_ "+$(array_join "$5" .)"
|
||||
echo ""
|
||||
}
|
||||
|
||||
function semver_setvar() {
|
||||
set_var "$1" "$(semver_build "$2" "$3" "$4" "$5" "$6")"
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Les fonctions psemver_* sont comme semver_* mais les noms de variables sont
|
||||
# standardisés (major, minor, pathchlevel, prelease, metadata) et l'on spécifie
|
||||
# uniquement un préfixe pour les noms de variable
|
||||
|
||||
function psemver_parse() { semver_parse "$1" "${2}major" "${2}minor" "${2}patchlevel" "${2}prelease" "${2}metadata" "${2}valid"; }
|
||||
function psemver_incmajor() { semver_incmajor "${1}major" "${1}minor" "${1}patchlevel" "${1}prelease" "${1}metadata"; }
|
||||
function psemver_incminor() { semver_incminor "${1}major" "${1}minor" "${1}patchlevel" "${1}prelease" "${1}metadata"; }
|
||||
function psemver_incpatchlevel() { semver_incpatchlevel "${1}major" "${1}minor" "${1}patchlevel" "${1}prelease" "${1}metadata"; }
|
||||
function psemver_setversion() { semver_setversion "$1" "${2}major" "${2}minor" "${2}patchlevel" "${2}prelease" "${2}metadata"; }
|
||||
function psemver_setprelease() { semver_setprelease "$1" "${2}major" "${2}minor" "${2}patchlevel" "${2}prelease" "${2}metadata"; }
|
||||
function psemver_compare_prelease() { semver_compare_prelease "${1}prelease" "${2}prelease"; }
|
||||
function psemver_setmetadata() { semver_setmetadata "$1" "${2}major" "${2}minor" "${2}patchlevel" "${2}prelease" "${2}metadata"; }
|
||||
function psemver_compare_metadata() { semver_compare_metadata "${1}metadata" "${2}metadata"; }
|
||||
function psemver_copy() { semver_copy "${1}major" "${1}minor" "${1}patchlevel" "${1}prelease" "${1}metadata" "${2}major" "${2}minor" "${2}patchlevel" "${2}prelease" "${2}metadata"; }
|
||||
function psemver_build() { semver_build "${1}major" "${1}minor" "${1}patchlevel" "${1}prelease" "${1}metadata"; }
|
||||
function psemver_setvar() { semver_setvar "$1" "${2}major" "${2}minor" "${2}patchlevel" "${2}prelease" "${2}metadata"; }
|
||||
67
ulib/service
67
ulib/service
@@ -1,67 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Des outils pour contrôler les services unix
|
||||
##@cooked nocomments
|
||||
uprovide service
|
||||
urequire sysinfos
|
||||
|
||||
function __service() {
|
||||
# Appliquer la commande $2 au service $1, e.g. 'service daemon restart'
|
||||
# Si la variable SERVICE_OVERRIDE_$1_$2 existe, utiliser la fonction dont le
|
||||
# nom est donnée par cette variable pour faire l'opération. Si la valeur est
|
||||
# 1, prendre la fonction nommée SERVICE_OVERRIDE_$1_$2
|
||||
# Pour information, le nom de la variable est corrigé en remplaçant '-' par
|
||||
# '_'. Ceci permet d'utiliser des noms de services avec des '-' dans leur
|
||||
# nom.
|
||||
# XXX ajouter le support de MacOS X
|
||||
local overriden="SERVICE_OVERRIDE_${1}_${2}" overridef
|
||||
overriden="${overriden//-/_}"
|
||||
overridef="${!overriden}"
|
||||
if [ -n "$overridef" ]; then
|
||||
[ "$overridef" == 1 ] && overridef="$overriden"
|
||||
"$overridef" "$@"
|
||||
elif [ -x /usr/sbin/service ]; then
|
||||
/usr/sbin/service "$@"
|
||||
else
|
||||
local script="$1"; shift
|
||||
"/etc/init.d/$script" "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
function service() {
|
||||
if [ "$2" == check ]; then
|
||||
__service "$1" status >&/dev/null
|
||||
elif [ "$2" == startm ]; then
|
||||
__service "$1" status >&/dev/null || __service "$1" start
|
||||
elif [ "$2" == stopm ]; then
|
||||
__service "$1" status >&/dev/null && __service "$1" stop
|
||||
elif [ "$2" == restartm ]; then
|
||||
__service "$1" status >&/dev/null && __service "$1" restart
|
||||
else
|
||||
__service "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
function service_start() {
|
||||
# démarrer le service $1 de façon inconditionnelle
|
||||
service "$1" start
|
||||
}
|
||||
function service_startm() {
|
||||
# démarrer le service $1 s'il n'est pas déjà démarré
|
||||
service "$1" startm
|
||||
}
|
||||
function service_stop() {
|
||||
# arrêter le service $1 de façon inconditionnelle
|
||||
service "$1" stop
|
||||
}
|
||||
function service_stopm() {
|
||||
# arrêter le service $1 s'il n'est pas déjà arrêté
|
||||
service "$1" stopm
|
||||
}
|
||||
function service_reload() {
|
||||
# recharger le service $1
|
||||
service "$1" reload
|
||||
}
|
||||
function service_status() {
|
||||
# tester/afficher le status du service $1
|
||||
service "$1" status
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Support des scripts CGI attaqués par un lien symbolique
|
||||
##@cooked nocomments
|
||||
# Ce fichier doit être inclu avec uinc
|
||||
# Si le script qui inclu ce fichier est lancé comme script CGI par un lien, il
|
||||
# doit pouvoir accéder à ses fichiers de support à partir de son répertoire
|
||||
# d'origine. Ce fichier permet de s'assurer que scriptdir a la bonne valeur.
|
||||
# cgiscriptdir contient la valeur d'origine, c'est à dire le répertoire cgi à
|
||||
# partir duquel le script est lancé.
|
||||
cgiscriptdir="$(cd "$(dirname -- "$0")"; pwd)"
|
||||
cgiscriptname="$(basename -- "$0")"
|
||||
if [ "$(uname -s)" == Linux ]; then
|
||||
script="$(readlink -f -- "$0")"
|
||||
else
|
||||
# Sur un système autre que linux, les options avancées (-f, -e, -m) de
|
||||
# readlink n'existent sans doute pas. Implémenter en bash l'équivalent de
|
||||
# readlink -m
|
||||
script="$(
|
||||
function __normpath() { local p="$1" np f; [ "${p#/}" == "$p" ] && p="$(pwd)/$p"; while [[ "$p" == *//* ]]; do p="${p//\/\///}"; done; p="${p%/}"; p="${p#/}"; np=; while [ -n "$p" ]; do if [[ "$p" == */* ]]; then f="${p%%/*}"; p="${p#*/}"; else f="$p"; p=; fi; if [ "$f" == . ]; then :; elif [ "$f" == .. ]; then if [[ "$np" == */* ]]; then np="${np%/*}"; else np=; fi; else [ -n "$np" ] && np="$np/"; np="$np$f"; fi; done; echo "/$np"; }
|
||||
function __readlinkm() { local p="$(__normpath "$1")" np n; while [ -n "$p" ]; do local max=50; while [ -L "$p" -a $max -gt 0 ]; do n="$(readlink "$p")"; if [ "${n#/}" != "$n" ]; then p="$n"; else p="${p%/*}/$n"; fi; p="$(__normpath "$p")"; max=$(($max-1)); done; [ -n "$np" ] && np="/$np"; if [[ "$p" == */* ]]; then np="${p##*/}$np"; p="${p%/*}"; else np="$p$np"; p=; fi; done; echo "/$np"; }
|
||||
__readlinkm "$0"
|
||||
)"
|
||||
fi
|
||||
scriptdir="$(dirname -- "$script")"
|
||||
scriptname="$(basename -- "$script")"
|
||||
UTOOLS_HAVE_SCRIPTVARS=1
|
||||
# Juste après avoir inclu ce fichier, on peut rajouter une ligne comme celle-ci
|
||||
# pour charger ulib:
|
||||
#source "$scriptdir/ulib/auto"
|
||||
@@ -1,114 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 mode: python -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
u"""Ce script est prévu pour être utilisé dans un script CGI.
|
||||
Il enregistre les fichiers uploadés dans le répertoire spécifié, et éventuellement lance une commande avec comme argument les fichiers enregistrés.
|
||||
"""
|
||||
|
||||
import sys, os, types, cgi, tempfile
|
||||
from os import path
|
||||
|
||||
cgitb = None # marqueur pour savoir si le module cgitb a été importé
|
||||
#import cgitb; cgitb.enable()
|
||||
|
||||
class FileManager(object):
|
||||
def __init__(self, destdir=None, parse_env=True):
|
||||
if destdir is None: destdir = '/tmp'
|
||||
self.fileinfos = []
|
||||
self.count = 0
|
||||
self.destdir = destdir
|
||||
if parse_env: self.parse_env()
|
||||
|
||||
def parse_env(self):
|
||||
class FieldStorage(cgi.FieldStorage):
|
||||
def make_file(self, binary=None):
|
||||
return self.fm._new_file(self)
|
||||
FieldStorage.fm = self
|
||||
self.form = FieldStorage()
|
||||
|
||||
def _new_file(self, form):
|
||||
fp = path.join(self.destdir, 'upload%i' % self.count)
|
||||
outf = open(fp, 'w+b')
|
||||
self.count += 1
|
||||
self.fileinfos.append((form.name, form.filename, fp, form.type))
|
||||
return outf
|
||||
|
||||
def write_csv(self, outf):
|
||||
close = False
|
||||
if type(outf) is types.StringType:
|
||||
outf = open(outf, 'w+b')
|
||||
close = True
|
||||
try:
|
||||
outf.write("name,value,file,type\n")
|
||||
for fi in self.fileinfos:
|
||||
outf.write("%s,%s,%s,%s\n" % fi)
|
||||
finally:
|
||||
if close: outf.close()
|
||||
|
||||
# Analyser les options
|
||||
from optparse import OptionParser
|
||||
parser = OptionParser(usage=u"\n\t%prog [options]\n\t%prog [options] -c command [args]", description=__doc__)
|
||||
parser.add_option('-d', '--destdir', dest='destdir',
|
||||
help=u"Spécifier le répertoire de destination des fichiers uploadés. Ce répertoire est créé si nécessaire.")
|
||||
parser.add_option('-p', '--printcsv', action='store_true', dest='printcsv',
|
||||
help=u"Afficher la liste des fichiers uploadés au format CSV. Chaque ligne est de la forme 'name,value,file,type' où name est le nom du champ dans le formulaire http, value le nom du fichier tel qu'il a été fourni par le client, file le chemin complet vers le fichier uploadé, et type le type mime du contenu.")
|
||||
parser.add_option('-c', '--cmd', action='store_true', dest='cmd',
|
||||
help=u"Lancer une commande après avoir enregistré les fichiers. Implique --remove")
|
||||
parser.add_option('-G', '--infos', action='store_const', const='infos', dest='argtype',
|
||||
help=u"La commande est lancée avec 4 arguments pour chaque fichier uploadé. Les arguments sont fournis dans l'ordre donné par l'option -p. C'est l'option par défaut.")
|
||||
parser.add_option('-F', '--files', action='store_const', const='files', dest='argtype',
|
||||
help=u"La commande est lancée avec en argument chaque fichier uploadé, correspondant à la colonne file de l'option -p")
|
||||
parser.add_option('-C', '--csv', action='store_const', const='csv', dest='argtype',
|
||||
help=u"La commande est lancée avec en argument un fichier au format CSV qui liste les fichiers uploadés. Cf l'option -p pour le format de ce fichier.")
|
||||
parser.set_defaults(argtype='infos')
|
||||
parser.add_option('--remove', action='store_true', dest='clear',
|
||||
help=u"Supprimer les fichiers uploadés.")
|
||||
parser.add_option('-k', '--keep', action='store_false', dest='clear',
|
||||
help=u"Ne pas supprimer les fichiers uploadés. Utiliser cette option avec -c pour garder les fichiers uploadés.")
|
||||
parser.add_option('--devel', action='store_true', dest='devel',
|
||||
help=u"Activer le mode développement: le module cgitb est chargé et activé.")
|
||||
o, args = parser.parse_args()
|
||||
|
||||
if o.devel and cgitb is None:
|
||||
import cgitb; cgitb.enable()
|
||||
|
||||
# Créer destdir le cas échéant
|
||||
if o.destdir is not None and not path.isdir(o.destdir):
|
||||
os.makedirs(o.destdir)
|
||||
|
||||
# Si aucune commande n'est spécifiée, afficher la liste des fichiers au format CSV
|
||||
if o.printcsv is None and o.cmd is None:
|
||||
o.printcsv = True
|
||||
|
||||
# Avec -c, par défaut supprimer les fichiers
|
||||
if o.cmd and o.clear is None:
|
||||
o.clear = True
|
||||
|
||||
fm = FileManager(o.destdir)
|
||||
|
||||
if o.printcsv:
|
||||
fm.write_csv(sys.stdout)
|
||||
|
||||
if o.cmd:
|
||||
tmpfile = None
|
||||
if o.argtype == 'infos':
|
||||
for fi in fm.fileinfos:
|
||||
args.extend(fi)
|
||||
elif o.argtype == 'files':
|
||||
args.extend(map(lambda fi: fi[2], fm.fileinfos))
|
||||
elif o.argtype == 'csv':
|
||||
fd, tmpfile = tempfile.mkstemp()
|
||||
os.close(fd)
|
||||
fm.write_csv(tmpfile)
|
||||
args.append(tmpfile)
|
||||
|
||||
os.spawnvp(os.P_WAIT, args[0], args)
|
||||
|
||||
if tmpfile is not None:
|
||||
try: os.remove(tmpfile)
|
||||
except: pass
|
||||
|
||||
if o.clear:
|
||||
for fi in fm.fileinfos:
|
||||
try: os.remove(fi[0])
|
||||
except: pass
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,30 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 mode: python -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
import sys
|
||||
import random
|
||||
|
||||
try: from crypt import crypt
|
||||
except ImportError: sys.exit(1)
|
||||
|
||||
CHARS = "./abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
||||
|
||||
if __name__ == '__main__':
|
||||
args = sys.argv[1:]
|
||||
|
||||
if len(args) == 1 and args[0] == '--help':
|
||||
print """mkcrypt.py - crypter un mot de passe avec la méthode crypt
|
||||
|
||||
USAGE
|
||||
mkcrypt.py clear [salt]"""
|
||||
sys.exit(0)
|
||||
elif len(args) > 0 and args[0] == '--':
|
||||
args = args[1:]
|
||||
|
||||
clpasswd = args[0:1] and args[0] or None
|
||||
salt = args[1:2] and args[1] or random.choice(CHARS) + random.choice(CHARS)
|
||||
if clpasswd is not None:
|
||||
print crypt(clpasswd, salt)
|
||||
sys.exit(0)
|
||||
else:
|
||||
sys.exit(1)
|
||||
@@ -1,81 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 mode: python -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
u"""%(scriptname)s: Plier/déplier des inclusions dans un fichier
|
||||
|
||||
USAGE
|
||||
%(scriptname)s [[options] dest...]
|
||||
|
||||
OPTIONS
|
||||
-f Plier les inclusions
|
||||
-u Déplier les inclusions (par défaut)
|
||||
-@ Forcer le caractère '@' pour le pliage/dépliage
|
||||
-* Forcer le caractère '*' pour le pliage/dépliage
|
||||
--auto
|
||||
Activer la recherche automatique de paramètres (par défaut)
|
||||
--noauto
|
||||
Désactiver la recherche automatique de paramètres
|
||||
-I SPEC
|
||||
Spécifier des fichiers à inclure dans les répertoires spécifiés
|
||||
-X SPEC
|
||||
Spécifier des fichiers à exclure dans les répertoires spécifiés
|
||||
--refdir REFDIR
|
||||
Spécifier le répertoire de référence. Soit un répertoire DEST spécifié
|
||||
dans les arguments. Si un fichier à inclure *n'est pas* un fils du
|
||||
répertoire DEST, l'emplacement effectif du fichier est calculé en
|
||||
faisant comme si DEST==REFDIR.
|
||||
Par exemple, soit DEST=/dest/path et REFDIR=/refdir/path. Si le fichier
|
||||
/dest/path/file inclue le fichier ../inc, alors c'est le fichier
|
||||
/refdir/inc qui est considéré.
|
||||
Ceci permet de traiter les inclusions dans une copie temporaire d'un
|
||||
répertoire, dans le cas où les fichier font référence à d'autres
|
||||
fichiers situés relativement à l'emplacement original.
|
||||
|
||||
Les spécifications de fichiers sont de types glob: ils peuvent contenir les
|
||||
wildcards * et ?. Ils supportent en plus la chaine '**' qui signifie n'importe
|
||||
quelle profondeur de répertoire. 'dir/' est équivalent à 'dir/**' et signifie
|
||||
tous les fichiers situés dans l'arborescence à partir de dir.
|
||||
|
||||
La variable UINCPATH contient une liste de répertoires qui sont consultés pour
|
||||
trouver les fichiers à inclure."""
|
||||
|
||||
import os, sys
|
||||
from os import path
|
||||
|
||||
from ulib.all import *
|
||||
from ulib.p.uinc import Updater, ConsoleOutput
|
||||
|
||||
def display_help():
|
||||
uprint(__doc__ % globals())
|
||||
|
||||
def run_uinc():
|
||||
action, options, args, params = Updater.parse_options(None)
|
||||
for option, value in options:
|
||||
if option in ('-h', '--help'):
|
||||
display_help()
|
||||
sys.exit(0)
|
||||
|
||||
uincdirs = os.environ.get('UINCPATH', '').split(os.pathsep)
|
||||
uincdirs = filter(None, uincdirs)
|
||||
|
||||
updater = Updater(args, **params)
|
||||
updater.out = ConsoleOutput()
|
||||
updater.uincdirs = uincdirs
|
||||
|
||||
if updater.auto:
|
||||
auto_args = u"\n ".join([relpath(p) for p in updater.args])
|
||||
auto_msg = u"""Les fichiers/répertoires suivants seront traités:
|
||||
%s
|
||||
Cette liste a été calculée automatiquement. Vous pouvez désactiver la
|
||||
configuration automatique avec --noauto. Voulez-vous continuer?""" % auto_args
|
||||
if not ask_yesno(auto_msg, True):
|
||||
return False
|
||||
|
||||
should_update, reason = updater.should_update()
|
||||
if should_update:
|
||||
return updater.update(action)
|
||||
else:
|
||||
ewarn(u"no update because %s" % reason)
|
||||
|
||||
if __name__ == '__main__':
|
||||
raise Exit(run_uinc())
|
||||
@@ -1,32 +0,0 @@
|
||||
#!/bin/bash
|
||||
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
# charger le fichier de configuration $1 pour avoir ULIBDIR
|
||||
source "$1" || exit 1
|
||||
source "$ULIBDIR/ulib" && urequire DEFAULTS uinst || exit 1
|
||||
OENC="$UTF8"
|
||||
|
||||
is_root || die "Ce script doit être lancé avec les droits de root"
|
||||
|
||||
# recharger la configuration avec la base __uinst_defaultvars
|
||||
__uinst_defaultvars
|
||||
source "$1" || die
|
||||
|
||||
[ -n "$srcdir" ] || die "Il faut spécifier le répertoire source"
|
||||
[ -e "$srcdir" ] || die "Répertoire/Fichier source inexistant: $srcdir"
|
||||
|
||||
################################################################################
|
||||
# Copie des fichiers
|
||||
|
||||
if is_yes "$copy_files"; then
|
||||
[ -n "$destdir" ] || die "Il faut spécifier le répertoire de destination"
|
||||
etitle "Copie des fichiers" __uinst2s_copy_files || die
|
||||
fi
|
||||
|
||||
################################################################################
|
||||
# Lancement des scripts
|
||||
|
||||
if [ -n "${root_scripts[*]}" ]; then
|
||||
# passer aux script le chemin vers le fichier de configuration
|
||||
etitle "Lancement des scripts root" __uinst2s_root_scripts "$1" || die
|
||||
fi
|
||||
@@ -1,21 +0,0 @@
|
||||
#!/bin/bash
|
||||
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
# charger le fichier de configuration $1 pour avoir ULIBDIR
|
||||
source "$1" || exit 1
|
||||
source "$ULIBDIR/ulib" && urequire DEFAULTS uinst || exit 1
|
||||
OENC="$UTF8"
|
||||
|
||||
is_root || die "Ce script doit être lancé avec les droits de root"
|
||||
|
||||
# recharger la configuration avec la base __uinst_defaultvars
|
||||
__uinst_defaultvars
|
||||
source "$1" || die
|
||||
|
||||
[ -n "$srcdir" ] || die "Il faut spécifier le répertoire source"
|
||||
[ -d "$srcdir" ] || die "Répertoire source inexistant: $srcdir"
|
||||
|
||||
################################################################################
|
||||
# Installation du package python
|
||||
|
||||
etitle "Installation des packages python" __uinst2s_python_setup || die
|
||||
@@ -1,232 +0,0 @@
|
||||
#!/bin/bash
|
||||
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
source "$1" || exit 1 # pour avoir la définition de ULIBDIR
|
||||
source "$ULIBDIR/ulib" &&
|
||||
urequire DEFAULTS prefixes apache webobjects wosign ||
|
||||
exit 1
|
||||
OENC="$UTF8"
|
||||
|
||||
is_root || die "Ce script doit être lancé avec les droits de root"
|
||||
|
||||
set_defaults WOServices
|
||||
urequire wondermonitor
|
||||
|
||||
compute_apache_prefixes
|
||||
compute_webobjects_prefixes
|
||||
source "$1" # relire les éventuelles valeurs forcées pour les préfixes
|
||||
|
||||
create_wodirs_maybe
|
||||
wosign_setup_maybe
|
||||
|
||||
function rm_ifexists() {
|
||||
if [ -d "$1" ]; then
|
||||
/bin/rm -rf "$1"
|
||||
fi
|
||||
}
|
||||
|
||||
################################################################################
|
||||
|
||||
if [ -z "$webinst" ]; then
|
||||
# récupérer les informations sur le mapping bundle -> application
|
||||
wom_getApplications appinfos
|
||||
|
||||
# Calculer les instances à relancer, en fonctions des applications et des
|
||||
# frameworks à déployer
|
||||
apps_to_restart=("${applications[@]}" "${frameworks[@]}")
|
||||
array_map apps_to_restart basename
|
||||
etitle "Calcul des instances à relancer" \
|
||||
compute_apps apps_to_restart appinfos "${apps_to_restart[@]}"
|
||||
|
||||
if [ -z "$bounce" ]; then
|
||||
# Arrêter les instances
|
||||
disable_autorecover=1
|
||||
stop_apps -a apps_to_start "" "" "${apps_to_restart[@]}"
|
||||
fi
|
||||
fi
|
||||
|
||||
################################################################################
|
||||
# Déployer les frameworks
|
||||
|
||||
if [ -n "${frameworks[*]}" ]; then
|
||||
etitle -s "Déploiement des frameworks"
|
||||
destdir="$WOFRAMEWORKS"
|
||||
webdestdir="$HTDOCSDIR/WebObjects/Frameworks"
|
||||
|
||||
for bundle in "${frameworks[@]}"; do
|
||||
fwkname="$(basename "$bundle")"
|
||||
fwkbasename="${fwkname%.framework}"
|
||||
fwkdesc=
|
||||
oldfwkname="$fwkname.orig"
|
||||
|
||||
etitle -s "$fwkname${fwkdesc:+: $fwkdesc}"
|
||||
|
||||
if [ -z "$webinst" ]; then
|
||||
ebegin "Correction de la casse du jar principal"
|
||||
jar="$(awk <"$bundle/Resources/Info.plist" '
|
||||
/<key>NSJavaPathClient<\/key>/ {
|
||||
getline
|
||||
gsub("^.*<string>", "")
|
||||
gsub("</string>.*$", "")
|
||||
print
|
||||
}
|
||||
')"
|
||||
if [ -n "$jar" ]; then
|
||||
lower_jar="$bundle/Resources/Java/$(echo "$jar" | awk '{print tolower($0)}')"
|
||||
jar="$bundle/Resources/Java/$jar"
|
||||
if [ ! -f "$jar" -a -f "$lower_jar" ]; then
|
||||
/bin/mv "$lower_jar" "$jar"; edot
|
||||
fi
|
||||
fi
|
||||
eend
|
||||
fi
|
||||
|
||||
if reason="$(wosignable "$bundle")"; then
|
||||
estep "Signature des jars"
|
||||
wosign -d -s "$bundle"
|
||||
fi
|
||||
|
||||
if [ -d "$destdir/$fwkname" ]; then
|
||||
ebegin "Suppression de l'ancienne installation"
|
||||
if [ -z "$webinst" ]; then
|
||||
rm_ifexists "$destdir/$oldfwkname"; edot
|
||||
/bin/mv "$destdir/$fwkname" "$destdir/$oldfwkname"; edot
|
||||
fi
|
||||
rm_ifexists "$webdestdir/$oldfwkname"; edot
|
||||
if [ -d "$webdestdir/$fwkname" ]; then
|
||||
/bin/mv "$webdestdir/$fwkname" "$webdestdir/$oldfwkname"; edot
|
||||
fi
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -z "$webinst" ]; then
|
||||
# copie des fichiers
|
||||
ebegin "Copie des fichiers"
|
||||
mkdir -p "$destdir"; edot
|
||||
cpdir "$bundle" "$destdir/$fwkname" &
|
||||
ewait $!
|
||||
eend
|
||||
|
||||
# permissions
|
||||
ebegin "Ajustement des permission"
|
||||
chown -R root: "$destdir/$fwkname"; edot
|
||||
chmod -R u=rwX,g=rX,o=rX "$destdir/$fwkname"; edot
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -d "$bundle/WebServerResources" ]; then
|
||||
# copie des fichiers pour le web
|
||||
ebegin "Copie des ressources web"
|
||||
cpdir "$bundle/WebServerResources" "$webdestdir/$fwkname/WebServerResources" &
|
||||
ewait $!
|
||||
eend
|
||||
|
||||
# permissions
|
||||
ebegin "Ajustement des permission"
|
||||
chown -R root: "$webdestdir/$fwkname"; edot
|
||||
chmod -R u=rwX,g=rX,o=rX "$webdestdir/$fwkname"; edot
|
||||
eend
|
||||
fi
|
||||
|
||||
eend
|
||||
done
|
||||
|
||||
eend
|
||||
fi
|
||||
|
||||
################################################################################
|
||||
# Déployer les applications
|
||||
|
||||
if [ -n "${applications[*]}" ]; then
|
||||
etitle -s "Déploiement des applications"
|
||||
destdir="$WOAPPLICATIONS"
|
||||
webdestdir="$HTDOCSDIR/WebObjects"
|
||||
|
||||
for bundle in "${applications[@]}"; do
|
||||
appname="$(basename "$bundle")"
|
||||
appbasename="${appname%.woa}"
|
||||
appdesc=
|
||||
oldappname="$appname.orig"
|
||||
|
||||
etitle -s "$appname${appdesc:+: $appdesc}"
|
||||
|
||||
if [ -z "$webinst" ]; then
|
||||
estep "Correction éventuelle de la casse des jars"
|
||||
fix_jars_case "$bundle"
|
||||
fi
|
||||
|
||||
estep "Vérification du bundle"
|
||||
verifix_bundle "$bundle"
|
||||
|
||||
if reason="$(wosignable "$bundle")"; then
|
||||
estep "Signature des jars"
|
||||
wosign -d -s "$bundle"
|
||||
fi
|
||||
|
||||
if [ -d "$destdir/$appname" ]; then
|
||||
ebegin "Suppression de l'ancienne installation"
|
||||
if [ -z "$webinst" ]; then
|
||||
rm_ifexists "$destdir/$oldappname"; edot
|
||||
/bin/mv "$destdir/$appname" "$destdir/$oldappname"; edot
|
||||
fi
|
||||
rm_ifexists "$webdestdir/$oldappname"; edot
|
||||
if [ -d "$webdestdir/$appname" ]; then
|
||||
/bin/mv "$webdestdir/$appname" "$webdestdir/$oldappname"; edot
|
||||
fi
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -z "$webinst" ]; then
|
||||
# copie des fichiers
|
||||
ebegin "Copie des fichiers"
|
||||
mkdir -p "$destdir"; edot
|
||||
cpdir "$bundle" "$destdir/$appname" &
|
||||
ewait $!
|
||||
eend
|
||||
|
||||
# permissions
|
||||
ebegin "Ajustement des permission"
|
||||
chown -R root: "$destdir/$appname"; edot
|
||||
chmod -R u=rwX,g=rX,o=rX "$destdir/$appname"; edot
|
||||
eend
|
||||
fi
|
||||
|
||||
if [ -d "$bundle/Contents/WebServerResources" ]; then
|
||||
# copie des fichiers pour le web
|
||||
ebegin "Copie des ressources web"
|
||||
cpdir "$bundle/Contents/WebServerResources" "$webdestdir/$appname/Contents/WebServerResources" &
|
||||
ewait $!
|
||||
eend
|
||||
|
||||
# permissions
|
||||
ebegin "Ajustement des permission"
|
||||
chown -R root: "$webdestdir/$appname"; edot
|
||||
chmod -R u=rwX,g=rX,o=rX "$webdestdir/$appname"; edot
|
||||
eend
|
||||
fi
|
||||
|
||||
eend
|
||||
done
|
||||
|
||||
eend
|
||||
fi
|
||||
|
||||
################################################################################
|
||||
|
||||
if [ -z "$webinst" ]; then
|
||||
if [ -z "$bounce" ]; then
|
||||
# Démarrer les instances
|
||||
enable_autorecover=1
|
||||
start_apps "" "" "${apps_to_start[@]}"
|
||||
else
|
||||
# Relancer les applications en mode bounce
|
||||
bounce_apps "" "" "${apps_to_restart[@]}"
|
||||
fi
|
||||
fi
|
||||
|
||||
################################################################################
|
||||
# Lancer les scripts
|
||||
|
||||
for script in "${scripts[@]}"; do
|
||||
eval "$script"
|
||||
done
|
||||
384
ulib/sysinfos
384
ulib/sysinfos
@@ -1,384 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion des informations sur l'hôte local
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide sysinfos
|
||||
urequire base
|
||||
|
||||
################################################################################
|
||||
## Informations sur le système local
|
||||
|
||||
## type de système
|
||||
# attention: dans SYSNAMES et *_SYSDISTS, les noms doivent être ordonnés du
|
||||
# moins spécifique au plus spécifique
|
||||
SYSNAMES=(linux linux64 linux32 linuxppc64 linuxppc32 linuxarm macosx)
|
||||
linux_SYSDISTS=(debianlike debian ubuntu redhatlike rhel fedora centos suse gentoo)
|
||||
linux32_SYSDISTS=(debianlike debian ubuntu redhatlike rhel fedora centos suse gentoo)
|
||||
linux64_SYSDISTS=(debianlike debian ubuntu redhatlike rhel fedora centos suse gentoo)
|
||||
linuxppc32_SYSDISTS=(debianlike debian ubuntu redhatlike fedora)
|
||||
linuxppc64_SYSDISTS=(debianlike debian ubuntu redhatlike fedora)
|
||||
linuxarm_SYSDISTS=(debianlike debian ubuntu)
|
||||
macosx_SYSDISTS=(lion snowleopard leopard tiger panther)
|
||||
SYSDIST_ALIASES=(
|
||||
10.7=lion 10.6=snowleopard 10.5=leopard 10.4=tiger 10.3=panther
|
||||
)
|
||||
# attention: dans *_SYSVERS, les noms doivent être ordonnés du plus récent au
|
||||
# moins récent
|
||||
debianlike_SYSVERS=()
|
||||
debian_SYSVERS=(wheezy squeeze lenny etch)
|
||||
ubuntu_SYSVERS=(oneiric natty maverick lucid karmic jaunty intrepid hardy)
|
||||
redhatlike_SYSVERS=()
|
||||
rhel_SYSVERS=(rhel6 rhel5 rhel4 redhat6 redhat5 redhat4)
|
||||
fedora_SYSVERS=(fedora14 fedora13 fedora12 fedora11)
|
||||
centos_SYSVERS=(centos6 centos5 centos4 redhat6 redhat5 redhat4)
|
||||
suse_SYSVERS=()
|
||||
gentoo_SYSVERS=()
|
||||
SYSVER_ALIASES=(
|
||||
7=wheezy 6=squeeze 5=lenny 4=etch
|
||||
11.10=oneiric 11.04=natty 10.10=maverick 10.04=lucid 9.10=karmic 9.04=jaunty 8.10=intrepid 8.04=hardy
|
||||
)
|
||||
|
||||
function __setup_ALL_SYSvars() {
|
||||
local s ds d fs f
|
||||
ALL_SYSDISTS=()
|
||||
for s in "${SYSNAMES[@]}"; do
|
||||
array_copy ds "${s}_SYSDISTS"
|
||||
for d in "${ds[@]}"; do
|
||||
array_set ALL_SYSDISTS "$d"
|
||||
done
|
||||
done
|
||||
ALL_SYSVERS=()
|
||||
for d in "${ALL_SYSDISTS[@]}"; do
|
||||
array_copy fs "${d}_SYSVERS"
|
||||
for f in "${fs[@]}"; do
|
||||
# les valeurs sont poussés vers la fin si elles existent déjà
|
||||
array_contains ALL_SYSVERS "$f" && array_del ALL_SYSVERS "$f"
|
||||
array_add ALL_SYSVERS "$f"
|
||||
done
|
||||
done
|
||||
}
|
||||
__setup_ALL_SYSvars
|
||||
unset -f __setup_ALL_SYSvars
|
||||
|
||||
MYSYSNAME=()
|
||||
MYBITS=
|
||||
MYSYSDIST=()
|
||||
MYSYSVER=()
|
||||
if [ "$UNAME_SYSTEM" == "Linux" ]; then
|
||||
case "$UNAME_MACHINE" in
|
||||
x86_64)
|
||||
MYSYSNAME=(linux64 linux)
|
||||
MYBITS=64
|
||||
;;
|
||||
i386|i586|i686)
|
||||
MYSYSNAME=(linux32 linux)
|
||||
MYBITS=32
|
||||
;;
|
||||
ppc)
|
||||
MYSYSNAME=(linuxppc32 linuxppc linux)
|
||||
MYBITS=32
|
||||
;;
|
||||
ppc64)
|
||||
MYSYSNAME=(linuxppc64 linuxppc linux)
|
||||
MYBITS=64
|
||||
;;
|
||||
arm*)
|
||||
MYSYSNAME=(linuxarm linux)
|
||||
;;
|
||||
*)
|
||||
MYSYSNAME=(linux)
|
||||
;;
|
||||
esac
|
||||
|
||||
if [ -f /etc/debian_version ]; then
|
||||
case "$(</etc/debian_version)" in
|
||||
7*|wheezy*) MYSYSDIST=(debian debianlike); MYSYSVER=(wheezy);;
|
||||
6*|squeeze*) MYSYSDIST=(debian debianlike); MYSYSVER=(squeeze);;
|
||||
5*) MYSYSDIST=(debian debianlike); MYSYSVER=(lenny);;
|
||||
4*) MYSYSDIST=(debian debianlike); MYSYSVER=(etch);;
|
||||
*) MYSYSDIST=(debianlike);;
|
||||
esac
|
||||
elif [ -f /etc/gentoo-release ]; then
|
||||
MYSYSDIST=(gentoo)
|
||||
elif [ -f /etc/redhat-release ]; then
|
||||
case "$(</etc/redhat-release)" in
|
||||
Fedora*) MYSYSDIST=(fedora redhatlike);;
|
||||
Red*Hat*Enterprise*Linux*) MYSYSDIST=(rhel redhatlike);;
|
||||
CentOS*) MYSYSDIST=(centos redhatlike);;
|
||||
*) MYSYSDIST=(redhatlike);;
|
||||
esac
|
||||
case "$(</etc/redhat-release)" in
|
||||
Fedora*14*) MYSYSVER=(fedora14);;
|
||||
Fedora*13*) MYSYSVER=(fedora13);;
|
||||
Fedora*12*) MYSYSVER=(fedora12);;
|
||||
Fedora*11*) MYSYSVER=(fedora11);;
|
||||
Red*Hat*Enterprise*Linux*release\ 6*) MYSYSVER=(rhel6 redhat6);;
|
||||
Red*Hat*Enterprise*Linux*release\ 5*) MYSYSVER=(rhel5 redhat5);;
|
||||
Red*Hat*Enterprise*Linux*release\ 4*) MYSYSVER=(rhel4 redhat4);;
|
||||
CentOS*release\ 6*) MYSYSVER=(centos6 redhat6);;
|
||||
CentOS*release\ 5*) MYSYSVER=(centos5 redhat5);;
|
||||
CentOS*release\ 4*) MYSYSVER=(centos4 redhat4);;
|
||||
esac
|
||||
fi
|
||||
elif [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
function get_macosx_version() {
|
||||
local i
|
||||
for i in /System/Library/Frameworks/CoreServices.framework/Frameworks/Metadata.framework/Resources/version.plist /System/Library/Frameworks/CoreServices.framework/Resources/version.plist; do
|
||||
if [ -f "$i" ]; then
|
||||
grep -A 1 CFBundleShortVersionString "$i" | grep string | sed 's/.*<string>//g
|
||||
s/<\/string>.*$//g'
|
||||
break
|
||||
fi
|
||||
done
|
||||
}
|
||||
MYSYSNAME=(macosx darwin)
|
||||
case "$(get_macosx_version)" in
|
||||
10.7*) MYSYSDIST=(lion);;
|
||||
10.6*) MYSYSDIST=(snowleopard);;
|
||||
10.5*) MYSYSDIST=(leopard);;
|
||||
10.4*) MYSYSDIST=(tiger);;
|
||||
10.3*) MYSYSDIST=(panther);;
|
||||
esac
|
||||
fi
|
||||
if [ -n "$UTOOLS_CHROOT" ]; then
|
||||
# Dans un chroot, il est possible de forcer les valeurs
|
||||
[ -n "$UTOOLS_SYSNAME" ] && eval "MYSYSNAME=($UTOOLS_SYSNAME)"
|
||||
[ -n "$UTOOLS_BITS" ] && eval "MYBITS=$UTOOLS_BITS"
|
||||
[ -n "$UTOOLS_SYSDIST" ] && eval "MYSYSDIST=($UTOOLS_SYSDIST)"
|
||||
[ -n "$UTOOLS_SYSVER" ] && eval "MYSYSVER=($UTOOLS_SYSVER)"
|
||||
fi
|
||||
|
||||
function __get_sysdist_alias() {
|
||||
if ! array_contains ALL_SYSDISTS "$1"; then
|
||||
local nd n d
|
||||
for nd in "${SYSDIST_ALIASES[@]}"; do
|
||||
splitvar "$nd" n d
|
||||
if [ "$n" == "$1" ]; then
|
||||
echo "$d"
|
||||
return
|
||||
fi
|
||||
done
|
||||
fi
|
||||
echo "$1"
|
||||
}
|
||||
|
||||
function __get_sysver_alias() {
|
||||
if ! array_contains ALL_SYSVERS "$1"; then
|
||||
local nv n v
|
||||
for nv in "${SYSVER_ALIASES[@]}"; do
|
||||
splitvar "$nv" n v
|
||||
if [ "$n" == "$1" ]; then
|
||||
echo "$v"
|
||||
return
|
||||
fi
|
||||
done
|
||||
fi
|
||||
echo "$1"
|
||||
}
|
||||
|
||||
function __fix_sysinfos_upward() {
|
||||
local sysname_ sysdists_ sysdist_ sysvers_ sysver_
|
||||
if [ -z "${!sysnamevar_}" ]; then
|
||||
if [ -z "${!sysdistvar_}" ]; then
|
||||
[ -z "${!sysvervar_}" ] && return
|
||||
# essayer de déterminer !sysdistvar_ à partir de !sysvervar_
|
||||
for sysname_ in "${SYSNAMES[@]}"; do
|
||||
array_copy sysdists_ "${sysname_}_SYSDISTS"
|
||||
for sysdist_ in "${sysdists_[@]}"; do
|
||||
array_copy sysvers_ "${sysdist_}_SYSVERS"
|
||||
for sysver_ in "${sysvers_[@]}"; do
|
||||
if [ "$sysver_" == "${!sysvervar_}" ]; then
|
||||
set_var "$sysdistvar_" "$sysdist_"
|
||||
set_var "$sysnamevar_" "$sysname_"
|
||||
return
|
||||
fi
|
||||
done
|
||||
done
|
||||
done
|
||||
fi
|
||||
[ -z "${!sysdistvar_}" ] && return 0
|
||||
# essayer de déterminer !sysnamevar_ à partir de !sysdistvar_
|
||||
for sysname_ in "${SYSNAMES[@]}"; do
|
||||
array_copy sysdists_ "${sysname_}_SYSDISTS"
|
||||
for sysdist_ in "${sysdists_[@]}"; do
|
||||
if [ "$sysdist_" == "${!sysdistvar_}" ]; then
|
||||
set_var "$sysnamevar_" "$sysname_"
|
||||
return
|
||||
fi
|
||||
done
|
||||
done
|
||||
fi
|
||||
}
|
||||
function __fix_sysinfos_downward() {
|
||||
local sysname_ sysdist_ sysver_
|
||||
|
||||
# si !sysnamevar_ n'est pas défini, on ne peut rien faire
|
||||
[ -z "${!sysnamevar_}" ] && return
|
||||
|
||||
if [ -z "${!sysdistvar_}" ]; then
|
||||
# essayer de déterminer !sysdistvar_ à partir de !sysnamevar_
|
||||
array_copy sysdists_ "${!sysnamevar_}_SYSDISTS"
|
||||
for sysdist_ in "${sysdists_[@]}"; do
|
||||
set_var "$sysdistvar_" "$sysdist_"
|
||||
break
|
||||
done
|
||||
fi
|
||||
[ -z "${!sysdistvar_}" ] && return
|
||||
|
||||
if [ -z "${!sysvervar_}" ]; then
|
||||
# essayer de déterminer !sysvervar_ à partir de !sysdistvar_
|
||||
array_copy sysvers_ "${sysdistvar_}_SYSVERS"
|
||||
for sysver_ in "${sysvers_[@]}"; do
|
||||
set_var "$sysvervar_" "$sysver_"
|
||||
break
|
||||
done
|
||||
fi
|
||||
#[ -z "${!sysvervar_}" ] && return
|
||||
}
|
||||
function ensure_sysinfos() {
|
||||
# Essayer de déterminer les valeurs des variables $1(=SYSNAME), $2(=SYSDIST)
|
||||
# et $3(=SYSVER) en fonction des valeurs des autres. Cette fonction est à
|
||||
# utiliser quand on récupère cette information de la part de l'utilisateur,
|
||||
# et qu'il faut compléter
|
||||
local sysnamevar_="${1:-SYSNAME}"
|
||||
local sysdistvar_="${2:-SYSDIST}"
|
||||
local sysvervar_="${3:-SYSVER}"
|
||||
[ -n "${!sysdistvar_}" ] && set_var "$sysdistvar_" "$(__get_sysdist_alias "${!sysdistvar_}")"
|
||||
[ -n "${!sysvervar_}" ] && set_var "$sysvervar_" "$(__get_sysver_alias "${!sysvervar_}")"
|
||||
__fix_sysinfos_upward
|
||||
__fix_sysinfos_downward
|
||||
}
|
||||
|
||||
function check_sysinfos() {
|
||||
# Tester si le système courant ($MYSYSNAME, $MYSYSDIST, $MYSYSVER, $MYBITS)
|
||||
# correspond à au moins un des arguments.
|
||||
# Les options -s, -d, -v, -b permettent respectivement de vérifier le
|
||||
# système, la distribution, la version et le nombre de bits. Il est possible
|
||||
# de spécifier plusieurs tests à effectuer, e.g.:
|
||||
# check_sysinfos -d debian ubuntu -b 64
|
||||
# pour tester si l'on est sur une distribution debian ou ubuntu *et* sur un
|
||||
# système 64 bits
|
||||
# Avec l'option -v, il est possible de suffixer la valeur avec + ou - selon
|
||||
# que l'on veut toutes les versions situées après ou avant la version
|
||||
# spécifiée. Attention, à cause d'une limitation de l'implémentation, il
|
||||
# faut alors impérativement filtrer aussi sur la distribution, e.g:
|
||||
# check_sysinfo -d debian -v lenny+
|
||||
# pour tester si on est en lenny ou en squeeze.
|
||||
# De même, l'option -d accepte aussi de suffixer la valeur avec + ou -, mais
|
||||
# cela n'a actuellement de sens qu'avec les version de MacOS X. Il faut
|
||||
# aussi impérativement filtrer sur le système, e.g:
|
||||
# check_sysinfos -s macosx -d 10.5+
|
||||
local sysnamevar_="MYSYSNAME"
|
||||
local sysdistvar_="MYSYSDIST"
|
||||
local sysvervar_="MYSYSVER"
|
||||
local bitsvar_="MYBITS"
|
||||
local check_=sysname r_=0
|
||||
while [ -n "$1" ]; do
|
||||
if [[ "$1" == -* ]]; then
|
||||
[ "$1" == "-S" ] && { sysnamevar_="$2"; shift 2; continue; }
|
||||
[ "$1" == "-D" ] && { sysdistvar_="$2"; shift 2; continue; }
|
||||
[ "$1" == "-V" ] && { sysvervar_="$2"; shift 2; continue; }
|
||||
[ "$1" == "-B" ] && { bitsvar_="$2"; shift 2; continue; }
|
||||
[ "$r_" == "1" ] && break
|
||||
[ "$1" == "-s" ] && check_=sysname
|
||||
[ "$1" == "-d" ] && check_=sysdist
|
||||
[ "$1" == "-v" ] && check_=sysver
|
||||
[ "$1" == "-b" ] && check_=bits
|
||||
r_=1
|
||||
shift
|
||||
continue
|
||||
fi
|
||||
if [ "$check_" == "sysname" ]; then
|
||||
if array_contains "$sysnamevar_" "$1"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
fi
|
||||
|
||||
elif [ "$check_" == "sysdist" ]; then
|
||||
local mode_=exact value_="$1"
|
||||
if [ "${value_%+}" != "$value_" ]; then
|
||||
mode_=after
|
||||
value_="${value_%+}"
|
||||
elif [ "${value_%-}" != "$value_" ]; then
|
||||
mode_=before
|
||||
value_="${value_%-}"
|
||||
fi
|
||||
value_="$(__get_sysdist_alias "$value_")"
|
||||
if [ "$mode_" == "exact" ]; then
|
||||
if array_contains "$sysdistvar_" "$value_"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
fi
|
||||
elif [ "$mode_" == "after" ]; then
|
||||
local sysdist_
|
||||
for sysdist_ in "${ALL_SYSDISTS[@]}"; do
|
||||
if array_contains "$sysdistvar_" "$sysdist_"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
elif [ "$sysdist_" == "$value_" ]; then
|
||||
break
|
||||
fi
|
||||
done
|
||||
elif [ "$mode_" == "before" ]; then
|
||||
local sysdist_ found_
|
||||
for sysdist_ in "${ALL_SYSDISTS[@]}"; do
|
||||
[ "$sysdist_" == "$value_" ] && found_=1
|
||||
if [ -n "$found_" ]; then
|
||||
if array_contains "$sysdistvar_" "$sysdist_"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
break
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
elif [ "$check_" == "sysver" ]; then
|
||||
local mode_=exact value_="$1"
|
||||
if [ "${value_%+}" != "$value_" ]; then
|
||||
mode_=after
|
||||
value_="${value_%+}"
|
||||
elif [ "${value_%-}" != "$value_" ]; then
|
||||
mode_=before
|
||||
value_="${value_%-}"
|
||||
fi
|
||||
value_="$(__get_sysver_alias "$value_")"
|
||||
if [ "$mode_" == "exact" ]; then
|
||||
if array_contains "$sysvervar_" "$value_"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
fi
|
||||
elif [ "$mode_" == "after" ]; then
|
||||
local sysver_
|
||||
for sysver_ in "${ALL_SYSVERS[@]}"; do
|
||||
if array_contains "$sysvervar_" "$sysver_"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
elif [ "$sysver_" == "$value_" ]; then
|
||||
break
|
||||
fi
|
||||
done
|
||||
elif [ "$mode_" == "before" ]; then
|
||||
local sysver_ found_
|
||||
for sysver_ in "${ALL_SYSVERS[@]}"; do
|
||||
[ "$sysver_" == "$value_" ] && found_=1
|
||||
if [ -n "$found_" ]; then
|
||||
if array_contains "$sysvervar_" "$sysver_"; then
|
||||
r_=0
|
||||
check_=skip
|
||||
break
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
elif [ "$check_" == "bits" ]; then
|
||||
if [ "$1" == "${!bitsvar_}" ]; then
|
||||
r_=0
|
||||
check_=skip
|
||||
fi
|
||||
fi
|
||||
shift
|
||||
done
|
||||
return $r_
|
||||
}
|
||||
424
ulib/tiddlywiki
424
ulib/tiddlywiki
@@ -1,424 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion de tiddlywiki
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide tiddlywiki
|
||||
urequire base
|
||||
|
||||
function twget_version() {
|
||||
# lire le numéro de version dans le fichier $1
|
||||
awk '/var[ \t]*version/ {
|
||||
match($0, /major: [0-9]*,/)
|
||||
major = substr($0, RSTART + 7, RLENGTH - 8)
|
||||
match($0, /minor: [0-9]*,/)
|
||||
minor = substr($0, RSTART + 7, RLENGTH - 8)
|
||||
match($0, /revision: [0-9]*,/)
|
||||
revision = substr($0, RSTART + 10, RLENGTH - 11)
|
||||
print major "." minor "." revision
|
||||
exit
|
||||
}' "$1"
|
||||
}
|
||||
|
||||
function twdump_header() {
|
||||
# lire et afficher le contenu avant-storeArea du tiddlywiki $1
|
||||
awk '
|
||||
BEGIN { found = 0 }
|
||||
/<div id="storeArea"/ { found = 1 }
|
||||
! found { print }
|
||||
' "$1"
|
||||
}
|
||||
|
||||
function twdump_footer() {
|
||||
# lire et afficher le contenu après-storeArea du tiddlywiki $1
|
||||
awk '
|
||||
BEGIN {
|
||||
found = 0
|
||||
}
|
||||
/<!--POST-STOREAREA-->/ { found = 1; }
|
||||
found { print }
|
||||
' "$1"
|
||||
}
|
||||
|
||||
function twdump_storeArea() {
|
||||
# lire et afficher le storeArea dans le tiddlywiki $1
|
||||
awk '
|
||||
BEGIN { found = 0 }
|
||||
/<div id="storeArea"/ { found = 1 }
|
||||
/<!--POST-STOREAREA-->/ { found = 0; next }
|
||||
found { print }
|
||||
' "$1"
|
||||
}
|
||||
|
||||
function twreplace_storeArea() {
|
||||
# dans le tiddlywiki $1, remplacer le storeArea par le fichier $2 (par défaut, lu sur stdin)
|
||||
(
|
||||
twdump_header "$1"
|
||||
if [ -z "$2" -o "$2" == "-" ]; then
|
||||
cat
|
||||
else
|
||||
cat "$2"
|
||||
fi
|
||||
twdump_footer "$1"
|
||||
) >"$1.$$"
|
||||
/bin/mv "$1.$$" "$1"
|
||||
}
|
||||
|
||||
function twupgrade() {
|
||||
# mettre à jour le tiddlywiki $1 sur la base du tiddlywiki plus récent $2
|
||||
(
|
||||
twdump_header "$2"
|
||||
twdump_storeArea "$1"
|
||||
twdump_footer "$2"
|
||||
) >"$1.$$"
|
||||
/bin/mv "$1.$$" "$1"
|
||||
}
|
||||
|
||||
TW_AWK_FUNCS='
|
||||
function twdate_tid2time(tiddate, vs, y, m, d, H, M, time) {
|
||||
if (match(tiddate, /([0-9][0-9][0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])$/, vs)) {
|
||||
y = vs[1] + 0; m = vs[2] + 0; d = vs[3] + 0
|
||||
H = vs[4] + 0; M = vs[5] + 0
|
||||
time = mktime(sprintf("%04i %02i %02i %02i %02i 00", y, m, d, H, M))
|
||||
time = time + 4 * 60 * 60 # UTC --> GMT+4
|
||||
return time
|
||||
}
|
||||
}
|
||||
function twdate_twp2time(twpdate, vs, y, m, d, H, M, time) {
|
||||
if (match(twpdate, /([0-9]+)\/([0-9]+)\/([0-9][0-9][0-9][0-9]) ([0-9]+)[:.]([0-9]+)$/, vs)) {
|
||||
y = vs[3] + 0; m = vs[2] + 0; d = vs[1] + 0
|
||||
H = vs[4] + 0; M = vs[5] + 0
|
||||
time = mktime(sprintf("%04i %02i %02i %02i %02i 00", y, m, d, H, M))
|
||||
return time
|
||||
}
|
||||
}
|
||||
function twdate_curtwp(time, r) {
|
||||
if (!time) time = systime()
|
||||
# arrondir à la minute supérieur si nécessaire, pour éviter les problèmes de
|
||||
# mise à jour pour un fichier modifié plusieurs fois dans une même minute.
|
||||
r = time % 60
|
||||
if (r != 0) time = time + 60 - r
|
||||
return strftime("%d/%m/%Y %H:%M", time)
|
||||
}
|
||||
function twdate_tid2twp(tiddate, vs, y, m, d, H, M, time) {
|
||||
time = twdate_tid2time(tiddate)
|
||||
if (time) return strftime("%d/%m/%Y %H:%M", time);
|
||||
}
|
||||
function twdate_curtid(time) {
|
||||
if (!time) time = systime()
|
||||
time = time - 4 * 60 * 60 # GMT+4 --> UTC
|
||||
return strftime("%Y%m%d%H%M", time)
|
||||
}
|
||||
function twdate_twp2tid(twpdate, vs, y, m, d, H, M, time) {
|
||||
time = twdate_twp2time(twpdate)
|
||||
if (time) {
|
||||
time = time - 4 * 60 * 60 # GMT+4 --> UTC
|
||||
return strftime("%Y%m%d%H%M", time)
|
||||
}
|
||||
}
|
||||
'
|
||||
|
||||
function twdate_curtwp() {
|
||||
# obtenir la date courante dans le format "dd/mm/YYYY HH:MM" exprimée dans
|
||||
# l'heure locale
|
||||
# $1 est éventuellement la date exprimée en nombre de secondes depuis
|
||||
# l'epoch, exprimée dans l'heure locale
|
||||
awkrun time="$1" "$TW_AWK_FUNCS"'BEGIN { print twdate_curtwp(time); }'
|
||||
}
|
||||
|
||||
function twdate_tid2twp() {
|
||||
# Transformer $1, une date de la forme "YYYYmmddHHMM" exprimée dans le
|
||||
# timezone UTC en une chaine "dd/mm/YYYY HH:MM" exprimée dans l'heure locale
|
||||
# Si $1 n'est pas dans le bon format, ne rien afficher
|
||||
awkrun "$TW_AWK_FUNCS"'{ twdate = twdate_tid2twp($0); if (twdate) print twdate; }' <<<"$1"
|
||||
}
|
||||
|
||||
function twdate_curtid() {
|
||||
# obtenir la date courante dans le format "YYYYmmddHHMM" exprimée dans le
|
||||
# timezone UTC
|
||||
# $1 est éventuellement la date exprimée en nombre de secondes depuis
|
||||
# l'epoch, exprimée dans l'heure locale
|
||||
awkrun time="$1" "$TW_AWK_FUNCS"'BEGIN { print twdate_curtid(time); }'
|
||||
}
|
||||
|
||||
function twdate_twp2tid() {
|
||||
# Transformer $1, une date de la forme "dd/mm/YYYY HH:MM" exprimée en heure
|
||||
# locale en une chaine "YYYYmmddHHMM" exprimée dans le timezone UTC
|
||||
# Si $1 n'est pas dans le bon format, ne rien afficher
|
||||
awkrun "$TW_AWK_FUNCS"'{ tiddate = twdate_twp2tid($0); if (tiddate) print tiddate; }' <<<"$1"
|
||||
}
|
||||
|
||||
function twdump_tiddlers() {
|
||||
# dumper les tiddlers du fichier $1 généré avec twdump_storeArea() sous
|
||||
# forme d'une liste d'appel de fonction '__tiddler_data title creator
|
||||
# modifier created modified tags changecount content'
|
||||
# Les arguments de la fonction sont les valeurs brutes du tiddler, qui ont
|
||||
# simplement été corrigées avec unquote_html()
|
||||
awkrun -f "$TW_AWK_FUNCS"'
|
||||
function parse_attrs() {
|
||||
title = ""
|
||||
creator = ""
|
||||
modifier = ""
|
||||
created = ""
|
||||
modified = ""
|
||||
tags = ""
|
||||
changecount = ""
|
||||
if (match($0, /title="([^"]*)"/, vs)) title = unquote_html(vs[1])
|
||||
if (match($0, /creator="([^"]*)"/, vs)) creator = unquote_html(vs[1])
|
||||
if (match($0, /modifier="([^"]*)"/, vs)) modifier = unquote_html(vs[1])
|
||||
if (match($0, /created="([^"]*)"/, vs)) created = unquote_html(vs[1])
|
||||
if (match($0, /modified="([^"]*)"/, vs)) modified = unquote_html(vs[1])
|
||||
if (match($0, /tags="([^"]*)"/, vs)) tags = unquote_html(vs[1])
|
||||
if (match($0, /changecount="([^"]*)"/, vs)) changecount = unquote_html(vs[1])
|
||||
}
|
||||
function parse_content( found_pre, vs) {
|
||||
content = ""
|
||||
found_pre = 0
|
||||
# Parser <pre> et éventuellement </pre>
|
||||
while (getline > 0) {
|
||||
if (match($0, /<pre>(.*)<\/pre>$/, vs)) {
|
||||
content = unquote_html(vs[1])
|
||||
break
|
||||
} else if (match($0, /<pre>(.*)$/, vs)) {
|
||||
found_pre = 1
|
||||
content = unquote_html(vs[1])
|
||||
break
|
||||
}
|
||||
}
|
||||
# Puis lire jusqu"à </pre>, le cas échéant
|
||||
if (found_pre) {
|
||||
found_pre = 0
|
||||
while (getline > 0) {
|
||||
if (match($0, /^(.*)<\/pre>/, vs)) {
|
||||
found_pre = 1
|
||||
content = content "\n" unquote_html(vs[1])
|
||||
break
|
||||
} else {
|
||||
content = content "\n" unquote_html($0)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function dump_tiddler() {
|
||||
print "__tiddler_data " quote_value(title) " " quote_value(creator) " " quote_value(modifier) " " quote_value(created) " " quote_value(modified) " " quote_value(tags) " " quote_value(changecount) " " quote_value(content)
|
||||
}
|
||||
BEGIN { parse = 0 }
|
||||
!parse && /<div id="storeArea"/ { parse = 1; next; }
|
||||
parse && $0 ~ /<div / {
|
||||
parse_attrs()
|
||||
parse_content()
|
||||
dump_tiddler()
|
||||
}
|
||||
' <"$1"
|
||||
}
|
||||
|
||||
function twdump_twpage() {
|
||||
# Dumper le contenu de la twpage $1 sous forme d'un appel à une function
|
||||
# '__twpage_data title creator modifier created modified tags changecount
|
||||
# content'
|
||||
# Les arguments de la fonction sont les valeurs brutes de la twpage, sauf
|
||||
# que le champ modified contient toujours la date de dernière modification
|
||||
# du fichier.
|
||||
local modifiedtime="$(stat -L -c %Y "$1")"
|
||||
awkrun -f user="$USER" modifiedtime="$modifiedtime" "$TW_AWK_FUNCS"'
|
||||
function parse_attr(line) {
|
||||
if (match(line, /^##@([^:]+): (.*)$/, vs)) {
|
||||
if (vs[1] == "title") title = vs[2]
|
||||
else if (vs[1] == "creator") creator = vs[2]
|
||||
else if (vs[1] == "modifier") modifier = vs[2]
|
||||
else if (vs[1] == "created") created = vs[2]
|
||||
else if (vs[1] == "modified") modified = vs[2]
|
||||
else if (vs[1] == "tags") tags = vs[2]
|
||||
else if (vs[1] == "changecount") changecount = vs[2]
|
||||
if (!creator) creator = user
|
||||
if (!modifier) modifier = user
|
||||
if (!created) created = twdate_curtwp()
|
||||
modified = twdate_curtwp(modifiedtime)
|
||||
}
|
||||
}
|
||||
{
|
||||
title = ""
|
||||
creator = ""
|
||||
modifier = ""
|
||||
created = ""
|
||||
modified = ""
|
||||
tags = ""
|
||||
changecount = ""
|
||||
content = ""
|
||||
eof = 0
|
||||
while ($0 ~ /^#/) {
|
||||
parse_attr($0)
|
||||
if (getline <= 0) {
|
||||
eof = 1
|
||||
break
|
||||
}
|
||||
}
|
||||
if (!eof) { while (getline > 0) {
|
||||
content = content "\n" $0
|
||||
}}
|
||||
gsub(/^[ \t\n]*/, "", content);
|
||||
gsub(/[ \t\n]*$/, "", content);
|
||||
|
||||
print "__twpage_data " quote_value(title) " " quote_value(creator) " " quote_value(modifier) " " quote_value(created) " " quote_value(modified) " " quote_value(tags) " " quote_value(changecount) " " quote_value(content)
|
||||
}' <"$1"
|
||||
}
|
||||
|
||||
function twwrite_tiddler() {
|
||||
# Ecrire sur STDOUT le tiddler correspondant aux paramètres sont spécifiés
|
||||
# sur la ligne de commande. Les arguments sont les valeurs brutes prises de
|
||||
# la twpage, telles qu'elles sont générées par twdump_twpage()
|
||||
awkrun -f title="$1" creator="$2" modifier="$3" created="$4" modified="$5" tags="$6" changecount="$7" content="$8" "$TW_AWK_FUNCS"'BEGIN {
|
||||
title = quote_html(title)
|
||||
creator = quote_html(creator)
|
||||
modifier = quote_html(modifier)
|
||||
created = quote_html(twdate_twp2tid(created))
|
||||
modified = quote_html(twdate_twp2tid(modified))
|
||||
tags = quote_html(tags)
|
||||
changecount = quote_html(changecount)
|
||||
content = quote_html(content)
|
||||
|
||||
print "<div title=\"" title "\" creator=\"" creator "\" modifier=\"" modifier "\" created=\"" created "\" modified=\"" modified "\" tags=\"" tags "\" changecount=\"" changecount "\">"
|
||||
print "<pre>" content "</pre>"
|
||||
print "</div>"
|
||||
}'
|
||||
}
|
||||
|
||||
function twcheck_twpage_modified() {
|
||||
# Vérifier si la twpage $1 peut être écrasée par un tiddler dont la date de
|
||||
# modification est $2, de format "YYYYmmddHHMM" exprimée dans le timezone
|
||||
# UTC
|
||||
# C'est le cas si le fichier $1 n'existe pas, ou a une date de modification
|
||||
# antérieure à $2
|
||||
[ -f "$1" ] || return 0
|
||||
local twpage="$1" othermodified="$2"
|
||||
(
|
||||
function __twpage_data() { thismodified="$(twdate_twp2tid "$5")"; }
|
||||
eval "$(twdump_twpage "$twpage")"
|
||||
[ "$thismodified" -le "$othermodified" ]
|
||||
)
|
||||
}
|
||||
|
||||
function twcheck_twpage_newtwpage() {
|
||||
# Vérifier si la twpage $1 peut être écrasée par la twpage $2
|
||||
# C'est le cas si le fichier $1 n'existe pas, ou a une date de modification
|
||||
# antérieure à $2
|
||||
[ -f "$1" ] || return 0
|
||||
local twpage="$1" othertwpage="$2"
|
||||
(
|
||||
function __twpage_data() { thismodified="$(twdate_twp2tid "$5")"; }
|
||||
eval "$(twdump_twpage "$twpage")"
|
||||
function __twpage_data() { othermodified="$(twdate_twp2tid "$5")"; }
|
||||
eval "$(twdump_twpage "$othertwpage")"
|
||||
[ "$thismodified" -le "$othermodified" ]
|
||||
)
|
||||
}
|
||||
|
||||
TW_VERBOSE=1
|
||||
function twwrite_twpage() {
|
||||
# Ecrire dans le répertoire courant le fichier correspondant au tiddler dont
|
||||
# les paramètres sont spécifiés sur la ligne de commande. Les arguments sont
|
||||
# les valeurs brutes prises du tiddler, telles qu'elles sont générées par
|
||||
# twdump_tiddlers()
|
||||
# Retourner 0 si le fichier a été écrasé, 1 s'il n'a pas été écrasé parce
|
||||
# qu'il n'a pas été modifié, 2 s'il n'a pas été écrasé parce qu'il est plus
|
||||
# récent.
|
||||
# Si TW_VERBOSE=1, afficher un message informatif lors de l'export
|
||||
local title="$1" creator="$2" modifier="$3" created="$4" modified="$5" tags="$6" changecount="$7" content="$8"
|
||||
|
||||
# enlever les caractères problématiques dans le titre pour générer le nom de
|
||||
# fichier
|
||||
local twpage="$title.twp"
|
||||
twpage="${twpage//\//_}"
|
||||
twpage="${twpage//:/_}"
|
||||
|
||||
local tmppage
|
||||
ac_set_tmpfile tmppage
|
||||
echo "# -*- coding: utf-8 mode: markdown -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
# Pense-bête:
|
||||
# ''bold'' ==striked== __underline__ //italic// ^^super^^ ~~sub~~
|
||||
# @@highlight@@ @@color:red;background-color:white; rouge sur noir@@
|
||||
# ~NotAWikiWord [[force wikiword]] [[friendly name|WikiWord]]
|
||||
# [[external|http://site.com]] ---- {{monospace}}
|
||||
# !h1 !!h2 !!!h3 !!!!h4 !!!!!h5
|
||||
# * dotlist ** sublist # numlist ## sublist
|
||||
# {{{ |caption|c [img[title|filename]]
|
||||
# pre text |!header|!header|h [img[filename]]
|
||||
# }}} |cell|cell| [img[title|filename][link]]
|
||||
# <<< |>|colspan| [img[filename][link]]
|
||||
# blockquote |rowspan|one| [<img[filename]]
|
||||
# <<< |~|two| [>img[filename]]
|
||||
# >quote1 |left| right|
|
||||
# >>quote2 |>| center |
|
||||
# >>>quote3
|
||||
##@creator: $creator
|
||||
##@created: $(twdate_tid2twp "$created")
|
||||
##@modifier: $modifier
|
||||
##@changecount: $changecount
|
||||
##@tags: $tags
|
||||
##@title: $title
|
||||
|
||||
$content" >"$tmppage"
|
||||
|
||||
local status
|
||||
if [ ! -f "$twpage" ] || testdiff "$tmppage" "$twpage"; then
|
||||
if twcheck_twpage_modified "$twpage" "$modified"; then
|
||||
if [ -n "$TW_VERBOSE" ]; then
|
||||
if [ -f "$twpage" ]; then
|
||||
estepw "$twpage: fichier écrasé, parce qu'il est plus ancien"
|
||||
else
|
||||
estepi "$title: export"
|
||||
fi
|
||||
fi
|
||||
cat "$tmppage" >"$twpage"
|
||||
status=0
|
||||
else
|
||||
if [ -n "$TW_VERBOSE" ]; then
|
||||
estepw "$twpage: fichier non écrasé car il est plus récent (utiliser -u)"
|
||||
fi
|
||||
status=2
|
||||
fi
|
||||
else
|
||||
status=1
|
||||
fi
|
||||
ac_clean "$tmppage"
|
||||
return $status
|
||||
}
|
||||
|
||||
function export_to_twpages() {
|
||||
# Exporter tous les tiddlers du tiddlywiki $1 dans le répertoire $2
|
||||
local wikifile="${1:-wiki.html}" wikidir="${2:-.}"
|
||||
local storeArea
|
||||
ac_set_tmpfile storeArea
|
||||
twdump_storeArea "$wikifile" >"$storeArea"
|
||||
|
||||
function __tiddler_data() { twwrite_twpage "$@"; }
|
||||
local CWD="$(pwd)"
|
||||
cd "$wikidir"
|
||||
eval "$(twdump_tiddlers "$storeArea")"
|
||||
cd "$CWD"
|
||||
ac_clean "$storeArea"
|
||||
}
|
||||
|
||||
function import_from_twpages() {
|
||||
# Remplacer les tiddlers du tiddlywiki $1 par les twpages du répertoire $2
|
||||
local wikifile="${1:-wiki.html}" wikidir="${2:-.}"
|
||||
|
||||
local storeArea
|
||||
ac_set_tmpfile storeArea
|
||||
echo "<div id=\"storeArea\">" >"$storeArea"
|
||||
|
||||
function __twpage_data() {
|
||||
twwrite_tiddler "$@" >>"$storeArea"
|
||||
}
|
||||
local -a twpages
|
||||
local twpage
|
||||
array_from_lines twpages "$(list_files "$wikidir" "*.twp" | csort)"
|
||||
for twpage in "${twpages[@]}"; do
|
||||
[ -n "$TW_VERBOSE" ] && estep "$twpage"
|
||||
eval "$(twdump_twpage "$wikidir/$twpage")"
|
||||
done
|
||||
|
||||
echo "</div>" >>"$storeArea"
|
||||
twreplace_storeArea "$wikifile" "$storeArea"
|
||||
|
||||
ac_clean "$storeArea"
|
||||
}
|
||||
195
ulib/udir
195
ulib/udir
@@ -1,195 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonction de support pour udir: gestion des paramètres des répertoires
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide udir
|
||||
urequire base
|
||||
|
||||
UDIR_TEMPLATE="\
|
||||
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
# Utiliser 'udir --help-vars' pour une description de la signification des
|
||||
# variables suivantes:
|
||||
udir_desc=\"\"
|
||||
udir_note=\"\"
|
||||
udir_types=()"
|
||||
|
||||
function udir_check() {
|
||||
# Vérifier si le fichier $1 existe
|
||||
# Si $1 est un répertoire, prendre $1/.udir
|
||||
local udirf="$1"
|
||||
[ -d "$udirf" ] && udirf="$udirf/.udir"
|
||||
[ -f "$udirf" ]
|
||||
}
|
||||
|
||||
function udir_create_maybe() {
|
||||
# Si le fichier $1 n'existe pas, le créer comme un template .udir
|
||||
# Si $1 est un répertoire, prendre $1/.udir
|
||||
local udirf="$1"
|
||||
[ -d "$udirf" ] && udirf="$udirf/.udir"
|
||||
[ -f "$udirf" ] || echo "$UDIR_TEMPLATE" >"$udirf"
|
||||
}
|
||||
|
||||
function udir_dump() {
|
||||
# Dumper toutes les variables définies pour le fichier $1
|
||||
# Si $1 est un répertoire, prendre $1/.udir
|
||||
local udirf="$(abspath "${1:-.}")"
|
||||
[ -d "$udirf" ] && udirf="$udirf/.udir"
|
||||
if [ -f "$udirf" ]; then
|
||||
set_var_cmd udir "$(dirname "$udirf")"
|
||||
set_var_cmd udirf "$udirf"
|
||||
<"$udirf" filter_comment -m
|
||||
fi
|
||||
}
|
||||
|
||||
function udir_eval() {
|
||||
# Evaluer la commande "$2..$*" dans le contexte des variables définies pour
|
||||
# le répertoire $1. La commande est évaluée dans un sous-shell pour ne pas
|
||||
# polluer l'espace de noms courant.
|
||||
|
||||
# note: on évalue les commandes dans un sous-shell au lieu d'utiliser des
|
||||
# variables locales, parce que bash 2.xx a un bug avec l'évaluation de la
|
||||
# définition de tableaux locaux. i.e.
|
||||
# eval "local array=(value)"
|
||||
# a pour résultat "$array" == "(value)", ce qui est incorrect.
|
||||
local udirf="$1"; shift
|
||||
(eval "$(udir_dump "$udirf")"; [ -n "$*" ] && eval "$@")
|
||||
}
|
||||
|
||||
function udir_dump_all() {
|
||||
# Dumper toutes les variables définies pour le répertoire $1 et *tous ses
|
||||
# parents* jusqu'à la racine
|
||||
local -a udirs
|
||||
local udir="$1"
|
||||
[ -f "$udir" ] && udir="$(dirname "$udir")"
|
||||
parentdirs udirs "$udir" reverse
|
||||
for udir in "${udirs[@]}"; do
|
||||
udir_dump "$udir/.udir"
|
||||
done
|
||||
}
|
||||
|
||||
function udir_eval_all() {
|
||||
# Evaluer la commande "$2..$*" dans le contexte des variables définies pour
|
||||
# le répertoire $1 et *tous ses parents* jusqu'à la racine
|
||||
local udirf="$1"; shift
|
||||
(eval "$(udir_dump_all "$udirf")"; [ -n "$*" ] && eval "$@")
|
||||
}
|
||||
|
||||
function udir_parse() {
|
||||
# Dans le fichier $1, lire les noms des variables
|
||||
# Si $1 est un répertoire, prendre $1/.udir
|
||||
# Les noms des variables sont placés dans le tableau $2(=UDIR_VARS), et les noms
|
||||
# des tableaux sont placés dans le tableau $3(=UDIR_ARRAYS)
|
||||
# note: les regex qui sont entre "" au lieu de // le sont à cause d'un bug
|
||||
# de awk sous macosx
|
||||
local __up_udir="$1"
|
||||
[ -d "$__up_udir" ] && __up_udir="$__up_udir/.udir"
|
||||
local __up_vars="${2:-UDIR_VARS}"
|
||||
local __up_arrays="${3:-UDIR_ARRAYS}"
|
||||
eval "$(<"$__up_udir" filter_comment -m | awk 'BEGIN {
|
||||
vars = "'"$__up_vars"'=("; first_var = 1;
|
||||
arrays = "'"$__up_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 ")"
|
||||
}')"
|
||||
}
|
||||
|
||||
function udir_update() {
|
||||
# Dans le fichier $1, mettre à jour les variables $2..*
|
||||
# Si $1 est un répertoire, prendre $1/.udir
|
||||
# Chaque argument de cette fonction est de la forme name[=value]
|
||||
# Si value n'est pas précisée, la variable obtient une valeur nulle
|
||||
# (i.e. var=)
|
||||
# Si la variable ne figure pas dans le fichier, elle est rajoutée à la fin
|
||||
# du fichier.
|
||||
# Cette fonction nécessite gawk.
|
||||
local udir="$1"; shift
|
||||
[ -d "$udir" ] && udir="$udir/.udir"
|
||||
udir_create_maybe "$udir"
|
||||
local mode="$(fix_mode "$udir")"
|
||||
|
||||
local script i param name value
|
||||
script="BEGIN {
|
||||
in_section=0
|
||||
max = $#"
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
name="${param%%=*}"
|
||||
script="$script
|
||||
names[$i] = $(quoted_awk "$name")"
|
||||
if [ "$name" != "$param" ]; then
|
||||
value="${param#*=}"
|
||||
script="$script
|
||||
values[$i] = $(quoted_awk "$value")"
|
||||
else
|
||||
script="$script
|
||||
values[$i] = \"\""
|
||||
fi
|
||||
script="$script
|
||||
seen[$i] = 0"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script"'
|
||||
}
|
||||
function write_unseen() {
|
||||
for (i = 0; i < max; i++) {
|
||||
if (!seen[i]) {
|
||||
print names[i] "=" values[i]
|
||||
seen[i] = 1
|
||||
}
|
||||
}
|
||||
}
|
||||
'
|
||||
i=0
|
||||
for param in "$@"; do
|
||||
name="${param%%=*}"
|
||||
script="$script
|
||||
\$0 ~ /^[ $TAB]*(##*[ $TAB]*)?$name[ $TAB]*=/ {
|
||||
\$0 = gensub(/^([ $TAB]*##*)?([ $TAB]*$name[ $TAB]*=[ $TAB]*).*\$/, \"\\\\2\" values[$i], \"\")
|
||||
seen[$i] = 1
|
||||
}"
|
||||
let i=$i+1
|
||||
done
|
||||
script="$script
|
||||
{ print }
|
||||
END {
|
||||
write_unseen()
|
||||
}"
|
||||
|
||||
ac_set_tmpfile tmpfile
|
||||
<"$udir" >"$tmpfile" awk "$script" &&
|
||||
cat "$tmpfile" >"$udir"
|
||||
unfix_mode "$udir" "$mode"
|
||||
ac_clean "$tmpfile"
|
||||
}
|
||||
|
||||
function udir_edit() {
|
||||
local udirf="$1"
|
||||
[ -d "$udirf" ] && udirf="$udirf/.udir"
|
||||
udir_create_maybe "$udirf"
|
||||
"${EDITOR:-vi}" +1 "$udirf"
|
||||
}
|
||||
72
ulib/uenv
72
ulib/uenv
@@ -1,72 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion des fichiers de ~/etc/{profile.d,bashrc.d,default}
|
||||
##@cooked nocomments
|
||||
uprovide uenv
|
||||
|
||||
function __uenv_check_file() {
|
||||
# Vérifier si le fichier $2 du répertoire $1 doit être sourcé.
|
||||
# note: pour utiliser cette fonction, les variables __uname_system et
|
||||
# __myhostname doivent être définies.
|
||||
local dir="$1" file="$2"
|
||||
|
||||
[ -f "$dir/$file" ] || return
|
||||
|
||||
# ignorer les fichiers qui ont l'extension .ignore
|
||||
[ "${file%%.ignore}" != "$file" ] && return 1
|
||||
|
||||
# tester si le fichier est spécifique à une plateforme
|
||||
local system
|
||||
system="$(expr "$file" : ".*\\.\\[\\([^.]*\\)\\]")"
|
||||
[ -n "$system" -a "$system" != "$__uname_system" ] && return 1
|
||||
system="$(expr "$file" : ".*\\.\\[-\\([^.]*\\)\\]")"
|
||||
[ -n "$system" -a "$system" == "$__uname_system" ] && return 1
|
||||
|
||||
# tester si le fichier est spécifique à une machine
|
||||
local host
|
||||
host="$(expr "$file" : ".*\\.on_\\([^.]*\\)")"
|
||||
[ -n "$host" -a "$host" != "$__myhostname" ] && return 1
|
||||
host="$(expr "$file" : ".*\\.noton_\\([^.]*\\)")"
|
||||
[ -n "$host" -a "$host" == "$__myhostname" ] && return 1
|
||||
|
||||
# tester si le fichier est spécifique à un utilisateur
|
||||
local user
|
||||
user="$(expr "$file" : ".*\\.for_\\([^.]*\\)")"
|
||||
[ -n "$user" -a "$user" != "$USER" ] && return 1
|
||||
user="$(expr "$file" : ".*\\.notfor_\\([^.]*\\)")"
|
||||
[ -n "$user" -a "$user" == "$USER" ] && return 1
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
function __uenv_source_dirs() {
|
||||
# charger les fichiers qui sont dans le répertoire $1. Si un fichier
|
||||
# .source_in_order existe dans ce répertoire, il fixe l'ordre dans lesquel
|
||||
# les fichiers sont chargés. Sinon, les fichiers sont sourcé par ordre
|
||||
# alphabétique.
|
||||
local __uname_system __myhostname
|
||||
__uname_system=`uname -s`
|
||||
[ "${__uname_system#CYGWIN}" != "$__uname_system" ] && __uname_system=Cygwin
|
||||
[ "${__uname_system#MINGW32}" != "$__uname_system" ] && __uname_system=Mingw
|
||||
__myhostname="${HOSTNAME%%.*}"
|
||||
|
||||
local dir file sio
|
||||
for dir in "$@"; do
|
||||
[ -d "$dir" ] || continue
|
||||
sio="$dir/.source_in_order"
|
||||
if [ -f "$sio" ]; then
|
||||
source "$sio"
|
||||
else
|
||||
for file in "$dir/"*; do
|
||||
if __uenv_check_file "$(dirname "$file")" "$(basename "$file")"; then
|
||||
source "$file"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
function __uenv_cleanup() {
|
||||
unset -f __uenv_check_file
|
||||
unset -f __uenv_source_dirs
|
||||
unset -f __uenv_cleanup
|
||||
}
|
||||
262
ulib/uenv_update
262
ulib/uenv_update
@@ -1,262 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion de la mise à jour des fichiers de ~/etc/{profile.d,bashrc.d,default}
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require uenv
|
||||
uprovide uenv_update
|
||||
urequire base uenv
|
||||
|
||||
function __uenv_move_after() {
|
||||
# Dans le fichier $1, déplacer la ligne $2 après la ligne $3.
|
||||
# Si la ligne $2 n'existe pas, ne rien faire
|
||||
# Si la ligne $3 n'existe pas ou vaut '*', mettre la ligne $2 en dernier.
|
||||
# Si $4 est spécifié, l'utiliser comme fichier temporaire.
|
||||
local tmpfile="$4"
|
||||
[ -n "$tmpfile" ] || ac_set_tmpfile tmpfile
|
||||
|
||||
# XXX Il faudrait quoter $2 et $3 pour éviter les caractères spéciaux de
|
||||
# grep!
|
||||
if quietgrep "^$2$" "$1"; then
|
||||
if [ "$3" != "*" ] && quietgrep "^$3$" "$1"; then
|
||||
awkrun line="$2" after="$3" '
|
||||
BEGIN {
|
||||
found_line = 0
|
||||
found_after = 0
|
||||
}
|
||||
! found_line && $0 == line {
|
||||
found_line = 1
|
||||
if (! found_after) {
|
||||
next
|
||||
}
|
||||
}
|
||||
! found_after && $0 == after {
|
||||
found_after = 1
|
||||
if (found_line) {
|
||||
# si nous avons trouvé la ligne avant after, la mettre juste après
|
||||
# sinon, pas la peine de faire de modification
|
||||
print
|
||||
print line
|
||||
next
|
||||
}
|
||||
}
|
||||
{ print }
|
||||
END {
|
||||
if (! found_after && after == "*") {
|
||||
if (found_line) {
|
||||
print line
|
||||
}
|
||||
}
|
||||
}' <"$1" >"$tmpfile" &&
|
||||
cat "$tmpfile" >"$1"
|
||||
else
|
||||
grep -v "^$2$" "$1" >"$tmpfile"
|
||||
echo "$2" >>"$tmpfile"
|
||||
cat "$tmpfile" >"$1"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function __uenv_move_before() {
|
||||
# Dans le fichier $1, déplacer la ligne $2 avant la ligne $3.
|
||||
# Si la ligne $2 n'existe pas, ne rien faire
|
||||
# Si la ligne $3 n'existe pas ou vaut '*', mettre la ligne $2 en premier.
|
||||
# Si $4 est spécifié, l'utiliser comme fichier temporaire.
|
||||
local tmpfile="$4"
|
||||
[ -n "$tmpfile" ] || ac_set_tmpfile tmpfile
|
||||
|
||||
# XXX Il faudrait quoter $2 et $3 pour éviter les caractères spéciaux de
|
||||
# grep!
|
||||
if quietgrep "^$2$" "$1"; then
|
||||
if [ "$3" != "*" ] && quietgrep "^$3$" "$1"; then
|
||||
awkrun line="$2" before="$3" '
|
||||
BEGIN {
|
||||
found_line = 0
|
||||
found_before = 0
|
||||
}
|
||||
! found_line && $0 == line {
|
||||
found_line = 1
|
||||
if (found_before) {
|
||||
next
|
||||
}
|
||||
}
|
||||
! found_before && ($0 == before || before == "*") {
|
||||
found_before = 1
|
||||
if (! found_line) {
|
||||
print line
|
||||
print
|
||||
next
|
||||
}
|
||||
}
|
||||
{ print }
|
||||
' <"$1" >"$tmpfile" &&
|
||||
cat "$tmpfile" >"$1"
|
||||
else
|
||||
echo "$2" >"$tmpfile"
|
||||
grep -v "^$2$" "$1" >>"$tmpfile"
|
||||
cat "$tmpfile" >"$1"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function uenv_update_dir() {
|
||||
# Mettre à jour l'ordre de chargement pour le répertoire $1 qui contient des
|
||||
# fichiers de profil pour le shell. L'ordre dans lequel le fichiers de
|
||||
# profil doivent être chargé est écrit dans le fichier $1/.source_in_order
|
||||
# Si $2 est spécifié, il s'agit d'un fichier temporaire utilisé pour les
|
||||
# calculs de l'ordre des chargements.
|
||||
# $3(=$1) est le répertoire de destination. Si $1 est un répertoire de
|
||||
# préparation temporaire, on peut spécifier grâce à $3 quel est le
|
||||
# répertoire final après préparation.
|
||||
local dir="$(abspath "$1")"
|
||||
local destdir="${3:-$dir}"
|
||||
local tmpfile="$2"
|
||||
[ -n "$tmpfile" ] || ac_set_tmpfile tmpfile
|
||||
local sio="$dir/.source_in_order"
|
||||
local before after file
|
||||
local -a files
|
||||
|
||||
local __uname_system="$UNAME_SYSTEM"
|
||||
local __myhostname="$MYHOSTNAME"
|
||||
>"$sio"
|
||||
for file in "$dir/"*; do
|
||||
file="$(basename "$file")"
|
||||
files=("${files[@]}" "$file")
|
||||
__uenv_check_file "$dir" "$file" && echo "$file" >>"$sio"
|
||||
done
|
||||
|
||||
# traiter d'abord les fichiers qui ont '@before *' ou '@after *'
|
||||
local -a nfiles
|
||||
for file in "${files[@]}"; do
|
||||
before="$(<"$dir/$file" awk '$0 ~ /^##@before / { print $2; exit 0 }')"
|
||||
if [ "$before" == "*" ]; then
|
||||
__uenv_move_before "$sio" "$file" "$before" "$tmpfile"
|
||||
else
|
||||
array_set nfiles "$file"
|
||||
fi
|
||||
after="$(<"$dir/$file" awk '$0 ~ /^##@after / { print $2; exit 0 }')"
|
||||
if [ "$after" == "*" ]; then
|
||||
__uenv_move_after "$sio" "$file" "$after" "$tmpfile"
|
||||
else
|
||||
array_set nfiles "$file"
|
||||
fi
|
||||
done
|
||||
# Ensuite traiter les autres fichiers.
|
||||
# L'opération est faite en deux temps parce que si A est avant B, et que B
|
||||
# est avant *, si A est traité avant B, A risque de se trouver après B si B
|
||||
# est déplacé au début de la liste.
|
||||
for file in "${nfiles[@]}"; do
|
||||
before="$(<"$dir/$file" awk '$0 ~ /^##@before / { print $2; exit 0 }')"
|
||||
[ -n "$before" -a "$before" != "*" ] && __uenv_move_before "$sio" "$file" "$before" "$tmpfile"
|
||||
after="$(<"$dir/$file" awk '$0 ~ /^##@after / { print $2; exit 0 }')"
|
||||
[ -n "$after" -a "$after" != "*" ] && __uenv_move_after "$sio" "$file" "$after" "$tmpfile"
|
||||
done
|
||||
|
||||
awkrun destdir="$destdir" '{ print "source " destdir "/" $0 }' <"$sio" >"$tmpfile" &&
|
||||
cat "$tmpfile" >"$sio"
|
||||
}
|
||||
|
||||
function uenv_set_destdirs() {
|
||||
profiledestdir="$HOME/etc/profile.d"
|
||||
bashrcdestdir="$HOME/etc/bashrc.d"
|
||||
defaultdestdir="$HOME/etc/default"
|
||||
}
|
||||
|
||||
function uenv_sourced_in() {
|
||||
# vérifier que l'un des fichiers $2..$* est sourcé dans $1
|
||||
local src="$1"; shift
|
||||
local file
|
||||
for file in "$@"; do
|
||||
grep -q "\\.[ \\t]*$file\$" "$src" && return 0
|
||||
grep -q "source[ \\t]*$file\$" "$src" && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function uenv_configure_profiles() {
|
||||
local destdir="$1"
|
||||
local LEGACY_PROFILE="$HOME/.profile"
|
||||
local PROFILE="$HOME/.bash_profile"
|
||||
local BASHRC="$HOME/.bashrc"
|
||||
|
||||
if [ ! -f "$PROFILE" ]; then
|
||||
echo "# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
if [ -f ~/.bashrc ]; then
|
||||
. ~/.bashrc
|
||||
fi" >"$PROFILE"
|
||||
fi
|
||||
if [ ! -f "$BASHRC" ]; then
|
||||
touch "$BASHRC"
|
||||
fi
|
||||
|
||||
if [ -f "$LEGACY_PROFILE" ]; then
|
||||
if ! uenv_sourced_in "$PROFILE" "~/.profile"; then
|
||||
ewarn "\
|
||||
~/.profile existe, il contient peut-être des instructions utiles. Si c'est le
|
||||
cas, il faut décommenter la ligne dans ~/.bash_profile qui source ~/.profile"
|
||||
estep "Configuration de l'inclusion de ~/.profile dans $PROFILE"
|
||||
echo >>"$PROFILE" "
|
||||
# decommenter si ~/.profile contient des commandes utiles
|
||||
#[ -f ~/.profile ] && source ~/.profile"
|
||||
fi
|
||||
fi
|
||||
|
||||
if ! uenv_sourced_in "$PROFILE" "$destdir/profile"; then
|
||||
estep "Configuration de l'inclusion de $destdir/profile"
|
||||
echo >>"$PROFILE" "
|
||||
# source $destdir/profile.d scripts
|
||||
[ -f \"$destdir/profile\" ] && source $destdir/profile"
|
||||
fi
|
||||
|
||||
if ! uenv_sourced_in "$BASHRC" "$destdir/bashrc"; then
|
||||
estep "Configuration de l'inclusion de $destdir/bashrc"
|
||||
echo >>"$BASHRC" "
|
||||
# source $destdir/bashrc.d scripts
|
||||
[ -f \"$destdir/bashrc\" ] && source $destdir/bashrc"
|
||||
fi
|
||||
}
|
||||
|
||||
function uenv_install_profiles() {
|
||||
local projdir="$1" profiledir="$2" bashrcdir="$3" defaultdir="$4"
|
||||
local tmpfile
|
||||
local prefix envsrcdir envdestdir envfiles envfile envsrc envdest
|
||||
local profiledestdir bashrcdestdir defaultdestdir
|
||||
uenv_set_destdirs
|
||||
|
||||
ac_set_tmpfile tmpfile
|
||||
for prefix in profile bashrc default; do
|
||||
envsrcdir="${prefix}dir"; envsrcdir="$projdir/${!envsrcdir}"
|
||||
envdestdir="${prefix}destdir"; envdestdir="${!envdestdir}"
|
||||
[ -n "$envsrcdir" -a -d "$envsrcdir" ] || continue
|
||||
|
||||
array_from_lines envfiles "$(list_files "$envsrcdir")"
|
||||
for envfile in "${envfiles[@]}"; do
|
||||
envsrc="$envsrcdir/$envfile"
|
||||
envdest="$envdestdir/$envfile"
|
||||
|
||||
mkdir -p "$envdestdir"
|
||||
if [ ! -f "$envdest" ]; then
|
||||
estep "Installation du profil par défaut $envfile dans $(ppath "$envdestdir")"
|
||||
/bin/cp -f "$envsrc" "$envdestdir"
|
||||
elif [ "$prefix" != "default" ] && ! endswith "$envfile" ".userconf" && testdiff "$envdest" "$envsrc"; then
|
||||
estep "Le profil par défaut $envfile dans $(ppath "$envdestdir") a été modifié"
|
||||
if show_info; then
|
||||
eecho "Voici les différences détectées:"
|
||||
eecho ""
|
||||
diff -u "$envdest" "$envsrcdir" 1>&2
|
||||
eecho ""
|
||||
fi
|
||||
|
||||
if ask_yesno "Faut-il remplacer $(ppath "$envdestdir/$envfile") par le profil par défaut?" O; then
|
||||
/bin/cp -f "$envsrc" "$envdestdir"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
if [ "$prefix" != "default" ]; then
|
||||
estep "Mise à jour de l'ordre de lecture de $(ppath "$envdestdir")"
|
||||
uenv_update_dir "$envdestdir" "$tmpfile"
|
||||
fi
|
||||
done
|
||||
ac_clean "$tmpfile"
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonction de support pour uinc: pliage/dépliage d'inclusions
|
||||
##@cooked nocomments
|
||||
##@require ulib
|
||||
##@require nutools/pyulib
|
||||
uprovide uinc
|
||||
urequire ulib nutools/pyulib
|
||||
|
||||
function uinc() { "$ULIBDIR/support/uinc.py" "$@"; }
|
||||
1398
ulib/uinst
1398
ulib/uinst
File diff suppressed because it is too large
Load Diff
102
ulib/ulib
102
ulib/ulib
@@ -1,102 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Charger les librairies de ulib. Nécessite bash.
|
||||
##@cooked nocomments
|
||||
|
||||
# Ce fichier doit être *sourcé*. Si ce fichier n'est pas sourcé, alors le
|
||||
# répertoire ulib doit être disponible dans le répertoire du script qui inclue
|
||||
# ce fichier. Ceci peut-être fait avec ulibsync.
|
||||
|
||||
# Ensuite, des librairies individuelles de ulib peuvent être chargées avec la
|
||||
# fonction urequire(), e.g.
|
||||
# source /etc/ulib && urequire DEFAULTS conf || exit 1
|
||||
# 'DEFAULTS' permet de charger base, pretty, sysinfos et compat.
|
||||
|
||||
function eerror() { echo "error: $*" 1>&2; }
|
||||
function die() { [ -n "$*" ] && eerror "$*"; exit 1; }
|
||||
|
||||
## Calculer l'emplacement de ulib
|
||||
|
||||
# il est possible de forcer la valeur de ULIBDIR avec FORCED_ULIBDIR. ceci est
|
||||
# utile avec bash 2.x qui ne supporte pas la variable BASH_SOURCE
|
||||
ULIBDIR="${FORCED_ULIBDIR:-@@dest@@/ulib}"
|
||||
|
||||
if [ "$ULIBDIR" = "@@""dest""@@/ulib" ]; then
|
||||
# La valeur "@@"dest"@@" n'est remplacée que dans la copie de ce script
|
||||
# faite dans /etc. Sinon, il faut toujours faire le calcul. Cela permet de
|
||||
# déplacer la librairie n'importe ou sur le disque, ce qui est
|
||||
# particulièrement intéressant quand on fait du déploiement.
|
||||
ULIBDIR="${BASH_SOURCE[0]}"
|
||||
if [ -n "$ULIBDIR" -a -f "$ULIBDIR" ]; then
|
||||
# Fichier sourcé
|
||||
ULIBDIR="$(dirname "$ULIBDIR")"
|
||||
else
|
||||
# Fichier non sourcé. Tout exprimer par rapport au script courant
|
||||
ULIBDIR="$(dirname "$0")/ulib"
|
||||
fi
|
||||
fi
|
||||
ULIBDIR="$(cd "$ULIBDIR"; pwd)"
|
||||
ULIBDIRS=("$ULIBDIR")
|
||||
|
||||
# marqueur pour tester si ulib a été chargé. Il faut avoir $ULIBINIT==$ULIBDIR
|
||||
ULIBINIT="$ULIBDIR"
|
||||
|
||||
# liste des fichiers sourcés par urequire
|
||||
[ -n "$ULIBPROVIDED" ] || ULIBPROVIDED=(ulib)
|
||||
|
||||
function uprovided() {
|
||||
# Tester si la ulibrairie $1 a déjà été chargé par urequire
|
||||
local ulib_
|
||||
for ulib_ in "${ULIBPROVIDED[@]}"; do
|
||||
[ "$ulib_" == "$1" ] && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function uprovide() {
|
||||
# Spécifier que la ulibrairie $1 a été sourcée, ou prétendre que c'est le
|
||||
# cas.
|
||||
uprovided "$1" && return 0
|
||||
ULIBPROVIDED=("${ULIBPROVIDED[@]}" "$1")
|
||||
}
|
||||
|
||||
function urequire() {
|
||||
# Sourcer un fichier recherché dans ULIBDIRS
|
||||
# Si le fichier est DEFAULTS, charger base, pretty, sysinfos et compat à la
|
||||
# place
|
||||
local ulib_ ulibdir_ found_
|
||||
[ -n "$*" ] || set DEFAULTS
|
||||
for ulib_ in "$@"; do
|
||||
found_=
|
||||
for ulibdir_ in "${ULIBDIRS[@]}"; do
|
||||
if [ -f "$ulibdir_/$ulib_" ]; then
|
||||
found_=1
|
||||
if ! uprovided "$ulib_"; then
|
||||
uprovide "$ulib_"
|
||||
source "$ulibdir_/$ulib_" || die
|
||||
fi
|
||||
break
|
||||
elif [ "$ulib_" == "DEFAULTS" ]; then
|
||||
found_=1
|
||||
for ulib_ in base pretty sysinfos compat; do
|
||||
if ! uprovided "$ulib_"; then
|
||||
uprovide "$ulib_"
|
||||
source "$ulibdir_/$ulib_" || die
|
||||
fi
|
||||
done
|
||||
break
|
||||
fi
|
||||
done
|
||||
[ -n "$found_" ] || die "Unable to find $ulib_ in ${ULIBDIR[*]}"
|
||||
done
|
||||
}
|
||||
|
||||
function ulib_add() {
|
||||
# Ajouter $1 au chemin de recherche de urequire
|
||||
[ -d "$1" ] && ULIBDIRS=("${ULIBDIRS[@]}" "$(cd "$1"; pwd)")
|
||||
}
|
||||
|
||||
function ulib_sync() {
|
||||
# Synchroniser les librairies ulib dans le répertoire $1
|
||||
destdir="$(abspath "${1:-.}")"
|
||||
[ "$destdir/ulib" != "$ULIBDIR" ] && cpdirnovcs "$ULIBDIR" "$destdir/ulib"
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
#!/bin/bash
|
||||
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
function display_help() {
|
||||
uecho "$scriptname: Gestion de la version de ulib
|
||||
|
||||
USAGE
|
||||
$scriptname [options]
|
||||
|
||||
OPTIONS
|
||||
-l, --show
|
||||
Afficher la version de la librairie (par défaut)
|
||||
-u, --update
|
||||
Incrémenter la version de la librairie. Il faut incrémenter la version
|
||||
de la librairie à chaque modification incompatible ou correction de bug.
|
||||
-c, --check MIN_VERSION
|
||||
Vérifier que la version de la librairie est au minimum MIN_VERSION, et
|
||||
afficher un message d'information. Utiliser l'option -q si l'on veut
|
||||
juste tester la version et ne pas afficher le message d'information."
|
||||
}
|
||||
|
||||
source "$(dirname "$0")/ulib" &&
|
||||
urequire DEFAULTS ||
|
||||
exit 1
|
||||
|
||||
action=show
|
||||
version=0
|
||||
set_version=
|
||||
min_version=
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with display_help' \
|
||||
-l,--show action=show \
|
||||
-u,--update action=update \
|
||||
-V:,--set-version: set_version= \
|
||||
-c:,--check: '$set@ min_version; action=check' \
|
||||
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
||||
|
||||
versionfile="$scriptdir/.ulib_version"
|
||||
[ -f "$versionfile" ] || echo "$version" >"$versionfile"
|
||||
version="$(<"$versionfile")"
|
||||
|
||||
if [ "$action" == show ]; then
|
||||
echo "ulib est en version $version"
|
||||
elif [ "$action" == update ]; then
|
||||
[ -n "$set_version" ] || set_version=$(($version + 1))
|
||||
echo "$set_version" >"$versionfile"
|
||||
echo "ulib est maintenant en version $set_version"
|
||||
elif [ "$action" == check ]; then
|
||||
r=1
|
||||
[ $version -ge $min_version ] && r=0
|
||||
if [ $r -eq 0 ]; then
|
||||
einfo "ulib est en version $version >= $min_version ${COULEUR_VERTE}[OK]${COULEUR_NORMALE}"
|
||||
else
|
||||
einfo "ulib est en version $version < $min_version ${COULEUR_ROUGE}[KO]${COULEUR_NORMALE}"
|
||||
fi
|
||||
exit $r
|
||||
fi
|
||||
94
ulib/ulibsh
94
ulib/ulibsh
@@ -1,94 +0,0 @@
|
||||
##@cooked comments #-*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Version de ulib utilisable avec n'importe quel bourne shell: le script est
|
||||
## relancé avec bash si nécessaire
|
||||
##@cooked nocomments
|
||||
##@inc[bash
|
||||
## Relancer le script avec bash si nécessaire
|
||||
if [ `basename "${BASH:-sh}"` = "sh" ]; then
|
||||
bash=`which bash 2>/dev/null`
|
||||
for bash in "$bash" /bin/bash /usr/bin/bash /usr/local/bin/bash; do
|
||||
if [ -x "$bash" ]; then
|
||||
exec "$bash" "$0" "$@"
|
||||
fi
|
||||
done
|
||||
echo "error: this script requires bash"
|
||||
exit 1
|
||||
fi
|
||||
##@inc]bash
|
||||
##@inc[ulib
|
||||
## Charger les librairies de ulib. Nécessite bash.
|
||||
|
||||
|
||||
|
||||
function eerror() { echo "error: $*" 1>&2; }
|
||||
function die() { [ -n "$*" ] && eerror "$*"; exit 1; }
|
||||
|
||||
|
||||
ULIBDIR="${FORCED_ULIBDIR:-@@dest@@/ulib}"
|
||||
|
||||
if [ "$ULIBDIR" = "@@""dest""@@/ulib" ]; then
|
||||
ULIBDIR="${BASH_SOURCE[0]}"
|
||||
if [ -n "$ULIBDIR" -a -f "$ULIBDIR" ]; then
|
||||
ULIBDIR="$(dirname "$ULIBDIR")"
|
||||
else
|
||||
ULIBDIR="$(dirname "$0")/ulib"
|
||||
fi
|
||||
fi
|
||||
ULIBDIR="$(cd "$ULIBDIR"; pwd)"
|
||||
ULIBDIRS=("$ULIBDIR")
|
||||
|
||||
ULIBINIT="$ULIBDIR"
|
||||
|
||||
[ -n "$ULIBPROVIDED" ] || ULIBPROVIDED=(ulib)
|
||||
|
||||
function uprovided() {
|
||||
local ulib_
|
||||
for ulib_ in "${ULIBPROVIDED[@]}"; do
|
||||
[ "$ulib_" == "$1" ] && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function uprovide() {
|
||||
uprovided "$1" && return 0
|
||||
ULIBPROVIDED=("${ULIBPROVIDED[@]}" "$1")
|
||||
}
|
||||
|
||||
function urequire() {
|
||||
local ulib_ ulibdir_ found_
|
||||
[ -n "$*" ] || set DEFAULTS
|
||||
for ulib_ in "$@"; do
|
||||
found_=
|
||||
for ulibdir_ in "${ULIBDIRS[@]}"; do
|
||||
if [ -f "$ulibdir_/$ulib_" ]; then
|
||||
found_=1
|
||||
if ! uprovided "$ulib_"; then
|
||||
uprovide "$ulib_"
|
||||
source "$ulibdir_/$ulib_" || die
|
||||
fi
|
||||
break
|
||||
elif [ "$ulib_" == "DEFAULTS" ]; then
|
||||
found_=1
|
||||
for ulib_ in base pretty sysinfos compat; do
|
||||
if ! uprovided "$ulib_"; then
|
||||
uprovide "$ulib_"
|
||||
source "$ulibdir_/$ulib_" || die
|
||||
fi
|
||||
done
|
||||
break
|
||||
fi
|
||||
done
|
||||
[ -n "$found_" ] || die "Unable to find $ulib_ in ${ULIBDIR[*]}"
|
||||
done
|
||||
}
|
||||
|
||||
function ulib_add() {
|
||||
[ -d "$1" ] && ULIBDIRS=("${ULIBDIRS[@]}" "$(cd "$1"; pwd)")
|
||||
}
|
||||
|
||||
function ulib_sync() {
|
||||
destdir="$(abspath "${1:-.}")"
|
||||
[ "$destdir/ulib" != "$ULIBDIR" ] && cpdirnovcs "$ULIBDIR" "$destdir/ulib"
|
||||
}
|
||||
##@inc]ulib
|
||||
uprovide ulibsh
|
||||
696
ulib/vcs
696
ulib/vcs
@@ -1,696 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonctions pour gérer les outils de vcs (subversion, git)
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
uprovide vcs
|
||||
urequire base
|
||||
|
||||
################################################################################
|
||||
# Général
|
||||
|
||||
function __vcs_get_type() {
|
||||
# Afficher le type de vcs du répertoire $1. L'arborescence n'est pas
|
||||
# parcourue. Si l'information n'est pas immédiatement disponible, cette
|
||||
# fonction échoue.
|
||||
# retourner 1 si le type n'a pas été trouvé
|
||||
[ -d "$1/.git" ] && { echo "git"; return; }
|
||||
[ -d "$1/.svn" ] && { echo "svn"; return; }
|
||||
[ -d "$1/CVS" ] && { echo "cvs"; return; }
|
||||
return 1
|
||||
}
|
||||
|
||||
function __vcs_find_type() {
|
||||
# Chercher le type de vcs du répertoire $1. L'arborescence jusqu'au
|
||||
# répertoire $HOME est parcourue si nécessaire. $1 doit être un répertoire
|
||||
# absolu.
|
||||
# Retourner 1 si le type n'a pas été trouvé
|
||||
local root="$1"
|
||||
# soit on a l'information immédiatement...
|
||||
__vcs_get_type "$root" && return
|
||||
# soit il faut la chercher en parcourant l'arborescence...
|
||||
while [ -n "$root" -a "$root" != "/" -a "$root" != "." -a "$root" != "$HOME" ]; do
|
||||
__vcs_get_type "$root" && return
|
||||
root="$(dirname "$root")"
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function __vcs_upward_until() {
|
||||
local root="$1"
|
||||
local type="$2"
|
||||
while [ -n "$root" -a "$root" != "/" -a "$root" != "." -a "$(__vcs_get_type "$root/..")" == "$type" ]; do
|
||||
root="$(dirname "$root")"
|
||||
done
|
||||
echo "$root"
|
||||
}
|
||||
|
||||
function __vcs_find_root() {
|
||||
# A partir du répertoire $1, chercher le répertoire de base du checkout
|
||||
# local. $1 doit être un répertoire absolu.
|
||||
# retourner 1 si le type n'a pas été trouvé
|
||||
local root="$1"
|
||||
local type="$(__vcs_get_type "$root")"
|
||||
if [ "$type" == "git" ]; then
|
||||
# si le type est git, nous sommes forcément déjà à la racine
|
||||
echo "$root"
|
||||
return
|
||||
elif [ "$type" == "svn" -o "$type" == "cvs" ]; then
|
||||
# trouver le répertoire le plus haut
|
||||
__vcs_upward_until "$root" "$type"
|
||||
return
|
||||
else
|
||||
# sinon, il faut chercher dans les répertoire au dessus jusqu'à trouver
|
||||
# un repository. On arrête la recherche à $HOME
|
||||
local found
|
||||
while [ -n "$root" -a "$root" != "/" -a "$root" != "." -a "$root" != "$HOME" ]; do
|
||||
type="$(__vcs_get_type "$root")" && { found=1; break; }
|
||||
root="$(dirname "$root")"
|
||||
done
|
||||
if [ -n "$found" ]; then
|
||||
if [ "$type" == "git" ]; then
|
||||
echo "$root"
|
||||
return
|
||||
elif [ "$type" == "svn" -o "$type" == "cvs" ]; then
|
||||
__vcs_upward_until "$root" "$type"
|
||||
return
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
function _vcs_get_dir() {
|
||||
abspath "${1:-.}"
|
||||
}
|
||||
function _vcs_get_type() {
|
||||
__vcs_find_type "$1" || {
|
||||
eerror "$(ppath "$1"): Ce répertoire n'est pas versionné"
|
||||
return 1
|
||||
}
|
||||
}
|
||||
|
||||
function _vcs_unsupported() {
|
||||
eerror "${1:+$1: }Opération ou option non supportée"
|
||||
return 1
|
||||
}
|
||||
function _vcs_invalid_copy() {
|
||||
eerror "Vous ne pouvez copier/déplacer qu'un fichier sur un fichier"
|
||||
return 1
|
||||
}
|
||||
function _vcs_check_nbargs() {
|
||||
[ "$1" -ge "$2" ] || {
|
||||
eerror "Cette commande nécessite au moins $2 argument(s)"
|
||||
return 1
|
||||
}
|
||||
if [ -n "$3" ]; then
|
||||
[ "$1" -le "$3" ] || {
|
||||
eerror "Cette commande supporte au plus $3 argument(s)"
|
||||
return 1
|
||||
}
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
function _vcs_showhelp() {
|
||||
local action func
|
||||
action="$1"; shift
|
||||
func="vcs_${action}_help"
|
||||
[ $# == 1 -a "$1" == "--help" ] && { "$func" "$action"; return; }
|
||||
return 1
|
||||
}
|
||||
|
||||
function _vcs_dispatch() {
|
||||
local dir action type func
|
||||
dir="$(_vcs_get_dir "$1")"; shift
|
||||
action="$1"; shift
|
||||
_vcs_showhelp "$action" "$@" && return
|
||||
type="$(_vcs_get_type "$dir")" || return
|
||||
func="${type}_${action}"
|
||||
"$func" "$@"
|
||||
}
|
||||
|
||||
########################################
|
||||
function vcs_getvcs_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Afficher le type de vcs pour le répertoire spécifié
|
||||
|
||||
USAGE
|
||||
uproject $1 [dir]"
|
||||
}
|
||||
function vcs_getvcs() {
|
||||
_vcs_showhelp getvcs "$@" && return
|
||||
__vcs_find_type "$(_vcs_get_dir "$1")"
|
||||
}
|
||||
########################################
|
||||
function vcs_getroot_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Afficher le répertoire racine du projet versionné correspondant au répertoire spécifié
|
||||
|
||||
USAGE
|
||||
uproject $1 [dir]"
|
||||
}
|
||||
function vcs_getroot() {
|
||||
_vcs_showhelp getvcs "$@" && return
|
||||
__vcs_find_root "$(_vcs_get_dir "$1")"
|
||||
}
|
||||
########################################
|
||||
function vcs_getrepos_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Afficher l'url du repository du projet versionné correspondant au répertoire spécifié
|
||||
|
||||
USAGE
|
||||
uproject $1 [dir]"
|
||||
}
|
||||
function vcs_getrepos() {
|
||||
_vcs_dispatch "$1" getrepos "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_geturl_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Afficher l'url dans le repository du répertoire versionné spécifié
|
||||
|
||||
USAGE
|
||||
uproject $1 [dir]"
|
||||
}
|
||||
function vcs_geturl() {
|
||||
_vcs_dispatch "$1" geturl "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_vcs_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Appeler le gestionnaire de version approprié avec les arguments donnés
|
||||
|
||||
USAGE
|
||||
uproject $1 [args]"
|
||||
}
|
||||
function vcs_vcs() {
|
||||
_vcs_showhelp vcs "$@" && return
|
||||
|
||||
local type
|
||||
type="$(_vcs_get_type "$(_vcs_get_dir)")" || return
|
||||
"$type" "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_add_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Ajouter les fichiers spécifiés dans le gestionnaire de version
|
||||
|
||||
USAGE
|
||||
uproject $1 <files...>"
|
||||
}
|
||||
function vcs_add() {
|
||||
# le répertoire de référence est le répertoire du premier fichier ajouté
|
||||
_vcs_dispatch "$(dirname "$1")" add "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_remove_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Suppprimer les fichiers versionnés spécifiés du gestionaire de version
|
||||
|
||||
USAGE
|
||||
uproject $1 <files...>"
|
||||
}
|
||||
function vcs_remove() {
|
||||
# le répertoire de référence est le répertoire du premier fichier supprimé
|
||||
_vcs_dispatch "$(dirname "$1")" remove "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_copy_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Copier les fichiers versionnés spécifiés
|
||||
|
||||
USAGE
|
||||
uproject $1 <sources...> <dest>"
|
||||
}
|
||||
function vcs_copy() {
|
||||
# le répertoire de référence est le répertoire de destination
|
||||
local last=$#
|
||||
_vcs_dispatch "$(dirname "${!last}")" copy "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_move_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Déplacer les fichiers versionnés spécifiés
|
||||
|
||||
USAGE
|
||||
uproject $1 <sources...> <dest>"
|
||||
}
|
||||
function vcs_move() {
|
||||
# le répertoire de référence est le répertoire de destination
|
||||
local last=$#
|
||||
_vcs_dispatch "$(dirname "${!last}")" move "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_mkdir_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Créer un nouveau répertoire versionné
|
||||
|
||||
USAGE
|
||||
uproject $1"
|
||||
}
|
||||
function vcs_mkdir() {
|
||||
# le répertoire de référence est le répertoire du premier répertoire créé
|
||||
_vcs_dispatch "$(dirname "$1")" mkdir "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_commit_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Enregistrer les modifications sur les fichiers modifiés avec le message spécifiés
|
||||
|
||||
USAGE
|
||||
uproject $1 <message> [files...]
|
||||
|
||||
Si files n'est pas spécifié, prendre tous les fichiers modifiés actuellement
|
||||
|
||||
OPTIONS
|
||||
-a Enregistrer les modifications sur tous les fichiers modifiés.
|
||||
-c Enregistrer uniquement les modifications de l'index. (si applicable)
|
||||
-l Garder le commit local, i.e. les modifications ne sont pas poussées sur
|
||||
le serveur. (si applicable)"
|
||||
}
|
||||
function vcs_commit() {
|
||||
_vcs_dispatch "" commit "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_status_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Afficher l'état des fichiers versionnés et non versionnés
|
||||
|
||||
USAGE
|
||||
uproject $1"
|
||||
}
|
||||
function vcs_status() {
|
||||
_vcs_dispatch "" status "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_update_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Mettre à jour le checkout local avec les modifications présentes sur le serveur
|
||||
|
||||
USAGE
|
||||
uproject $1
|
||||
|
||||
OPTIONS
|
||||
-x Ne pas mettre à jour les références externes"
|
||||
}
|
||||
function vcs_update() {
|
||||
_vcs_dispatch "" update "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_push_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Pousser les modifications locales sur le serveur
|
||||
|
||||
USAGE
|
||||
uproject $1"
|
||||
}
|
||||
function vcs_push() {
|
||||
_vcs_dispatch "" push "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_diff_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: Afficher les différences
|
||||
|
||||
USAGE
|
||||
uproject $1
|
||||
|
||||
OPTIONS
|
||||
-l (par défaut) Afficher les différences non commitées
|
||||
-c Si cela a du sens, afficher les différences en passe d'être commitées
|
||||
-R Afficher les modifications effectuées depuis la dernière release
|
||||
Pour le moment, l'option -R n'est pas implémentée"
|
||||
}
|
||||
function vcs_diff() {
|
||||
_vcs_dispatch "" diff "$@"
|
||||
}
|
||||
########################################
|
||||
function vcs_tag_help() {
|
||||
local OENC="$UTF8"
|
||||
uecho "uproject $1: donner un nom symbolique à la révision courante
|
||||
|
||||
USAGE
|
||||
uproject $1 <name>"
|
||||
}
|
||||
function vcs_tag() {
|
||||
_vcs_dispatch "" tag "$@"
|
||||
}
|
||||
########################################
|
||||
# XXX Ajouter vcs_revert, vcs_resolve, uproject_grep
|
||||
|
||||
################################################################################
|
||||
# Git
|
||||
|
||||
function git_getrepos() {
|
||||
git config --get remote.origin.url
|
||||
}
|
||||
function git_geturl() {
|
||||
git config --get remote.origin.url
|
||||
}
|
||||
function git_add() {
|
||||
git add "$@"
|
||||
}
|
||||
function git_remove() {
|
||||
git rm "$@"
|
||||
}
|
||||
function git_copy() {
|
||||
git cp "$@"
|
||||
}
|
||||
function git_move() {
|
||||
git mv "$@"
|
||||
}
|
||||
function git_mkdir() {
|
||||
git mkdir "$@"
|
||||
}
|
||||
function git_commit() {
|
||||
local all=auto push=auto nopush args
|
||||
normyesval nopush "$UTOOLS_NOPUSH"
|
||||
[ -n "$nopush" ] && push=
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-a,--all all=1 \
|
||||
-c,--cached all= \
|
||||
-p,--push push=1 \
|
||||
-l,--local push= \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
local message="$1"; shift
|
||||
local -a cmd
|
||||
cmd=(git commit)
|
||||
[ -n "$message" ] && cmd=("${cmd[@]}" -m "$message")
|
||||
if [ "$all" == "auto" ]; then
|
||||
# Si des fichiers sont spécifiés, prendre ceux-là.
|
||||
if [ -z "$*" ]; then
|
||||
# Sinon, s'il y a des fichiers dans l'index, commiter uniquement ces
|
||||
# fichiers
|
||||
# Sinon, committer tous les fichiers modifiés
|
||||
# le code suivant retourne vrai si l'index contient au moins fichier
|
||||
git status --porcelain 2>/dev/null | awk '
|
||||
BEGIN { ec = 1 }
|
||||
substr($0, 1, 1) ~ /[^ ?]/ { ec = 0; exit }
|
||||
END { exit ec }' ||
|
||||
cmd=("${cmd[@]}" -a)
|
||||
fi
|
||||
else
|
||||
[ -n "$all" ] && cmd=("${cmd[@]}" -a)
|
||||
fi
|
||||
|
||||
if ! "${cmd[@]}" "$@"; then
|
||||
[ "$push" == auto ] && return 1
|
||||
fi
|
||||
if [ "$push" == auto ]; then
|
||||
git_push --auto || return
|
||||
elif [ -n "$push" ]; then
|
||||
git_push --force || return
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
function git_status() {
|
||||
git status "$@"
|
||||
}
|
||||
function git_update() {
|
||||
local dummy args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-x dummy \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
git pull "$@"
|
||||
}
|
||||
function git_push() {
|
||||
local all auto force args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-a,--all all=1 \
|
||||
--auto auto=1 \
|
||||
-f,--force force=1 \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
if [ $# -gt 0 ]; then
|
||||
# si des arguments sont spécifiés, les passer à git sans modification
|
||||
git push "$@"
|
||||
return $?
|
||||
elif [ -n "$all" ]; then
|
||||
# On a demandé à pusher toutes les branches
|
||||
git push --all "$@"
|
||||
return $?
|
||||
fi
|
||||
|
||||
# sinon on push vers origin. vérifier la présence du remote
|
||||
[ -n "$(git config --get remote.origin.url)" ] || {
|
||||
if [ -n "$auto" ]; then
|
||||
# en mode automatique, ignorer l'absence de remote
|
||||
return 0
|
||||
else
|
||||
eerror "Aucun remote origin n'est défini"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# puis calculer la branche à pusher
|
||||
local branch="$(git rev-parse --abbrev-ref HEAD 2>/dev/null)"
|
||||
local origin="$(git config --get "branch.$branch.remote")"
|
||||
if [ -n "$branch" -a "$origin" == origin ]; then
|
||||
if [ -n "$auto" ]; then
|
||||
# en mode automatique, ne pousser que la branche courante
|
||||
git push origin "$branch" || return
|
||||
else
|
||||
# pousser toutes les branches
|
||||
git push || return
|
||||
fi
|
||||
elif [ -n "$force" ]; then
|
||||
git push || return
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
function git_diff() {
|
||||
local dummy cached args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-l dummy \
|
||||
-r: '$_vcs_unsupported -r' \
|
||||
-c cached \
|
||||
-R '$_vcs_unsupported -R' \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
git diff ${cached:+--cached} "$@"
|
||||
}
|
||||
function git_tag() {
|
||||
_vcs_unsupported tag #XXX
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Subversion
|
||||
|
||||
function svn_getrepos() {
|
||||
LANG=C svn info "${@:-.}" | awk '/^Repository Root: / { print substr($0, 18) }'
|
||||
}
|
||||
function svn_geturl() {
|
||||
LANG=C svn info "${@:-.}" | awk '/^URL: / { print substr($0, 6) }'
|
||||
}
|
||||
function svn_add() {
|
||||
svn add "$@"
|
||||
}
|
||||
function svn_remove() {
|
||||
svn delete "$@"
|
||||
}
|
||||
function svn_copy() {
|
||||
svn copy --parents "$@"
|
||||
}
|
||||
function svn_move() {
|
||||
svn move --parents "$@"
|
||||
}
|
||||
function svn_mkdir() {
|
||||
svn mkdir --parents "$@"
|
||||
}
|
||||
function svn_commit() {
|
||||
local message="$1"; shift
|
||||
local -a cmd
|
||||
cmd=(svn commit)
|
||||
[ -n "$message" ] && cmd=("${cmd[@]}" -m "$message")
|
||||
cmd=("${cmd[@]}" "${@:-.}")
|
||||
"${cmd[@]}"
|
||||
}
|
||||
function svn_status() {
|
||||
svn status "$@"
|
||||
}
|
||||
function svn_update() {
|
||||
local ignore_externals args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-x ignore_externals \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
svn update ${ignore_externals:+--ignore-externals} "$@"
|
||||
}
|
||||
function svn_push() {
|
||||
local args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
}
|
||||
function svn_diff() {
|
||||
local dummy revision args tmpfile0 tmpfile
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-l dummy \
|
||||
-r: revision \
|
||||
-c '$_vcs_unsupported -c' \
|
||||
-R '$_vcs_unsupported -R' \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
ac_set_tmpfile tmpfile0
|
||||
ac_set_tmpfile tmpfile
|
||||
LANG=C svn status 2>/dev/null | awk '/^$/ { next } /^(M|X|Performing status on external item at)/ { next } { print }' >"$tmpfile0"
|
||||
if [ -s "$tmpfile0" ]; then
|
||||
echo "Fichiers non modifiés dans un état spécial:" >>"$tmpfile"
|
||||
cat "$tmpfile0" >>"$tmpfile"
|
||||
echo "===================================================================" >>"$tmpfile"
|
||||
fi
|
||||
ac_clean "$tmpfile0"
|
||||
|
||||
svn diff -x -u ${revision:+-r "$revision"} "$@" >>"$tmpfile"
|
||||
|
||||
if [ -s "$tmpfile" ]; then
|
||||
"${PAGER:-less}" "$tmpfile"
|
||||
ac_clean "$tmpfile"
|
||||
return 0
|
||||
else
|
||||
einfo "Aucune différence détectée"
|
||||
ac_clean "$tmpfile"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
function svn_tag() {
|
||||
_vcs_unsupported tag #XXX
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# CVS
|
||||
|
||||
function cvs_getrepos() {
|
||||
_vcs_unsupported getrepos
|
||||
}
|
||||
function cvs_geturl() {
|
||||
_vcs_unsupported geturl
|
||||
}
|
||||
function cvs_add() {
|
||||
cvs add "$@"
|
||||
}
|
||||
function cvs_remove() {
|
||||
rm "$@"
|
||||
cvs remove "$@"
|
||||
}
|
||||
|
||||
function cvs_copy() {
|
||||
_vcs_check_nbargs $# 2 2 || return
|
||||
local src="$1" dest="$2"
|
||||
if [ -d "$dest" ]; then
|
||||
# copie d'un fichier vers un répertoire
|
||||
cp "$src" "$dest" || return
|
||||
cvs add "$dest/$(basename "$src")"
|
||||
elif [ -f "$src" ]; then
|
||||
# copie d'un fichier vers un fichier
|
||||
cp "$src" "$dest" || return
|
||||
cvs add "$dest"
|
||||
else
|
||||
_vcs_invalid_copy
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
function cvs_move() {
|
||||
_vcs_check_nbargs $# 2 2 || return
|
||||
local src="$1" dest="$2"
|
||||
if [ -d "$dest" ]; then
|
||||
# copie d'un fichier vers un répertoire
|
||||
mv "$src" "$dest" || return
|
||||
cvs remove "$src"
|
||||
cvs add "$dest/$(basename "$src")"
|
||||
elif [ -f "$src" ]; then
|
||||
# copie d'un fichier vers un fichier
|
||||
mv "$src" "$dest" || return
|
||||
cvs remove "$src"
|
||||
cvs add "$dest"
|
||||
else
|
||||
_vcs_invalid_copy
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
function cvs_mkdir() {
|
||||
mkdir -p "$@"
|
||||
cvs add "$@"
|
||||
}
|
||||
function cvs_commit() {
|
||||
local message="$1"; shift
|
||||
local -a cmd
|
||||
cmd=(cvs commit)
|
||||
[ -n "$message" ] && cmd=("${cmd[@]}" -m "$message")
|
||||
cmd=("${cmd[@]}" "${@:-.}")
|
||||
"${cmd[@]}"
|
||||
}
|
||||
function cvs_status() {
|
||||
cvs update "$@"
|
||||
}
|
||||
function cvs_update() {
|
||||
local dummy args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-x dummy \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
cvs update "$@"
|
||||
}
|
||||
function cvs_push() {
|
||||
local args
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
}
|
||||
function cvs_diff() {
|
||||
local dummy revision args tmpfile
|
||||
parse_opts + "${PRETTYOPTS[@]}" \
|
||||
-l dummy \
|
||||
-r: revision \
|
||||
-c '$_vcs_unsupported -c' \
|
||||
-R '$_vcs_unsupported -R' \
|
||||
@ args -- "$@" && set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
ac_set_tmpfile tmpfile
|
||||
cvs diff -u ${revision:+-r "$revision"} "$@" >"$tmpfile"
|
||||
|
||||
if [ -s "$tmpfile" ]; then
|
||||
"${PAGER:-less}" "$tmpfile"
|
||||
ac_clean "$tmpfile"
|
||||
return 0
|
||||
else
|
||||
ac_clean "$tmpfile"
|
||||
einfo "Aucune différence détectée"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
function cvs_tag() {
|
||||
local cwd rootdir
|
||||
cwd="$(pwd)"
|
||||
rootdir="$(__vcs_find_root "$cwd")"
|
||||
cvs tag "$1" "$(relpath "$rootdir" "$cwd")"
|
||||
}
|
||||
40
ulib/virsh
40
ulib/virsh
@@ -1,40 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Fonction de support pour virsh
|
||||
##@cooked nocomments
|
||||
uprovide virsh
|
||||
|
||||
function virsh_filter() {
|
||||
# filtrer une sortie liste de virsh. En pratique, ne prendre que les lignes
|
||||
# non vides à partir de la ligne "----*"
|
||||
awk '
|
||||
BEGIN { dump = 0 }
|
||||
/^---/ { dump = 1; next }
|
||||
dump && $0 != "" { print }
|
||||
'
|
||||
}
|
||||
|
||||
function virsh_list() {
|
||||
virsh list "$@" | virsh_filter
|
||||
}
|
||||
|
||||
function virsh_pool_list() {
|
||||
virsh pool-list "$@" | virsh_filter
|
||||
}
|
||||
|
||||
function guess_vm_type() {
|
||||
# Afficher hn, kvm, vmware, virtualbox ou openvz suivant que l'on est
|
||||
# *probablement* respectivement sur une machine physique, une machine
|
||||
# virtuelle kvm, vmware, virtualbox, openvz
|
||||
# XXX pour le moment, seuls openvz, kvm et hn sont supportés
|
||||
local ctid="$(grep envID /proc/self/status | awk '{print $2}')"
|
||||
if [ -n "$ctid" -a "$ctid" != "0" ]; then
|
||||
echo openvz
|
||||
return 0
|
||||
fi
|
||||
local cpuid="$(grep 'model name' /proc/cpuinfo)"
|
||||
if quietgrep QEMU <<<"$cpuid"; then
|
||||
echo kvm
|
||||
else
|
||||
echo hn
|
||||
fi
|
||||
}
|
||||
696
ulib/webobjects
696
ulib/webobjects
@@ -1,696 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Gestion des services de webobjects (démarrage/arrêt), et de leur configuration
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
##@require javaproperties
|
||||
uprovide webobjects
|
||||
urequire base sysinfos javaproperties
|
||||
|
||||
################################################################################
|
||||
# Préfixes
|
||||
|
||||
__webobjects_prefixes=
|
||||
function __compute_webobjects_prefixes() {
|
||||
[ -n "$__webobjects_prefixes" ] && return
|
||||
if check_sysinfos -s darwin; then
|
||||
# valeurs par défaut de NEXT_ROOT, WOROOT et LOCALROOT sur MacOS X
|
||||
DEFAULT_NEXT_ROOT=
|
||||
function get_default_woroot_prefix() { echo "$NEXT_ROOT/System"; }
|
||||
function get_default_localroot_prefix() { echo "$NEXT_ROOT"; }
|
||||
else
|
||||
# valeurs par défaut de NEXT_ROOT, WOROOT et LOCALROOT sur les autres Unix
|
||||
DEFAULT_NEXT_ROOT=/opt/Apple
|
||||
function get_default_woroot_prefix() { echo "$NEXT_ROOT"; }
|
||||
function get_default_localroot_prefix() { echo "$NEXT_ROOT/Local"; }
|
||||
fi
|
||||
|
||||
NEXT_ROOT="${NEXT_ROOT:-$DEFAULT_NEXT_ROOT}"
|
||||
WOROOT="${WOROOT:-$(get_default_woroot_prefix)}"
|
||||
LOCALROOT="${LOCALROOT:-$(get_default_localroot_prefix)}"
|
||||
SYSTEMFRAMEWORKS="$WOROOT/Library/Frameworks"
|
||||
WOEXTENSIONS="$LOCALROOT/Library/WebObjects/Extensions"
|
||||
WOFRAMEWORKS="$LOCALROOT/Library/WebObjects/Applications/Frameworks"
|
||||
WOAPPLICATIONS="$LOCALROOT/Library/WebObjects/Applications"
|
||||
WOCONFIGURATION="$LOCALROOT/Library/WebObjects/Configuration"
|
||||
WOAUTOSTART="$WOCONFIGURATION/AutoStart.txt"
|
||||
WOLOGS="/var/log/WebObjects"
|
||||
local versionfile="$SYSTEMFRAMEWORKS/JavaWebObjects.framework/Resources/version.plist"
|
||||
[ -f "$versionfile" ] && WOVERSION="$(grep -A 1 CFBundleShortVersionString "$versionfile" | tail -1 | sed 's/^.*<string>\(.*\)<\/string>.*$/\1/')" || WOVERSION=
|
||||
__webobjects_prefixes=1
|
||||
}
|
||||
|
||||
UTOOLS_PREFIXES=("${UTOOLS_PREFIXES[@]}" NEXT_ROOT WOROOT LOCALROOT SYSTEMFRAMEWORKS WOEXTENSIONS WOFRAMEWORKS WOAPPLICATIONS WOCONFIGURATION WOAUTOSTART WOLOGS WOVERSION)
|
||||
|
||||
function compute_webobjects_prefixes() {
|
||||
__compute_webobjects_prefixes
|
||||
}
|
||||
|
||||
function recompute_webobjects_prefixes() {
|
||||
__webobjects_prefixes=
|
||||
__compute_webobjects_prefixes
|
||||
}
|
||||
|
||||
function get_NEXT_ROOT_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$NEXT_ROOT"
|
||||
}
|
||||
function get_WOROOT_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOROOT"
|
||||
}
|
||||
function get_LOCALROOT_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$LOCALROOT"
|
||||
}
|
||||
function get_SYSTEMFRAMEWORKS_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$SYSTEMFRAMEWORKS"
|
||||
}
|
||||
function get_WOEXTENSIONS_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOEXTENSIONS"
|
||||
}
|
||||
function get_WOFRAMEWORKS_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOFRAMEWORKS"
|
||||
}
|
||||
function get_WOAPPLICATIONS_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOAPPLICATIONS"
|
||||
}
|
||||
function get_WOCONFIGURATION_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOCONFIGURATION"
|
||||
}
|
||||
function get_WOAUTOSTART_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOAUTOSTART"
|
||||
}
|
||||
function get_WOLOGS_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOLOGS"
|
||||
}
|
||||
function get_WOVERSION_prefix() {
|
||||
__compute_webobjects_prefixes
|
||||
echo "$WOVERSION"
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Bundles
|
||||
|
||||
function is_wobundle() {
|
||||
# Tester si $1 a un nom de bundle valide, c'est à dire avec l'extension .woa
|
||||
# ou .framework
|
||||
local bundle="$(basename "$(abspath "$1")")"
|
||||
[ "${bundle%.woa}" != "$bundle" -o "${bundle%.framework}" != "$bundle" ]
|
||||
}
|
||||
|
||||
function is_woappdir() {
|
||||
# Tester si $1 est un répertoire d'application webobjects. Le test est
|
||||
# effectué sur le contenu du bundle, pas sur le nom (utiliser is_wobundle()
|
||||
# pour cela)
|
||||
|
||||
# existence du répertoire
|
||||
[ -d "$1" ] || return 1
|
||||
# répertoires de resources
|
||||
[ -d "$1/Contents/Resources" ] || return 1
|
||||
# répertoires de classpath
|
||||
[ -d "$1/Contents/UNIX" ] || return 1
|
||||
[ -d "$1/Contents/MacOS" ] || return 1
|
||||
[ -d "$1/Contents/Windows" ] || return 1
|
||||
# fin des tests
|
||||
return 0
|
||||
}
|
||||
|
||||
function is_wofwkdir() {
|
||||
# Tester si $1 est un répertoire de framework webobjects. Le test est
|
||||
# effectué sur le contenu du bundle, pas sur le nom (utiliser is_wobundle()
|
||||
# pour cela)
|
||||
|
||||
# existence du répertoire
|
||||
[ -d "$1" ] || return 1
|
||||
# répertoires de resource
|
||||
[ -d "$1/Resources" -o -d "$1/WebServerResources" ] || return 1
|
||||
# fin des tests
|
||||
return 0
|
||||
}
|
||||
|
||||
function get_app_winclspth() {
|
||||
# calculer la valeur de Contents/Windows/CLSSPATH.txt pour l'application $1
|
||||
local found
|
||||
if [ ! -f "$1/Contents/Windows/CLSSPATH.txt" ]; then
|
||||
local clspth
|
||||
array_from_lines clspth "$(list_files "$1/Contents/Windows" | grep -i clsspath.txt)"
|
||||
if [ ${#clspth[*]} -eq 1 ]; then
|
||||
echo "Contents/Windows/$clspth"
|
||||
found=1
|
||||
fi
|
||||
fi
|
||||
# pas trouvé, prendre la valeur par défaut
|
||||
[ -n "$found" ] || echo Contents/Windows/CLSSPATH.txt
|
||||
}
|
||||
|
||||
function get_infofile() {
|
||||
# Obtenir le chemin vers le fichier Info.plist dans le répertoire de
|
||||
# resource du bundle $1
|
||||
local bundle="$(abspath "$1")" resdir
|
||||
if endswith "$bundle" .woa; then
|
||||
resdir="$bundle/Contents"
|
||||
elif endswith "$bundle" .framework; then
|
||||
resdir="$bundle/Resources"
|
||||
else
|
||||
# on a donné directement resdir
|
||||
resdir="$bundle"
|
||||
fi
|
||||
echo "$resdir/Info.plist"
|
||||
}
|
||||
|
||||
function read_infofile() {
|
||||
# Lire la version et le numéro de release dans le fichier $1 (chemin vers
|
||||
# Info.plist) et les placer dans les variables $2(=version) et $3(=release)
|
||||
# Retourner 1 si un erreur s'est produite, par exemple si le fichier $1
|
||||
# n'existe pas ou n'est pas accessible en lecture
|
||||
[ -f "$1" -a -r "$1" ] || return 1
|
||||
set_var "${2:-version}" "$(grep -A 1 CFBundleShortVersionString "$1" | tail -1 | sed 's/^.*<string>\(.*\)<\/string>.*$/\1/')"
|
||||
set_var "${3:-release}" "$(grep -A 1 CFBundleVersion "$1" | tail -1 | sed 's/^.*<string>\(.*\)<\/string>.*$/\1/')"
|
||||
}
|
||||
|
||||
function write_infofile() {
|
||||
# Ecrire $2 (la version) et $3 (le numéro de release) dans le fichier $1
|
||||
# (chemin vers Info.plist)
|
||||
# Retourner 1 si un erreur s'est produite, par exemple si le fichier $1
|
||||
# n'existe pas
|
||||
local status tmpfile
|
||||
ac_set_tmpfile tmpfile
|
||||
<"$1" >"$tmpfile" cawkrun version="$2" release="$3" '
|
||||
/<key>CFBundleShortVersionString<\/key>/ {
|
||||
print; getline
|
||||
sub(/<string>.*<\/string>/, "<string>" version "</string>")
|
||||
print; next
|
||||
}
|
||||
/<key>CFBundleVersion<\/key>/ {
|
||||
print; getline
|
||||
sub(/<string>.*<\/string>/, "<string>" release "</string>")
|
||||
print; next
|
||||
}
|
||||
{ print }
|
||||
' && cat "$tmpfile" >"$1"
|
||||
status=$?
|
||||
ac_clean "$tmpfile"
|
||||
return $status
|
||||
}
|
||||
|
||||
function get_jawotoolsfile() {
|
||||
# Obtenir le chemin vers le fichier jawotools.properties dans le bundle $1
|
||||
local default="$1/jawotools.properties" file
|
||||
for file in "$default" "$1/build_infos.txt"; do
|
||||
if [ -f "$file" ]; then
|
||||
echo "$file"
|
||||
return
|
||||
fi
|
||||
done
|
||||
echo "$default"
|
||||
}
|
||||
|
||||
function read_jawotoolsfile() {
|
||||
# lire le fichier de propriété $1 et placer les valeurs dans les variables
|
||||
# $2(=version), $3(=releaseDate), $4(=description)
|
||||
local filename="$(basename "$1")"
|
||||
if [ "$filename" == "build_infos.txt" ]; then
|
||||
# legacy
|
||||
read_property "$1" version "${2:-version}"
|
||||
read_property "$1" date "${3:-releaseDate}"
|
||||
read_property "$1" desc "${4:-description}"
|
||||
else
|
||||
read_property "$1" version "${2:-version}"
|
||||
read_property "$1" releaseDate "${3:-releaseDate}"
|
||||
read_property "$1" description "${4:-description}"
|
||||
fi
|
||||
}
|
||||
|
||||
function save_jawotoolsfile() {
|
||||
# écrire le fichier de propriété $1 avec les valeurs version ($2),
|
||||
# releaseDate ($3) et description ($4)
|
||||
[ -e "$1" ] || touch "$1"
|
||||
write_property "$1" version "$2"
|
||||
write_property "$1" releaseDate "$3"
|
||||
write_property "$1" description "$4"
|
||||
}
|
||||
|
||||
function get_versionfile() {
|
||||
# Obtenir le chemin vers le fichier VERSION.txt dans le répertoire de
|
||||
# resource du bundle $1
|
||||
local bundle="$(abspath "$1")" resdir
|
||||
if endswith "$bundle" .woa; then
|
||||
resdir="$bundle/Contents/Resources"
|
||||
elif endswith "$bundle" .framework; then
|
||||
resdir="$bundle/Resources"
|
||||
else
|
||||
# on a donné directement resdir
|
||||
resdir="$bundle"
|
||||
fi
|
||||
local default="$resdir/VERSION.txt" file
|
||||
for file in "$default" "$1/version.txt"; do
|
||||
if [ -f "$file" ]; then
|
||||
echo "$file"
|
||||
return
|
||||
fi
|
||||
done
|
||||
echo "$default"
|
||||
}
|
||||
|
||||
function get_configfile() {
|
||||
# obtenir le chemin vers le fichier de configuration du répertoire de
|
||||
# resource du bundle
|
||||
# $1=bundle ou resdir (appdir/Contents/Resources ou fwkdir/Resources)
|
||||
local bundle="$(abspath "$1")" resdir
|
||||
if endswith "$bundle" .woa; then
|
||||
resdir="$bundle/Contents/Resources"
|
||||
elif endswith "$bundle" .framework; then
|
||||
resdir="$bundle/Resources"
|
||||
else
|
||||
# on a donné directement resdir
|
||||
resdir="$bundle"
|
||||
fi
|
||||
local configs
|
||||
array_lsfiles configs "$resdir" "*.config"
|
||||
if [ ${#configs[*]} -eq 0 ]; then
|
||||
array_lsfiles configs "$resdir" "config.xml"
|
||||
fi
|
||||
echo "${configs:-$resdir/Properties}"
|
||||
}
|
||||
|
||||
function searchreplace_classpath() {
|
||||
# Dans les fichiers classpath de l'application $1, remplacer $2 par $3. Si
|
||||
# $3 est vide, la ligne est supprimée
|
||||
local bundle="$1" search="$2" replace="$3" scriptunx scriptwin clspth
|
||||
|
||||
[ -n "$search" ] || return 1
|
||||
search="${search//\//\\/}"; replace="${replace//\//\\/}"
|
||||
if [ -n "$replace" ]; then
|
||||
scriptunx="s/${search}/${replace}/g"
|
||||
else
|
||||
scriptunx="/${search}/d"
|
||||
fi
|
||||
search="${search//\\\//\\\\}"; replace="${replace//\\\//\\\\}"
|
||||
if [ -n "$replace" ]; then
|
||||
scriptwin="s/${search}/${replace}/g"
|
||||
else
|
||||
scriptwin="/${search}/d"
|
||||
fi
|
||||
|
||||
clspth="$bundle/Contents/UNIX/UNIXClassPath.txt"
|
||||
nl2lf "$clspth"; sedi "$scriptunx" "$clspth"
|
||||
clspth="$bundle/Contents/MacOS/MacOSClassPath.txt"
|
||||
nl2lf "$clspth"; sedi "$scriptunx" "$clspth"
|
||||
clspth="$bundle/$(get_app_winclspth "$bundle")"
|
||||
nl2lf "$clspth"; sedi "$scriptwin" "$clspth"; nl2crlf "$clspth"
|
||||
}
|
||||
|
||||
function dump_jars() {
|
||||
# Afficher les jars des frameworks utilisés par l'application $1
|
||||
local clspth
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
clspth="Contents/MacOS/MacOSClassPath.txt"
|
||||
else
|
||||
clspth="Contents/UNIX/UNIXClassPath.txt"
|
||||
fi
|
||||
cat "$1/$clspth" | _nl2lf | grep '\.framework' | grep -v "^#" | grep -v "APPROOT/" | grep -v "WOROOT/" | awk '{
|
||||
if (match($0, /[^\/]*\.framework/) != 0) {
|
||||
print
|
||||
}
|
||||
}' | sort -u
|
||||
}
|
||||
|
||||
function dump_frameworks() {
|
||||
# Afficher les frameworks utilisés par l'application $1
|
||||
dump_jars "$1" | awk '{
|
||||
if (match($0, /[^\/]*\.framework/) != 0) {
|
||||
print substr($0, RSTART, RLENGTH)
|
||||
}
|
||||
}'
|
||||
}
|
||||
|
||||
function remove_framework() {
|
||||
# supprimer le framework $2 (nom de base) des fichiers de classpath du
|
||||
# bundle d'application $1
|
||||
local bundle="$1" framework="$2" frameworks
|
||||
|
||||
endswith "$framework" .framework || framework="$framework.framework"
|
||||
array_from_lines frameworks "$(dump_frameworks "$bundle")"
|
||||
if array_contains frameworks "$framework"; then
|
||||
searchreplace_classpath "$bundle" "^LOCALROOT/.*/$framework/"
|
||||
fi
|
||||
}
|
||||
|
||||
function add_framework() {
|
||||
# s'il n'y existe pas déjà, ajouter le framework $2 (nom de base ou chemin
|
||||
# absolu) aux fichiers de classpath du bundle d'application $1
|
||||
local bundle="$1" framework="$2" frameworks jars jar line
|
||||
local winclspth="$(get_app_winclspth "$bundle")"
|
||||
|
||||
endswith "$framework" .framework || framework="$framework.framework"
|
||||
array_from_lines frameworks "$(dump_frameworks "$bundle")"
|
||||
if ! array_contains frameworks "$framework"; then
|
||||
if beginswith "$framework" /; then
|
||||
# on a donné un chemin absolu
|
||||
array_lsfiles jars "$framework/Resources/Java" "*.jar"
|
||||
if [ -z "${jars[*]}" ]; then
|
||||
eerror "Impossible de trouver les fichiers du framework $framework
|
||||
dans $WOFRAMEWORKS"
|
||||
return 1
|
||||
else
|
||||
for jar in "${jars[@]}"; do
|
||||
echo "$jar" >>"$bundle/Contents/UNIX/UNIXClassPath.txt"
|
||||
echo "$jar" >>"$bundle/Contents/MacOS/MacOSClassPath.txt"
|
||||
echo "${jar//\//\\}" >>"$bundle/$winclspth"
|
||||
done
|
||||
fi
|
||||
else
|
||||
# on a donné juste le nom du framework
|
||||
array_from_lines jars "$(list_files "$WOFRAMEWORKS/$framework/Resources/Java" "*.jar")"
|
||||
if [ -z "${jars[*]}" ]; then
|
||||
eerror "Impossible de trouver les fichiers du framework $framework
|
||||
dans $WOFRAMEWORKS"
|
||||
return 1
|
||||
else
|
||||
for jar in "${jars[@]}"; do
|
||||
line="LOCALROOT/Library/WebObjects/Applications/Frameworks/$framework/Resources/Java/$jar"
|
||||
echo "$line" >>"$bundle/Contents/UNIX/UNIXClassPath.txt"
|
||||
echo "$line" >>"$bundle/Contents/MacOS/MacOSClassPath.txt"
|
||||
echo "${line//\//\\}" >>"$bundle/$winclspth"
|
||||
done
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
function fix_jars_case() {
|
||||
# Vérifier que la casse des jars de tous les frameworks utilisés par
|
||||
# l'application $1 est conforme au système de fichier
|
||||
local bundle="$1" clspth jars jar fwkdir fwkname jarname jarnamefs
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
clspth="Contents/MacOS/MacOSClassPath.txt"
|
||||
else
|
||||
clspth="Contents/UNIX/UNIXClassPath.txt"
|
||||
fi
|
||||
array_from_lines jars "$(dump_jars "$bundle")"
|
||||
for jar in "${jars[@]}"; do
|
||||
{ endswith "$jar" .jar || endswith "$jar" .zip; } || continue
|
||||
|
||||
if beginswith "$jar" LOCALROOT; then
|
||||
fwkname="${jar##*/Frameworks/}"; fwkname="${fwkname%%/*}"
|
||||
fwkdir="$WOFRAMEWORKS"
|
||||
else
|
||||
fwkdir="${jar%/*.framework/*}"
|
||||
fwkname="${jar##/*.framework/}";
|
||||
fwkname="${jar:0:$((${#jar}-${#fwkname}-1))}"; fwkname="${fwkname##*/}"
|
||||
fi
|
||||
jarname="${jar##*/}"
|
||||
|
||||
if [ ! -d "$fwkdir/$fwkname" ]; then
|
||||
eerror "$(basename "$bundle"): $fwkname: ce framework n'existe pas"
|
||||
continue
|
||||
fi
|
||||
|
||||
array_from_lines jarnamefs "$(list_files "$fwkdir/$fwkname/Resources/Java" "*.jar" | grep -i "^$jarname")"
|
||||
if [ ${#jarnamefs[*]} -eq 0 ]; then
|
||||
eerror "$(basename "$bundle"): $fwkname: $jarname n'existe pas"
|
||||
elif [ ${#jarnamefs[*]} -gt 1 ]; then
|
||||
eerror "$(basename "$bundle"): $fwkname: il existe plusieurs jars $jarname"
|
||||
else
|
||||
if [ "$jarname" != "$jarnamefs" ]; then
|
||||
einfo "$(basename "$bundle"): $fwkname: $jarnamefs"
|
||||
searchreplace_classpath "$bundle" "$fwkname/Resources/Java/$jarname" "$fwkname/Resources/Java/$jarnamefs"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
function verifix_bundle() {
|
||||
# vérifier et corriger le bundle $1. Pour une application, on vérifie que le
|
||||
# script est exécutable. Pour un framework, on vérifie que le framework est
|
||||
# conforme au modèle des framework générés par WebObjects.
|
||||
local bundle="$1"
|
||||
if is_woappdir "$bundle"; then
|
||||
local script="$bundle/$(basename "$bundle" .woa)"
|
||||
if [ ! -x "$script" ]; then
|
||||
chmod +x "$script"
|
||||
fi
|
||||
|
||||
elif is_wofwkdir "$bundle"; then
|
||||
[ -L "$bundle/Resources" ] && return
|
||||
|
||||
local filename
|
||||
|
||||
if [ ! -L "$bundle/Resources" ]; then
|
||||
rm -rf "$bundle/Versions/A/Resources"
|
||||
cpdir "$bundle/Resources" "$bundle/Versions/A/Resources"
|
||||
rm -rf "$bundle/Resources"
|
||||
fi
|
||||
if [ ! -L "$bundle/WebServerResource" ]; then
|
||||
rm -rf "$bundle/Versions/A/WebServerResources"
|
||||
cpdir "$bundle/WebServerResources" "$bundle/Versions/A/WebServerResources"
|
||||
rm -rf "$bundle/WebServerResources"
|
||||
fi
|
||||
local cwd="$(pwd)"
|
||||
cd "$bundle/Versions"
|
||||
if [ -e Current ]; then
|
||||
if [ ! -L Current -a -d Current ]; then
|
||||
rm -rf Current
|
||||
else
|
||||
rm -f Current
|
||||
fi
|
||||
fi
|
||||
ln -s A Current
|
||||
cd ..
|
||||
ln -s Versions/Current/Resources Resources
|
||||
ln -s Versions/Current/WebServerResources WebServerResources
|
||||
cd "$cwd"
|
||||
fi
|
||||
}
|
||||
|
||||
function compute_fapps() {
|
||||
# Placer dans le tableau $1(=fappnames) la liste des noms de bundle
|
||||
# d'applications qui dépendent du framework $2
|
||||
# Cette opération est faite à partir des informations sur le système de
|
||||
# fichier. Elle ne peut donc concerner qu'une installation locale.
|
||||
local -a __cf_fappnames
|
||||
local __cf_fwknames __cf_fwkname __cf_appnames __cf_appname
|
||||
|
||||
__cf_fwkname="$2"
|
||||
[ "${__cf_fwkname%.framework}" != "$__cf_fwkname" ] || __cf_fwkname="$__cf_fwkname.framework"
|
||||
__cf_fwkname="$(basename "$__cf_fwkname")"
|
||||
|
||||
array_from_lines __cf_appnames "$(list_dirs "$WOAPPLICATIONS" "*.woa")"
|
||||
for __cf_appname in "${__cf_appnames[@]}"; do
|
||||
array_from_lines __cf_fwknames "$(dump_frameworks "$WOAPPLICATIONS/$__cf_appname")"
|
||||
if array_contains __cf_fwknames "$__cf_fwkname"; then
|
||||
array_set __cf_fappnames "$__cf_appname"
|
||||
fi
|
||||
done
|
||||
array_copy "${1:-fappnames}" __cf_fappnames
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Applications et instances
|
||||
|
||||
WORAURL_USE_PROXY= # faut-il passer par un proxy?
|
||||
WORAURL_DATA=
|
||||
function woraurl() {
|
||||
# Faire une requête avec la méthode $1 sur l'url $2 avec le payload $3 (par
|
||||
# exemple pour la méthode POST). la réponse est disponible dans le fichier
|
||||
# $WORAURL_DATA, $4(=http_code) contient le code de réponse.
|
||||
# Retourner 0 en cas de succès, ou une valeur différente de zéro si un
|
||||
# erreur se produit (typiquement, 3 pour une erreur du serveur, 1 pour une
|
||||
# réponse applicative, comme par exemple si l'application n'existe pas)
|
||||
# Les codes de réponse 2xx et 417 sont des succès
|
||||
# Les autres codes (à priori 4xx ou 5xx) sont des erreurs
|
||||
# note: le code 417 est utilisé par le moniteur pour répondre "Non", par
|
||||
# opposition à 200 utilisé pour répondre "OUI"
|
||||
local _status _http_code _args
|
||||
[ -n "$WORAURL_DATA" ] || ac_set_tmpfile WORAURL_DATA
|
||||
_args=(-s -X "${1:-GET}" ${3:+-d "$3"} -w '%{http_code}' -o "$WORAURL_DATA")
|
||||
[ -z "$WORAURL_USE_PROXY" ] && _args=("${_args[@]}" -x "")
|
||||
_http_code="$(curl "${_args[@]}" "$2")"
|
||||
case "$_http_code" in
|
||||
2*|417) _status=0;;
|
||||
4*) _status=1;;
|
||||
5*) _status=3;;
|
||||
*) _status=11;;
|
||||
esac
|
||||
set_var "${4:-http_code}" "$_http_code"
|
||||
return $_status
|
||||
}
|
||||
function wogeturl() { woraurl GET "$@"; }
|
||||
|
||||
function splitins() {
|
||||
# Analyser le nom $1, qui peut être de forme '', 'Name.woa',
|
||||
# 'Name.framework', 'App' ou 'Instance-N' (où N est un nombre), et
|
||||
# initialiser les variables $2(=type) et $3(=name)
|
||||
# Si $1=="", type=all et name=""
|
||||
# Si $1==Name.woa, type=woa et name=Name.woa
|
||||
# Si $1==Name.framework, type=fwk et name=Name.framework
|
||||
# Si $1==App, type=app et name=App
|
||||
# si $1==App-N, type=ins et name=App-N
|
||||
if [ -z "$1" ]; then
|
||||
set_var "${2:-type}" all
|
||||
set_var "${3:-name}"
|
||||
elif [ "${1%.woa}" != "$1" ]; then
|
||||
set_var "${2:-type}" woa
|
||||
set_var "${3:-name}" "$1"
|
||||
elif [ "${1%.framework}" != "$1" ]; then
|
||||
set_var "${2:-type}" fwk
|
||||
set_var "${3:-name}" "$1"
|
||||
elif [[ "$1" == *-* ]]; then
|
||||
local __si_name __si_num
|
||||
__si_name="${1%-*}"
|
||||
__si_num="${1##*-}"
|
||||
if [ -z "${__si_num//[0-9]/}" ]; then
|
||||
set_var "${2:-type}" ins
|
||||
set_var "${3:-name}" "$1"
|
||||
else
|
||||
set_var "${2:-type}" app
|
||||
set_var "${3:-name}" "$1"
|
||||
fi
|
||||
elif [ -n "$1" ]; then
|
||||
set_var "${2:-type}" app
|
||||
set_var "${3:-name}" "$1"
|
||||
fi
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Environnement
|
||||
|
||||
function create_wodirs_maybe() {
|
||||
mkdir -p "$WOAPPLICATIONS"
|
||||
mkdir -p "$WOFRAMEWORKS"
|
||||
}
|
||||
|
||||
function check_autostart() {
|
||||
# vérifier la présence du fichier $WOAUTOSTART. Si ce n'est pas le cas, le
|
||||
# créer avec le contenu du tableau $1
|
||||
if [ ! -f "$WOAUTOSTART" -a -n "$1" ]; then
|
||||
array_to_lines "$1" | csort >"$WOAUTOSTART" || return 1
|
||||
enote "Le fichier $(ppath "$WOAUTOSTART") a été créé avec la liste suivante:
|
||||
$(<"$WOAUTOSTART")"
|
||||
fi
|
||||
}
|
||||
|
||||
function get_autostart_order() {
|
||||
# Initialiser le tableau $1 avec la liste donnée dans le fichier
|
||||
# $WOAUTOSTART
|
||||
array_from_lines "$1" "$(<"$WOAUTOSTART" filter_comment)"
|
||||
}
|
||||
|
||||
function apply_autostart_order() {
|
||||
# Réordonner les valeurs $3..* selon la liste donnée dans le tableau $2,
|
||||
# puis placer le résultat dans le tableau $1. $2 doit être construit avec
|
||||
# get_autostart_order(). Si $2 n'est pas spécifié, la liste est construite
|
||||
# localement.
|
||||
# Si le tableau contient des lignes de délai @N, replacer les délais après
|
||||
# les applications appropriées
|
||||
local __aa_reverse
|
||||
if [ "$1" == "-r" ]; then
|
||||
__aa_reverse=1
|
||||
shift
|
||||
fi
|
||||
local -a __aa_oapps __aa_src
|
||||
local __aa_dest="$1" __aa_oapp; shift
|
||||
local __found
|
||||
if [ -n "$1" ]; then
|
||||
array_copy __aa_oapps "$1"
|
||||
else
|
||||
get_autostart_order __aa_oapps
|
||||
fi
|
||||
shift
|
||||
set_array __aa_src @ "$@"
|
||||
array_new "$__aa_dest"
|
||||
for __aa_oapp in "${__aa_oapps[@]}"; do
|
||||
if [[ "$__aa_oapp" == @* ]]; then
|
||||
# Si on trouve une ligne @N, et que la précédente ligne a été
|
||||
# sélectionnée, alors inclure le délai aussi dans la liste des
|
||||
# valeurs à prendre en compte
|
||||
[ -n "$__aa_found" ] && array_add "$__aa_dest" "$__aa_oapp"
|
||||
__aa_found=
|
||||
elif array_contains __aa_src "$__aa_oapp"; then
|
||||
array_add "$__aa_dest" "$__aa_oapp"
|
||||
array_del __aa_src "$__aa_oapp"
|
||||
__aa_found=1
|
||||
else
|
||||
__aa_found=
|
||||
fi
|
||||
done
|
||||
array_extend "$__aa_dest" __aa_src
|
||||
[ -n "$__aa_reverse" ] && array_reverse "$__aa_dest"
|
||||
}
|
||||
|
||||
function __unix_woservices() {
|
||||
if [ -x /etc/init.d/WOServices ]; then
|
||||
/etc/init.d/WOServices "$@"
|
||||
else
|
||||
eerror "Ce script ne sait pas piloter wotaskd/javamonitor sur cette plateforme"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
SERVICE_OVERRIDE_wotaskd_stop=wotaskd_stop
|
||||
function wotaskd_stop() {
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
launchctl unload /System/Library/LaunchDaemons/com.apple.wotaskd.plist
|
||||
else
|
||||
__unix_woservices stop
|
||||
fi
|
||||
}
|
||||
|
||||
SERVICE_OVERRIDE_wotaskd_start=wotaskd_start
|
||||
function wotaskd_start() {
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
launchctl load /System/Library/LaunchDaemons/com.apple.wotaskd.plist
|
||||
else
|
||||
__unix_woservices start
|
||||
fi
|
||||
}
|
||||
|
||||
SERVICE_OVERRIDE_javamonitor_stop=javamonitor_stop
|
||||
SERVICE_OVERRIDE_womonitor_stop=javamonitor_stop
|
||||
function javamonitor_stop() {
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
launchctl unload /System/Library/LaunchDaemons/com.apple.womonitor.plist
|
||||
else
|
||||
__unix_woservices stop
|
||||
fi
|
||||
}
|
||||
function womonitor_stop() { javamonitor_stop "$@"; }
|
||||
|
||||
SERVICE_OVERRIDE_javamonitor_start=javamonitor_start
|
||||
SERVICE_OVERRIDE_womonitor_start=javamonitor_start
|
||||
function javamonitor_start() {
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
launchctl load /System/Library/LaunchDaemons/com.apple.womonitor.plist
|
||||
else
|
||||
__unix_woservices start
|
||||
fi
|
||||
}
|
||||
function womonitor_start() { javamonitor_start "$@"; }
|
||||
|
||||
SERVICE_OVERRIDE_woservices_stop=woservices_stop
|
||||
function woservices_stop() {
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
javamonitor_stop
|
||||
wotaskd_stop
|
||||
else
|
||||
__unix_woservices stop
|
||||
fi
|
||||
}
|
||||
|
||||
SERVICE_OVERRIDE_woservices_start=woservices_start
|
||||
function woservices_start() {
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
wotaskd_start
|
||||
javamonitor_start
|
||||
else
|
||||
__unix_woservices start
|
||||
fi
|
||||
}
|
||||
558
ulib/woinst
558
ulib/woinst
@@ -1,558 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Déploiement de bundle WebObjects
|
||||
##@cooked nocomments
|
||||
##@require ulib
|
||||
##@require base
|
||||
##@require prefixes
|
||||
##@require apache
|
||||
##@require webobjects
|
||||
uprovide woinst
|
||||
urequire ulib base prefixes apache webobjects
|
||||
|
||||
function date2version() {
|
||||
local date="$1"
|
||||
dd="$(expr "$date" : "\(..\)")"; [ -z "$dd" ] && dd="$(date +%d)"
|
||||
mm="$(expr "$date" : "../\(..\)")"; [ -z "$mm" ] && mm="$(date +%m)"
|
||||
yyyy="$(expr "$date" : "../../\(....\)")"; [ -z "$yyyy" ] && yyyy="$(date +%Y)"
|
||||
yy="$(expr "$yyyy" : "..\(..\)")"
|
||||
echo "$yyyy$mm$dd"
|
||||
}
|
||||
|
||||
function woconf() {
|
||||
function __woconf_display_help() {
|
||||
uecho "woctl configure: configurer une application ou un framework
|
||||
|
||||
USAGE
|
||||
configure <app.woa|fwk.framework> [cmds...]
|
||||
|
||||
cmds est soit un unique argument avec une commande par ligne, soit une suite de commandes séparées par //
|
||||
|
||||
COMMANDES
|
||||
# comment
|
||||
Les commentaires sont ignorés
|
||||
v[erify]
|
||||
Vérifier le corriger la consistance du bundle.
|
||||
Cette action est effectuée automatiquement sauf si l'option --no-verify
|
||||
est spécifiée.
|
||||
set_config configfile
|
||||
c>configfile
|
||||
Changer le fichier de configuration par défaut
|
||||
set_config configfile srcfile
|
||||
c>configfile:srcfile
|
||||
Créer le fichier configfile en le copiant depuis srcfile, et en faire le
|
||||
nouveau fichier de configuration par défaut
|
||||
set_property prop value [configfile]
|
||||
c[configfile/]prop=value
|
||||
Modifier une propriété dans le fichier de configuration spécifié.
|
||||
Utiliser le fichier de configuration par défaut si configfile n'est pas
|
||||
spécifié.
|
||||
set_eomodel eomodel
|
||||
e>eomodel
|
||||
Changer l'eomodel par défaut
|
||||
set_dbconfig dbConfig [eomodel]
|
||||
e[eomodel/]dbConfig
|
||||
Activer la configuration dbConfig dans l'eomodel spécifié. Utiliser
|
||||
l'eomodel par défaut si eomodel n'est pas spécifié.
|
||||
add Fwk.framework
|
||||
aFwk.framework
|
||||
Ajouter un framework au classpath de l'application
|
||||
remove Fwk.framework
|
||||
rFwk.framework
|
||||
Enlever un framework du classpath de l'application
|
||||
replace before after
|
||||
sbefore:after
|
||||
Faire un recherche/remplace dans les fichiers de classpath de
|
||||
l'application.
|
||||
f[ix_case]
|
||||
Corriger la casse dans les fichiers de classpath de l'application, selon
|
||||
les frameworks effectivement installés. En effet, un déploiement qui
|
||||
peut fonctionner sur MacOSX, dont le système de fichier n'est pas
|
||||
sensible à la casse, peut cesser de fonctionner sur Linux, parce que le
|
||||
nom du jar ne correspond pas."
|
||||
}
|
||||
|
||||
local noverify bundle cmds cmd
|
||||
noverify=
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with __woconf_display_help' \
|
||||
--noverify,--no-verify noverify=1 \
|
||||
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
||||
|
||||
bundle="$1"; shift
|
||||
[ -n "$bundle" ] || {
|
||||
eerror "Il faut spécifier le bundle à configurer"
|
||||
return 1
|
||||
}
|
||||
if is_wobundle "$bundle" && is_woappdir "$bundle"; then
|
||||
:
|
||||
elif is_wobundle "$bundle" && is_wofwkdir "$bundle"; then
|
||||
:
|
||||
else
|
||||
eerror "N'est pas un bundle valide: $bundle"
|
||||
return 1
|
||||
fi
|
||||
bundle="$(abspath "$bundle")"
|
||||
[ -w "$bundle" ] || die "Bundle non accessible en écriture"
|
||||
|
||||
if [ $# -le 1 ]; then
|
||||
array_from_lines cmds "$(filter_comment <<<"$1")"
|
||||
else
|
||||
cmds=()
|
||||
cmd=()
|
||||
while [ -n "$1" ]; do
|
||||
if [ "$1" == // ]; then
|
||||
if [ -n "${cmd[*]}" ]; then
|
||||
cmds=("${cmds[@]}" "$(quoted_args "${cmd[@]}")")
|
||||
fi
|
||||
cmd=()
|
||||
else
|
||||
cmd=("${cmd[@]}" "$1")
|
||||
fi
|
||||
shift
|
||||
done
|
||||
if [ -n "${cmd[*]}" ]; then
|
||||
cmds=("${cmds[@]}" "$(quoted_args "${cmd[@]}")")
|
||||
fi
|
||||
fi
|
||||
|
||||
etitle "Configuration de $(ppath "$bundle")"
|
||||
local verify_done first=1
|
||||
[ -z "$noverify" ] && {
|
||||
estep verify
|
||||
verifix_bundle "$bundle"
|
||||
verify_done=1
|
||||
}
|
||||
for cmd in "${cmds[@]}"; do
|
||||
eval "set -- $cmd"
|
||||
if [ $# -eq 1 ]; then
|
||||
# commandes abrégées sur une lettre
|
||||
case "$1" in
|
||||
v|verify|verifix)
|
||||
# si v est en premier, et que la vérification a déjà été faite,
|
||||
# alors on peut l'ignorer
|
||||
if [ -z "$first" -o -z "$verify_done" ]; then
|
||||
estep "verify"
|
||||
verifix_bundle "$bundle"
|
||||
fi
|
||||
;;
|
||||
f|fix_case|fix-case)
|
||||
estep "fix-case"
|
||||
fix_jars_case "$bundle"
|
||||
;;
|
||||
c*)
|
||||
eerror "set_config / set_property ne sont pas implémentés"
|
||||
;;
|
||||
e*)
|
||||
eerror "set_eomodel / set_dbconfig ne sont pas implémentés"
|
||||
;;
|
||||
a*)
|
||||
local framework="${1#a}"
|
||||
estep "add $framework"
|
||||
add_framework "$bundle" "$framework"
|
||||
;;
|
||||
r*)
|
||||
local framework="${1#r}"
|
||||
estep "remove $framework"
|
||||
remove_framework "$bundle" "$framework"
|
||||
;;
|
||||
s*)
|
||||
local search replace
|
||||
replace="${1#s}"
|
||||
search="${replace%%:*}"
|
||||
replace="${replace#*:}"
|
||||
if [ -n "$replace" ]; then
|
||||
estep "Replace in classpath $search --> $replace"
|
||||
else
|
||||
estep "Delete in classpath $search"
|
||||
fi
|
||||
searchreplace_classpath "$bundle" "$search" "$replace"
|
||||
;;
|
||||
*) eerror "Commande invalide: $1";;
|
||||
esac
|
||||
else
|
||||
# commandes "user-friendly"
|
||||
case "$1" in
|
||||
conf|config|set_conf|set_config)
|
||||
eerror "set_config n'est pas implémenté"
|
||||
;;
|
||||
prop|property|set_prop|set_property)
|
||||
eerror "set_property n'est pas implémenté"
|
||||
;;
|
||||
eomodel|set_eomodel)
|
||||
eerror "set_eomodel n'est pas implémenté"
|
||||
;;
|
||||
dbconf|dbconfig|set_dbconf|set_dbconfig)
|
||||
eerror "set_dbconfig n'est pas implémenté"
|
||||
;;
|
||||
add|add_fwk|add_framework)
|
||||
estep "add $2"
|
||||
add_framework "$bundle" "$2"
|
||||
;;
|
||||
remove|remove_fwk|remove_framework)
|
||||
estep "remove $2"
|
||||
remove_framework "$bundle" "$2"
|
||||
;;
|
||||
repl|replace)
|
||||
if [ -n "$3" ]; then
|
||||
estep "Replace in classpath $2 --> $3"
|
||||
else
|
||||
estep "Delete in classpath $2"
|
||||
fi
|
||||
searchreplace_classpath "$bundle" "$2" "$3"
|
||||
;;
|
||||
*) eerror "Commande invalide: $*";;
|
||||
esac
|
||||
fi
|
||||
first=
|
||||
done
|
||||
eend
|
||||
}
|
||||
|
||||
function wotag() {
|
||||
function __wotag_display_help() {
|
||||
uecho "woctl tag: attacher une information de version à un bundle
|
||||
|
||||
USAGE
|
||||
tag [options] <bundle>
|
||||
|
||||
OPTIONS
|
||||
-c Vérifier si des informations de versions existent dans le bundle
|
||||
spécifié.
|
||||
-s Afficher les informations de versions attachées
|
||||
-v VERSION
|
||||
Spécifier la version, ou '-' s'il n'y a pas de version
|
||||
-d DATE
|
||||
Spécifier la date de release
|
||||
-m DESC
|
||||
Spécifier une description du bundle
|
||||
|
||||
Si aucune des options -v, -d, -m n'est spécifiée, alors tenter de prendre les
|
||||
informations de version et la date de release depuis le fichier VERSION.txt
|
||||
situé dans le répertoire de resources.
|
||||
Sinon, il faut saisir manuellement les informations."
|
||||
}
|
||||
|
||||
local action newversion newdate newdesc
|
||||
local version date desc release
|
||||
local bundlename bundle found
|
||||
action=tag
|
||||
newversion=
|
||||
newdate=
|
||||
newdesc=
|
||||
bundlename=
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with __wotag_display_help' \
|
||||
-c action=check \
|
||||
-s action=show \
|
||||
-v:,--version: newversion= \
|
||||
-d:,--date: newdate= \
|
||||
-m:,--desc: newdesc= \
|
||||
--message: bundlename= \
|
||||
@ args -- "$@" &&
|
||||
set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
bundle="$1"
|
||||
[ -n "$bundle" ] || {
|
||||
eerror "Il faut spécifier le bundle à tagger"
|
||||
return 1
|
||||
}
|
||||
if [ ! -d "$bundle" ]; then
|
||||
if [ "$action" == "check" ]; then
|
||||
return 1
|
||||
elif [ "$action" == "show" ]; then
|
||||
[ -z "$bundlename" ] && bundlename="$(basename "$bundle")"
|
||||
eecho "$bundlename: not found"
|
||||
return 0
|
||||
else
|
||||
eerror "Bundle non trouvé: $bundle"
|
||||
return 1
|
||||
fi
|
||||
elif is_wobundle "$bundle" && is_woappdir "$bundle"; then
|
||||
:
|
||||
elif is_wobundle "$bundle" && is_wofwkdir "$bundle"; then
|
||||
:
|
||||
else
|
||||
eerror "N'est pas un bundle valide: $bundle"
|
||||
return 1
|
||||
fi
|
||||
bundle="$(abspath "$bundle")"
|
||||
[ -z "$bundlename" ] && bundlename="$(basename "$bundle")"
|
||||
|
||||
local infofile="$(get_infofile "$bundle")"
|
||||
local jawotoolsfile="$(get_jawotoolsfile "$bundle")"
|
||||
local jawotoolsfile2="$bundle/jawotools.properties"
|
||||
local versionfile="$(get_versionfile "$bundle")"
|
||||
|
||||
if [ "$action" == "check" ]; then
|
||||
[ -f "$jawotoolsfile" ] || return 1
|
||||
read_jawotoolsfile "$jawotoolsfile" version date
|
||||
[ -n "$version" -o -n "$date" ] && return 0
|
||||
return 1
|
||||
|
||||
elif [ "$action" == "show" ]; then
|
||||
found=
|
||||
if [ -f "$jawotoolsfile" ]; then
|
||||
read_jawotoolsfile "$jawotoolsfile" version date desc
|
||||
if [ -n "$version" -o -n "$date" ]; then
|
||||
eecho "$bundlename: Version${version:+ "$version"}${date:+ du "$date"}${desc:+
|
||||
("$desc")}"
|
||||
found=1
|
||||
fi
|
||||
elif [ -f "$infofile" ]; then
|
||||
read_infofile "$infofile" version release
|
||||
if [ -n "$version" ]; then
|
||||
eecho "$bundlename: Version $version${release:+ ("$release")}"
|
||||
found=1
|
||||
elif [ -n "$release" ]; then
|
||||
eecho "$bundlename: Release $release"
|
||||
found=1
|
||||
fi
|
||||
fi
|
||||
[ -n "$found" ] || eecho "$bundlename: no version found"
|
||||
|
||||
elif [ "$action" == "tag" ]; then
|
||||
# lire les valeurs actuelles
|
||||
if [ -f "$jawotoolsfile" ]; then
|
||||
read_jawotoolsfile "$jawotoolsfile" version date desc
|
||||
fi
|
||||
|
||||
# si le fichier de version existe, lire la version et la date de release
|
||||
if [ -z "$newversion" -a -z "$newdate" -a -f "$versionfile" ]; then
|
||||
newversion="$(awk <"$versionfile" '{
|
||||
gsub("-r../../....$", "")
|
||||
print
|
||||
exit
|
||||
}')"
|
||||
newdate="$(awk <"$versionfile" '{
|
||||
if ($0 ~ /.*-r..\/..\/....$/) {
|
||||
gsub(".*-r", "")
|
||||
print
|
||||
}
|
||||
exit
|
||||
}')"
|
||||
fi
|
||||
# si le fichier Info.plist existe, y lire les informations de version
|
||||
if [ -z "$newversion" -a -z "$newdate" -a -f "$infofile" ]; then
|
||||
read_infofile "$infofile" newversion release
|
||||
[ -n "$newversion" ] || newversion="$release"
|
||||
fi
|
||||
|
||||
# nous n'avons pas trouvé de version, il faut saisir les valeurs à la main
|
||||
if [ -z "$newversion" -o -z "$newdate" ]; then
|
||||
[ "$newversion" == "-" ] && newversion=
|
||||
[ "$newdate" == "-" ] && newdate=
|
||||
|
||||
defversion="${newversion:-$version}"
|
||||
read_value "Entrez la version (vide s'il n'y a que la date de release)" newversion "$defversion" N
|
||||
defdate="${newdate:-${date:-$(date +"%d/%m/%Y")}}"
|
||||
read_value "Entrez la date de release" newdate "$defdate"
|
||||
defdesc="${newdesc:-$desc}"
|
||||
read_value -i "Entrez une description du bundle" newdesc "$defdesc" N
|
||||
fi
|
||||
[ "$newversion" == "-" ] && newversion=
|
||||
[ "$newdate" == "-" ] && newdate=
|
||||
|
||||
[ -n "$newversion" -o -n "$newdate" ] || {
|
||||
eerror "Il faut spécifier le numéro de version et/ou la date de release"
|
||||
return 1
|
||||
}
|
||||
|
||||
eecho "$bundlename: Version${newversion:+ "$newversion"}${newdate:+ du "$newdate"}${newdesc:+
|
||||
("$newdesc")}"
|
||||
if [ "$newversion" != "$version" -o "$newdate" != "$date" -o "$newdesc" != "$desc" ]; then
|
||||
[ "$jawotoolsfile" == "$jawotoolsfile2" ] || rm -f "$jawotoolsfile"
|
||||
save_jawotoolsfile "$jawotoolsfile2" "$newversion" "$newdate" "$newdesc"
|
||||
write_infofile "$infofile" "$newversion" "$(date2version "$newdate")"
|
||||
else
|
||||
einfo "Aucune modification effectuée"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
WOINST_TMPDIR_SET=
|
||||
function __woinst_set_tmpdir_maybe() {
|
||||
if [ -z "$WOINST_TMPDIR_SET" ]; then
|
||||
ac_set_tmpdir tmpdir
|
||||
WOINST_TMPDIR_SET=1
|
||||
fi
|
||||
}
|
||||
|
||||
function __woinst_expand_archive() {
|
||||
local archdir contents
|
||||
__woinst_set_tmpdir_maybe
|
||||
|
||||
estep "Décompactage de $(ppath "$src") dans $tmpdir..."
|
||||
archdir="$tmpdir/$(get_archive_appname "$src")"
|
||||
mkdir -p "$archdir"
|
||||
extract_archive "$src" "$archdir" || return 1
|
||||
|
||||
# s'il n'y a qu'un répertoire dans l'archive, le considérer comme le
|
||||
# répertoire à déployer.
|
||||
array_from_lines contents "$(list_all "$archdir")"
|
||||
if [ "${#contents[*]}" -eq 1 -a -d "$archdir/$contents" ]; then
|
||||
archdir="$archdir/$contents"
|
||||
fi
|
||||
|
||||
src="$archdir"
|
||||
}
|
||||
|
||||
function woinst() {
|
||||
function __woinst_display_help() {
|
||||
uecho "$scriptname: Déployer un bundle (application ou framework) de WebObjects
|
||||
|
||||
USAGE
|
||||
$scriptname [options] <file|archive|dir>...
|
||||
|
||||
OPTIONS
|
||||
PREFIX=value
|
||||
Spécifier une valeur pour un préfixe, plutôt que de laisser uprefix
|
||||
l'autodétecter. Utiliser uprefix -l pour une liste de préfixes valides.
|
||||
-b Redémarrer les instances en mode bounce.
|
||||
Par défaut, les instances sont arrêtées avant le déploiement, et
|
||||
redémarrées après
|
||||
-W Ne déployer que les resources web. Implique -n
|
||||
-n Ne pas tagger les bundles déployés avec un numéro de version. Par
|
||||
défaut, l'utilisateur est invité à compléter des informations telles
|
||||
que n° de version et date de release si ces informations ne sont pas
|
||||
disponible.
|
||||
-x CMD
|
||||
Exécuter la commande CMD après avoir effectué le déploiement"
|
||||
}
|
||||
|
||||
local bounce webinst notag scripts istmpdir tmpdir
|
||||
scripts=()
|
||||
parse_opts "${PRETTYOPTS[@]}" \
|
||||
--help '$exit_with __woinst_display_help' \
|
||||
-b,--bounce bounce=1 \
|
||||
-W,--webres webinst=1 \
|
||||
-n,--notag notag=1 \
|
||||
-x:,--exec: scripts \
|
||||
--is-tmpdir '$istmpdir=1; tmpdir=.' \
|
||||
@ args -- "$@" &&
|
||||
set -- "${args[@]}" || {
|
||||
eerror "$args"
|
||||
return 1
|
||||
}
|
||||
|
||||
# Tout d'abord énumérer les frameworks et applications à installer
|
||||
# Lire aussi les définitions de variables
|
||||
compute_apache_prefixes
|
||||
compute_webobjects_prefixes
|
||||
|
||||
etitle "Calcul de la liste des bundles à déployer"
|
||||
|
||||
if [ -z "$istmpdir" ]; then
|
||||
__woinst_set_tmpdir_maybe
|
||||
estep "La copie de travail sera faite dans $(ppath "$tmpdir")..."
|
||||
fi
|
||||
|
||||
local -a variables frameworks applications
|
||||
local src name value valid copied
|
||||
variables=()
|
||||
frameworks=()
|
||||
applications=()
|
||||
for src in "${@:-.}"; do
|
||||
if [[ "$src" == *=* ]]; then
|
||||
splitvar "$src" name value
|
||||
array_add variables "$name"
|
||||
set_var "$name" "$value"
|
||||
else
|
||||
src="$(abspath "$src")"
|
||||
valid=
|
||||
copied=
|
||||
|
||||
if [ -f "$src" ] && is_archive "$src"; then
|
||||
__woinst_expand_archive || return 1
|
||||
copied=1
|
||||
fi
|
||||
if [ -d "$src" ]; then
|
||||
if endswith "$src" .framework; then
|
||||
is_wofwkdir "$src" || {
|
||||
eerror "Framework invalide: $(ppath "$src")"
|
||||
return 1
|
||||
}
|
||||
valid=1
|
||||
elif endswith "$src" .woa; then
|
||||
is_woappdir "$src" || {
|
||||
eerror "Application invalide: $(ppath "$src")"
|
||||
return 1
|
||||
}
|
||||
valid=1
|
||||
fi
|
||||
fi
|
||||
[ -n "$valid" ] || {
|
||||
eerror "N'est pas un bundle valide: $(ppath "$src")"
|
||||
return 1
|
||||
}
|
||||
srcname="$(basename "$src")"
|
||||
|
||||
if [ -z "$copied" -a -z "$istmpdir" ]; then
|
||||
estep "$(ppath "$src")"
|
||||
cpnovcs "$src" "$tmpdir"
|
||||
src="$tmpdir/$srcname"
|
||||
fi
|
||||
|
||||
if endswith "$src" .framework; then
|
||||
array_add frameworks "$src"
|
||||
elif endswith "$src" .woa; then
|
||||
array_add applications "$src"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
eend
|
||||
|
||||
# Tagger les bundles
|
||||
if [ -z "$webinst" -a -z "$notag" ]; then
|
||||
etitle "Tagger les bundles"
|
||||
for src in "${frameworks[@]}"; do
|
||||
srcname="$(basename "$src")"
|
||||
etitle "$srcname"
|
||||
wotag --message "Version installée" -s "$WOFRAMEWORKS/$srcname"
|
||||
wotag --message "Version à installer" "$src"
|
||||
eend
|
||||
done
|
||||
for src in "${applications[@]}"; do
|
||||
srcname="$(basename "$src")"
|
||||
etitle "$srcname"
|
||||
wotag --message "Version installée" -s "$WOAPPLICATIONS/$srcname"
|
||||
wotag --message "Version à installer" "$src"
|
||||
eend
|
||||
done
|
||||
eend
|
||||
fi
|
||||
|
||||
# Confirmer le déploiement
|
||||
etitle "Résumé"
|
||||
function __woinst_strip_woa() { basename "$1" .woa; }
|
||||
function __woinst_strip_fwk() { basename "$1" .framework; }
|
||||
estepn "Déploiement ${applications:+des applications: $(array_mapjoin applications __woinst_strip_woa " ")${frameworks:+
|
||||
et }}${frameworks:+des frameworks: $(array_mapjoin frameworks __woinst_strip_fwk " ")}
|
||||
dans NEXT_ROOT = ${NEXT_ROOT:-/}
|
||||
HTDOCS_DIR = ${HTDOCSDIR}"
|
||||
|
||||
if ! ask_yesno -c "Voulez-vous lancer le déploiement?" O; then
|
||||
eend
|
||||
return 1
|
||||
fi
|
||||
eend
|
||||
|
||||
# Faire le déploiement
|
||||
local configfile variable
|
||||
ac_set_tmpfile configfile
|
||||
for variable in "${variables[@]}" bounce webinst ULIBDIR __estack __tlevel; do
|
||||
set_var_cmd "$variable" "${!variable}" >>"$configfile"
|
||||
done
|
||||
for array in variables scripts applications frameworks; do
|
||||
set_array_cmd "$array" >>"$configfile"
|
||||
done
|
||||
# pour les serveurs qui ont une vieille version de bash, forcer la valeur de
|
||||
# ULIBDIR
|
||||
set_var_cmd "FORCED_ULIBDIR" "$ULIBDIR" >>"$configfile"
|
||||
|
||||
runscript_as_root "$ULIBDIR/support/woinst2s" "$configfile"
|
||||
|
||||
ac_clean "$tmpdir" "$configfile"
|
||||
}
|
||||
@@ -1,734 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Pilotage du moniteur de ProjectWonder
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
##@require webobjects
|
||||
uprovide wondermonitor
|
||||
urequire base sysinfos webobjects
|
||||
|
||||
WOM_DEFAULT_HOST=localhost
|
||||
WOM_DEFAULT_PORT="${JAVAMONITOR_PORT:-56789}"
|
||||
WOM_DEFAULT_PASSWORD="$JAVAMONITOR_PASSWORD"
|
||||
|
||||
function __get_womurl() {
|
||||
# $1 est un nom d'hôte de la forme host[:port]
|
||||
# Le transfomer en url pour attaquer le moniteur:
|
||||
# http://host:port/cgi-bin/WebObjects/JavaMonitor.woa/$2[?pw=$3[&$4...]]
|
||||
# $2 est l'url relative à attaquer. Si $3 est spécifié, c'est le mot de
|
||||
# passe pour l'accès au moniteur. Si $4...* sont spécifiés, ce sont d'autres
|
||||
# paramètres.
|
||||
local host port password paramsep="?"
|
||||
if [ -n "$1" ]; then
|
||||
splitpair "$1" host port
|
||||
[ -n "$host" ] || host="$WOM_DEFAULT_HOST"
|
||||
[ -n "$port" ] || port="$WOM_DEFAULT_PORT"
|
||||
shift
|
||||
# si on spécifie explicitement l'hôte, considérer que le mot de passe
|
||||
# est explicitement spécifié aussi, et ne pas prendre la valeur par
|
||||
# défaut.
|
||||
password="$2"
|
||||
else
|
||||
host="$WOM_DEFAULT_HOST"
|
||||
port="$WOM_DEFAULT_PORT"
|
||||
shift
|
||||
password="${2:-$WOM_DEFAULT_PASSWORD}"
|
||||
fi
|
||||
|
||||
local womurl="http://$host:$port/cgi-bin/WebObjects/JavaMonitor.woa"
|
||||
if [ -n "$1" ]; then
|
||||
[ "${1#/}" == "$1" ] && womurl="$womurl/"
|
||||
womurl="$womurl$1"
|
||||
fi; shift
|
||||
if [ -n "$password" ]; then
|
||||
womurl="$womurl${paramsep}pw=$password"
|
||||
paramsep="&"
|
||||
fi; shift
|
||||
while [ -n "$1" ]; do
|
||||
womurl="$womurl${paramsep}$1"; shift
|
||||
paramsep="&"
|
||||
done
|
||||
echo "$womurl"
|
||||
}
|
||||
|
||||
function __check_type() {
|
||||
# vérifier que le type $1 (calculé par splitins()) est l'une des valeurs
|
||||
# $2..*
|
||||
local actual="$1" expected; shift
|
||||
for expected in "$@"; do
|
||||
[ "$actual" == "$expected" ] && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
function __json_filter() {
|
||||
# traiter un flux json pour que chaque valeur soit sur une ligne séparée,
|
||||
# facilitant le traitement par un script bash
|
||||
awk '{
|
||||
gsub(/}\][ ]*$/, "\n&")
|
||||
gsub(/},[ ]*$/, "\n&")
|
||||
gsub(/[][{]/, "&\n")
|
||||
gsub(/,[ ]*"/, ",\n\"")
|
||||
#gsub(/"}/, "\",\n}")
|
||||
print
|
||||
}'
|
||||
}
|
||||
|
||||
function wom__statistics() {
|
||||
# Afficher les statistiques pour le serveur $1, avec éventuellement le mot
|
||||
# de passe $2
|
||||
wogeturl "$(__get_womurl "$1" wa/statistics "$2")" || return
|
||||
}
|
||||
|
||||
function wom__info() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et afficher des informations sur l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/info "$3" type="$type" ${name:+name=$name})" || return
|
||||
}
|
||||
|
||||
function wom__info_filter() {
|
||||
# filtrer le résultat de wom__info en ne gardant que les tags
|
||||
# name, state, activeSessions, autoRecover, deaths, host, port
|
||||
awkrun -f '
|
||||
function get_value(line) {
|
||||
match(line, /^[^"]*"[^"]*":[ ]*"?/); line = substr(line, RSTART + RLENGTH)
|
||||
match(line, /"?[ ]*,?[ ]*$/); line = substr(line, 1, RSTART - 1)
|
||||
return line
|
||||
}
|
||||
function reset_values() {
|
||||
name = ""; state = "";
|
||||
activeSessions = ""; autoRecover = ""; deaths = ""
|
||||
host = ""; port = ""
|
||||
}
|
||||
function dump_values() {
|
||||
if (name != "") {
|
||||
print quote_value(name) " " quote_value(state) " " quote_value(activeSessions) " " quote_value(autoRecover) " " quote_value(deaths) " " quote_value(host) " " quote_value(port)
|
||||
}
|
||||
reset_values()
|
||||
}
|
||||
BEGIN {
|
||||
inapp = 0
|
||||
reset_values()
|
||||
}
|
||||
/{/ { inapp = 1 }
|
||||
/}/ { dump_values(); inapp = 0 }
|
||||
inapp && $0 ~ /"name"/ { name = get_value($0) }
|
||||
inapp && $0 ~ /"state"/ { state = get_value($0) }
|
||||
inapp && $0 ~ /"activeSessions"/ { activeSessions = get_value($0) }
|
||||
inapp && $0 ~ /"autoRecover"/ { autoRecover = get_value($0) }
|
||||
inapp && $0 ~ /"deaths"/ { deaths = get_value($0) }
|
||||
inapp && $0 ~ /"host"/ { host = get_value($0) }
|
||||
inapp && $0 ~ /"port"/ { port = get_value($0) }
|
||||
'
|
||||
}
|
||||
|
||||
function wom_info() {
|
||||
# Contacter le moniteur sur l'hôte $3, avec éventuellement le mot de passe
|
||||
# $4, et initialiser le tableau $1 avec une liste de valeurs quotés de la
|
||||
# forme:
|
||||
# "'name' 'state' 'activeSessions' 'autoRecover' 'deaths' 'host' 'port'"
|
||||
# concernant l'application $2 (par défaut, toutes les applications). Notez
|
||||
# qu'il y a une ligne par instance d'application
|
||||
# Ces valeurs peuvent être utilisées comme arguments d'une fonction. par
|
||||
# exemple:
|
||||
# wom_info appinfos "" host pw
|
||||
# for args in "${appinfos[@]}"; do
|
||||
# eval "userfunc $args"
|
||||
# done
|
||||
wom__info "$2" "$3" "$4" || return
|
||||
array_from_lines "$1" "$(<"$WORAURL_DATA" __json_filter | wom__info_filter)"
|
||||
}
|
||||
|
||||
function wom_getValidAndRunning() {
|
||||
# Placer la liste des applications valides dans le tableau $1(=valid_apps)
|
||||
# et la liste des applications qui tournent dans le tableau
|
||||
# $2=(running_apps), en contactant le moniteur sur l'hôte $3, avec
|
||||
# éventuellement le mot de passe $4.
|
||||
local -a __vr_appinfos __vr_valids="${1:-valid_apps}" __vr_runnings="${2:-running_apps}"
|
||||
local __vr_appinfo
|
||||
wom_info __vr_appinfos "$3" "$4" || return
|
||||
array_new "$__vr_valids"
|
||||
array_new "$__vr_runnings"
|
||||
for __vr_appinfo in "${__vr_appinfos[@]}"; do
|
||||
eval "__vr_appinfo=($__vr_appinfo)"
|
||||
array_addu "$__vr_valids" "${__vr_appinfo[0]}"
|
||||
if [ "${__vr_appinfo[1]}" == "ALIVE" ]; then
|
||||
array_addu "$__vr_runnings" "${__vr_appinfo[0]}"
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
function show_appinfo() {
|
||||
# Afficher des informations sur une application. Les arguments doivent être
|
||||
# le résultat de la fonction wom_info()
|
||||
local name="$1" state="$2"
|
||||
local activeSessions="$3" autoRecover="$4" deaths="$5"
|
||||
local host="$6" port="$7"
|
||||
local color suffix
|
||||
case "$state" in
|
||||
ALIVE)
|
||||
color="$COULEUR_VERTE"
|
||||
suffix="NbSessions: "
|
||||
[ "${activeSessions:-0}" -gt 0 ] && suffix="$suffix$COULEUR_BLEUE"
|
||||
suffix="$suffix$activeSessions$COULEUR_NORMALE, deaths="
|
||||
[ "${deaths:-0}" -gt 0 ] && suffix="$suffix$COULEUR_ROUGE"
|
||||
suffix="$suffix$deaths$COULEUR_NORMALE"
|
||||
;;
|
||||
DEAD) color="";;
|
||||
STARTING|STOPPING) color="$COULEUR_BLEUE";;
|
||||
*) color="$COULEUR_JAUNE";;
|
||||
esac
|
||||
eecho "$color$name$COULEUR_NORMALE ($state)${suffix:+: $suffix}"
|
||||
}
|
||||
|
||||
function wom_running() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et tester si l'application $1 (par défaut, all) tourne actuellement
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/running "$3" type="$type" ${name:+name=$name})" || return
|
||||
is_yes "$(<"$WORAURL_DATA")"
|
||||
}
|
||||
|
||||
function wom_start() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et démarrer l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/start "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_stopped() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et tester si l'application $1 (par défaut, all) est actuellement arrêtée
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/stopped "$3" type="$type" ${name:+name=$name})" || return
|
||||
is_yes "$(<"$WORAURL_DATA")"
|
||||
}
|
||||
|
||||
function wom_stop() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et arrêter l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/stop "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_forceQuit() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et forcer l'arrêt de l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/forceQuit "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_turnScheduledOn() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et activer le flag scheduled sur l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/turnScheduledOn "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_turnScheduledOff() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et désactiver le flag scheduled sur l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/turnScheduledOff "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_turnRefuseNewSessionOn() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et activer le flag refuseNewSession sur l'application $1 (par défaut,
|
||||
# all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/turnRefuseNewSessionOn "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_turnRefuseNewSessionOff() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et désactiver le flag refuseNewSession sur l'application $1 (par
|
||||
# défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/turnRefuseNewSessionOff "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_turnAutoRecoverOn() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et activer le flag autoRecover sur l'application $1 (par défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/turnAutoRecoverOn "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_turnAutoRecoverOff() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et désactiver le flag autoRecover sur l'application $1 (par défaut,
|
||||
# all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" all app ins || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/turnAutoRecoverOff "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_bounce() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et redémarrer l'application $1 (par défaut, all) en mode bounce
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" app all || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/bounce "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom_clearDeaths() {
|
||||
# Contacter le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3, et effacer le compte des morts suspectes pour l'application $1 (par
|
||||
# défaut, all)
|
||||
local type name
|
||||
splitins "$1" type name
|
||||
__check_type "$type" app all || return 2
|
||||
wogeturl "$(__get_womurl "$2" admin/clearDeaths "$3" type="$type" ${name:+name=$name})" || return
|
||||
[ "$(<"$WORAURL_DATA")" == "OK" ]
|
||||
}
|
||||
|
||||
function wom__getApplications() {
|
||||
# Obtenir des information sur la définition de l'application $1 (ou de
|
||||
# toutes les applications si $1=="") en contactant le moniteur sur l'hôte $2
|
||||
# avec éventuellement le mot de passe $3. Le résultat est un flux xml,
|
||||
# chaque application étant défini dans un tag <MApplications>. Si un erreur
|
||||
# se produit, l'erreur est dans un tag <Strings>
|
||||
woraurl GET "$(__get_womurl "$2" "ra/mApplications${1:+/$1}" "$3")" || return
|
||||
}
|
||||
|
||||
function wom__getApplications_filter() {
|
||||
# filtrer le résultat de wom__getApplications en ne gardant que les tags
|
||||
# name, unixPath, macPath, winPath
|
||||
awkrun -f '
|
||||
function get_value(line) {
|
||||
if (line ~ / nil="true"/) return ""
|
||||
match(line, /^[^<]*<[^<>]*>/); line = substr(line, RSTART + RLENGTH)
|
||||
match(line, /<.*$/); line = substr(line, 1, RSTART - 1)
|
||||
return line
|
||||
}
|
||||
function get_attr_value(attr, line) {
|
||||
match(line, attr "=\""); line = substr(line, RSTART + RLENGTH)
|
||||
match(line, /".*$/); line = substr(line, 1, RSTART - 1)
|
||||
return line
|
||||
}
|
||||
function reset_values() {
|
||||
name = ""
|
||||
unixPath = ""
|
||||
macPath = ""
|
||||
winPath = ""
|
||||
}
|
||||
function dump_values() {
|
||||
if (name != "") {
|
||||
print quote_value(name) " " quote_value(unixPath) " " quote_value(macPath) " " quote_value(winPath)
|
||||
}
|
||||
reset_values()
|
||||
}
|
||||
BEGIN {
|
||||
inapp = 0
|
||||
reset_values()
|
||||
}
|
||||
/<MApplications/ { inapp = 1 }
|
||||
/<\/MApplications/ { dump_values(); inapp = 0 }
|
||||
inapp && $0 ~ /<name[> ]/ { name = get_value($0) }
|
||||
inapp && $0 ~ /<unixPath[> ]/ { unixPath = get_value($0) }
|
||||
inapp && $0 ~ /<macPath[> ]/ { macPath = get_value($0) }
|
||||
inapp && $0 ~ /<winPath[> ]/ { winPath = get_value($0) }
|
||||
'
|
||||
}
|
||||
|
||||
function wom_getApplications() {
|
||||
# Obtenir la liste des applications définies en contactant le moniteur sur
|
||||
# l'hôte $3 avec éventuellement le mot de passe $4, et initialiser le
|
||||
# tableau $1 avec une liste de valeurs quotées de la forme:
|
||||
# "'name' 'unixPath' 'macPath' 'winPath'"
|
||||
# concernant l'application $2 (par défaut, toutes les applications)
|
||||
# Ces valeurs peuvent être utilisées comme arguments d'une fonction. par
|
||||
# exemple:
|
||||
# wom_getApplications appinfos "" host pw
|
||||
# for args in "${appinfos[@]}"; do
|
||||
# eval "userfunc $args"
|
||||
# done
|
||||
array_new "$1"
|
||||
wom__getApplications "$2" "$3" "$4" || return
|
||||
array_from_lines "$1" "$(<"$WORAURL_DATA" wom__getApplications_filter)"
|
||||
}
|
||||
|
||||
function wom_addApplication() {
|
||||
# Ajouter une application nommée $1 en contactant le moniteur sur l'hôte $2,
|
||||
# avec éventuellement le mot de passe $3.
|
||||
# Soit le nom Name, par défaut l'exécutable se trouve dans
|
||||
# WOAPPLICATIONS/Name.woa/Name et les logs dans /var/log/WebObjects, et le
|
||||
# flag autoRecover est activé
|
||||
# XXX supporter la possibilité de modifier les valeurs par défaut
|
||||
local name="$1" unixPath macPath unixOutputPath macOutputPath
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
unixPath=
|
||||
unixOutputPath=
|
||||
macPath="$WOAPPLICATIONS/$name.woa/$name"
|
||||
macOutputPath="$WOLOGS"
|
||||
else
|
||||
macPath=
|
||||
macOutputPath=
|
||||
unixPath="$WOAPPLICATIONS/$name.woa/$name"
|
||||
unixOutputPath="$WOLOGS"
|
||||
fi
|
||||
|
||||
local data="{id: '$name', type: 'MApplication', name: '$name', unixOutputPath: '$unixOutputPath', unixPath: '$unixPath', macOutputPath: '$macOutputPath', macPath: '$macPath', autoRecover: false}"
|
||||
woraurl POST "$(__get_womurl "$2" ra/mApplications.json "$3")" "$data"
|
||||
}
|
||||
|
||||
function wom_addInstance() {
|
||||
# Ajouter une instance sur localhost pour l'application nommée $1 en
|
||||
# contactant le moniteur sur l'hôte $2, avec éventuellement le mot de passe
|
||||
# $3.
|
||||
# XXX supporter la possibilité de modifier les valeurs par défaut
|
||||
woraurl GET "$(__get_womurl "$2" "ra/mApplications/$1/addInstance" "$3" host=localhost)"
|
||||
# cette requête plante pour je ne sais quelle raison: (faire des investigations!)
|
||||
#woraurl GET "$(__get_womurl "$2" "ra/mApplications/$1/addInstanceOnAllHosts" "$3")"
|
||||
}
|
||||
|
||||
function check_compute_apps_localhost() {
|
||||
# si les arguments de compute_apps contiennent des bundles de framework, il
|
||||
# faut avoir accès au système de fichier local. vérifier si l'un des
|
||||
# arguments $2..* est un framework. si c'est le cas, vérifier que l'hôte $1
|
||||
# est localhost.
|
||||
# retourner 0 si c'est ok, 1 s'il y a des frameworks et que host n'est pas
|
||||
# localhost
|
||||
local host="$1"; shift
|
||||
local spec type name
|
||||
for spec in "$@"; do
|
||||
splitins "$spec" type name
|
||||
if [ "$type" == "fwk" ]; then
|
||||
if [ -z "$host" -o "$host" == "localhost" -o "$host" == "127.0.0.1" ]; then
|
||||
return 0
|
||||
else
|
||||
eerror "Spécifier des bundles de framework n'est supporté que sur l'hôte local"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
done
|
||||
return 0
|
||||
}
|
||||
|
||||
function compute_apps() {
|
||||
# Remplir le tableau $1(=apps) avec la liste des applications correspondant
|
||||
# aux arguments $3...*
|
||||
# Un bundle de framework (Name.framework) est remplacé par la liste des
|
||||
# bundles d'applications qui dépendent de ce framework. Cette information
|
||||
# est obtenue en consultant le système de fichier local.
|
||||
# Un bundle d'application est remplacé par la liste des applications qui
|
||||
# sont définies pour ce bundle. Cette information est obtenue en consultant
|
||||
# le tableau généré par wom_getApplications(), dont le nom est $2
|
||||
# Les arguments de la forme @N sont ignorés, ils correspondent à des délais
|
||||
# à respecter lors du démarrage de l'application
|
||||
local -a __ca_specs
|
||||
local __ca_notempty
|
||||
local __ca_spec __ca_type __ca_name __ca_fapps __ca_appinfo __ca_path __ca_found
|
||||
__ca_fapps=()
|
||||
local __ca_apps="${1:-apps}"; shift
|
||||
local __ca_appinfos="$1"; shift
|
||||
if [ -z "$__ca_appinfos" ]; then
|
||||
# si on ne donne pas le tableau de wom_getApplications, le calculer nous
|
||||
# même
|
||||
wom_getApplications __ca_appinfos
|
||||
else
|
||||
array_copy __ca_appinfos "$__ca_appinfos"
|
||||
fi
|
||||
array_new "$__ca_apps"
|
||||
[ -n "$*" ] && __ca_notempty=1
|
||||
__ca_specs=("$@")
|
||||
while [ -n "${__ca_specs[*]}" ]; do
|
||||
set -- "${__ca_specs[@]}"
|
||||
# si un framework est spécifié, il faut rajouter d'autres bundles
|
||||
# d'applications. il sont insérés dans __ca_specs
|
||||
__ca_specs=()
|
||||
for __ca_spec in "$@"; do
|
||||
if [[ "$__ca_spec" == @* ]]; then
|
||||
array_add "$__ca_apps" "$__ca_spec"
|
||||
continue
|
||||
fi
|
||||
|
||||
splitins "$__ca_spec" __ca_type __ca_name
|
||||
if [ "$__ca_type" == "fwk" ]; then
|
||||
compute_fapps __ca_fapps "$__ca_name"
|
||||
if [ -n "${__ca_fapps[*]}" ]; then
|
||||
estep "$__ca_name --> ${__ca_fapps[*]}"
|
||||
for __ca_spec in "${__ca_fapps[@]}"; do
|
||||
# rajouter l'application dans __ca_specs, pour traitement
|
||||
array_addu __ca_specs "$__ca_spec"
|
||||
done
|
||||
else
|
||||
ewarn "$__ca_name: Aucune correspondance n'a été trouvée"
|
||||
fi
|
||||
elif [ "$__ca_type" == "woa" ]; then
|
||||
__ca_found=
|
||||
for __ca_appinfo in "${__ca_appinfos[@]}"; do
|
||||
eval "__ca_appinfo=($__ca_appinfo)"
|
||||
if [ "$UNAME_SYSTEM" == "Darwin" ]; then
|
||||
__ca_path="${__ca_appinfo[2]}"
|
||||
else
|
||||
__ca_path="${__ca_appinfo[1]}"
|
||||
fi
|
||||
if [[ "$__ca_path" == */"$__ca_name/${__ca_name%.woa}" ]]; then
|
||||
# trouvé
|
||||
estep "$__ca_name --> ${__ca_appinfo[0]}"
|
||||
array_addu "$__ca_apps" "${__ca_appinfo[0]}"
|
||||
__ca_found=1
|
||||
# note: ne pas s'arrêter ici. il peut y avoir d'autres
|
||||
# instances pour cette application
|
||||
fi
|
||||
done
|
||||
[ -n "$__ca_found" ] || ewarn "$__ca_name: Aucune correspondance n'a été trouvée"
|
||||
else
|
||||
array_addu "$__ca_apps" "$__ca_name"
|
||||
fi
|
||||
done
|
||||
done
|
||||
if array_isempty "$__ca_apps" && [ -n "$__ca_notempty" ]; then
|
||||
# on a donné une liste non vide, mais on se retrouve avec une liste vide
|
||||
return 1
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
function get_error_msg() {
|
||||
local status="$1"; shift
|
||||
local reason
|
||||
[ -f "$WORAURL_DATA" ] && reason=". Le message d'erreur est:
|
||||
$(<"$WORAURL_DATA")"
|
||||
case "$status" in
|
||||
0) :;;
|
||||
1) echo "Une erreur s'est produite$reason";;
|
||||
2) echo "Erreur de syntaxe$reason";;
|
||||
3) echo "Impossible de contacter le serveur$reason";;
|
||||
*) echo "Impossible ${reason:-"de faire l'opération"}";; #' bug colorisation
|
||||
esac
|
||||
}
|
||||
|
||||
function __do_wait() {
|
||||
if [[ "$1" == @* ]]; then
|
||||
local n="${1#@}"
|
||||
estepn "Attente de $n secondes..."
|
||||
sleep "$n"
|
||||
return 0
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
function __ignore_wait() {
|
||||
if [[ "$1" == @* ]]; then
|
||||
estepw "$1: temps d'attente ignoré"
|
||||
return 0
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
function start_apps() {
|
||||
# Démarrer les applications $3..$* en contactant le moniteur sur l'hôte $1
|
||||
# avec le mot de passe éventuel $2
|
||||
# Les variables globales enable_autorecover et force_enable_autorecover
|
||||
# permettent respectivement d'activer l'autoRecover après le démarrage de
|
||||
# l'application et de forcer l'activation de l'autoRecover même si
|
||||
# l'instance tournait déjà.
|
||||
# Un argument de la forme @N provoque une attente de N secondes. Ceci permet
|
||||
# de placer un temps d'attente entre le démarrage de certaines applications.
|
||||
[ -n "$*" ] || return 0
|
||||
|
||||
local app error turnArOn
|
||||
local host="$1" password="$2"; shift; shift
|
||||
etitle "Démarrage des applications"
|
||||
for app in "$@"; do
|
||||
__do_wait "$app" && continue
|
||||
|
||||
ebegin "$app"
|
||||
error=
|
||||
turnArOn=
|
||||
if wom_running "$app" "$host" "$password"; then
|
||||
edotw 0 "Application déjà démarrée"
|
||||
elif wom_start "$app" "$host" "$password"; then
|
||||
turnArOn=1
|
||||
edot 0 "Démarrage"
|
||||
else
|
||||
error=$?
|
||||
edot 1 "$(get_error_msg "$error" "de démarrer l'application")"
|
||||
fi
|
||||
[ -z "$error" -a -n "$force_enable_autorecover" ] && turnArOn=1
|
||||
if [ -n "$turnArOn" -a -n "$enable_autorecover" ]; then
|
||||
if wom_turnAutoRecoverOn "$app" "$host" "$password"; then
|
||||
edot 0 "Activer autoRecover"
|
||||
else
|
||||
error=$?
|
||||
edot 1 "$(get_error_msg "$error" "d'activer autoRecover")"
|
||||
fi
|
||||
fi
|
||||
eend $error
|
||||
done
|
||||
eend
|
||||
return "${error:-0}"
|
||||
}
|
||||
|
||||
function stop_apps() {
|
||||
# Arrêter les applications $3..$* en contactant le moniteur sur l'hôte $1
|
||||
# avec le mot de passe éventuel $2
|
||||
# Les variables globales disable_autorecover et force_disable_autorecover
|
||||
# permettent respectivement de désactiver l'autoRecover après l'arrêt de
|
||||
# l'application et de forcer la désactivation de l'autoRecover même si
|
||||
# l'instance ne tournait pas.
|
||||
# L'option {-a ARRAY} permet de remplir ARRAY avec la liste des applications
|
||||
# qui ont été effectivement arrêtées. Cette option si elle est spécifiée
|
||||
# doit être en premier
|
||||
# Pour compatibilité avec start_apps, les arguments de la forme @N sont
|
||||
# ignorés. Il n'y a pas de temps d'attente entre les applications lors de
|
||||
# l'arrêt.
|
||||
local -a __sa_stopped
|
||||
if [ "$1" == "-a" ]; then
|
||||
__sa_stopped="$2"
|
||||
shift; shift
|
||||
fi
|
||||
|
||||
[ -n "$*" ] || return 0
|
||||
|
||||
local __sa_app __sa_error __sa_turnArOff
|
||||
local __sa_tried_stop_once __sa_could_not_stop
|
||||
local __sa_host="$1" __sa_password="$2"; shift; shift
|
||||
etitle "Arrêt des applications"
|
||||
for __sa_app in "$@"; do
|
||||
__ignore_wait "$__sa_app" && continue
|
||||
|
||||
ebegin "$__sa_app"
|
||||
__sa_error=
|
||||
__sa_should_stop=1
|
||||
__sa_turnArOff=
|
||||
|
||||
if wom_stopped "$__sa_app" "$__sa_host" "$__sa_password"; then
|
||||
edotw 0 "Application déjà arrêtée"
|
||||
[ -n "$force_disable_autorecover" ] && __sa_turnArOff=1
|
||||
__sa_should_stop=
|
||||
else
|
||||
__sa_turnArOff=1
|
||||
fi
|
||||
if [ -n "$__sa_turnArOff" -a -n "$disable_autorecover" ]; then
|
||||
if wom_turnAutoRecoverOff "$__sa_app" "$__sa_host" "$__sa_password"; then
|
||||
edot 0 "Désactiver autoRecover"
|
||||
else
|
||||
__sa_error=$?
|
||||
edot 1 "$(get_error_msg "$__sa_error" "de désactiver autoRecover")"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ -n "$__sa_should_stop" ]; then
|
||||
if wom_stop "$__sa_app" "$__sa_host" "$__sa_password"; then
|
||||
edot 0 "Arrêt"
|
||||
[ -n "$__sa_stopped" ] && array_addu "$__sa_stopped" "$__sa_app"
|
||||
else
|
||||
__sa_error=$?
|
||||
__sa_could_not_stop=1
|
||||
edot 1 "$(get_error_msg "$__sa_error" "d'arrêter l'application")"
|
||||
fi
|
||||
__sa_tried_stop_once=1
|
||||
fi
|
||||
eend $__sa_error
|
||||
done
|
||||
|
||||
# ne faire d'attente que s'il y a eu au moins une tentative d'arrêt d'une
|
||||
# application
|
||||
[ -n "$__sa_tried_stop_once" ] || {
|
||||
eend
|
||||
return 0
|
||||
}
|
||||
|
||||
# Attendre un certain temps avant de continuer... On accord 500 ms par
|
||||
# instance, avec un minumum de 10 secondes
|
||||
local delay=$(($# / 2))
|
||||
[ "$delay" -lt 10 ] && delay=10
|
||||
ebegin "Attente de l'arrêt des instances"
|
||||
sleep $delay &
|
||||
ewait $!
|
||||
eend
|
||||
|
||||
if [ -n "$__sa_could_not_stop" ]; then
|
||||
# Nous n'avons pas réussi à arrêter l'une des applications. Il faut
|
||||
# l'arrêter sauvagement
|
||||
__sa_could_not_stop=
|
||||
for __sa_app in "$@"; do
|
||||
if ! wom_stopped "$__sa_app" "$__sa_host" "$__sa_password"; then
|
||||
ebegin "Arrêt forcé de $__sa_app"
|
||||
if wom_stop "$__sa_app" "$__sa_host" "$__sa_password"; then
|
||||
edot 0 "Arrêt forcé"
|
||||
[ -n "$__sa_stopped" ] && array_addu "$__sa_stopped" "$__sa_app"
|
||||
else
|
||||
__sa_error=$?
|
||||
__sa_could_not_stop=1
|
||||
edot 1 "$(get_error_msg "$__sa_error" "de forcer l'arrêt de l'application")"
|
||||
fi
|
||||
eend
|
||||
fi
|
||||
done
|
||||
# il faut attendre au plus 30 secondes pour l'arrêt forcé
|
||||
ebegin "Attente de l'arrêt forcé des instances"
|
||||
sleep 30 &
|
||||
ewait $!
|
||||
eend
|
||||
[ -n "$__sa_could_not_stop" ] && ewarn "Certaines instances n'ont pas pu être arrêtées"
|
||||
fi
|
||||
|
||||
eend
|
||||
return "${__sa_error:-0}"
|
||||
}
|
||||
|
||||
function bounce_apps() {
|
||||
# Redémarrer les applications $3..$* en mode bounce en contactant le
|
||||
# moniteur sur l'hôte $1 avec le mot de passe éventuel $2
|
||||
# Pour compatibilité avec start_apps, les arguments de la forme @N sont
|
||||
# ignorés. Il n'y a pas de temps d'attente entre les applications lors du
|
||||
# redémarrage.
|
||||
[ -n "$*" ] || return 0
|
||||
|
||||
local app error
|
||||
local host="$1" password="$2"; shift; shift
|
||||
etitle "Redémarrage des applications en mode bounce"
|
||||
for app in "$@"; do
|
||||
__ignore_wait "$app" && continue
|
||||
|
||||
ebegin "$app"
|
||||
error=
|
||||
if wom_bounce "$app" "$host" "$password"; then
|
||||
edot 0 "Redémarrage"
|
||||
else
|
||||
error=$?
|
||||
edot 1 "$(get_error_msg "$error" "de redémarrer l'application")"
|
||||
fi
|
||||
done
|
||||
eend
|
||||
return "${error:-0}"
|
||||
}
|
||||
195
ulib/wosign
195
ulib/wosign
@@ -1,195 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Support de la signature des jars pour WebObjects
|
||||
##@cooked nocomments
|
||||
##@require webobjects
|
||||
uprovide wosign
|
||||
urequire webobjects
|
||||
|
||||
WOSIGN_KEYSTORE=
|
||||
WOSIGN_STOREPASS=
|
||||
WOSIGN_KEYALIAS=
|
||||
|
||||
function wosign_setup_maybe() {
|
||||
WOSIGN_CONFDIR="$WOCONFIGURATION/Signatures"
|
||||
WOSIGN_CONF="$WOSIGN_CONFDIR/signature.conf"
|
||||
if [ -f "$WOSIGN_CONF" ]; then
|
||||
eval "$(
|
||||
keystore=
|
||||
storepass=
|
||||
keyalias=
|
||||
source "$WOSIGN_CONF"
|
||||
set_var_cmd WOSIGN_KEYSTORE "$keystore"
|
||||
set_var_cmd WOSIGN_STOREPASS "$storepass"
|
||||
set_var_cmd WOSIGN_KEYALIAS "$keyalias"
|
||||
)"
|
||||
|
||||
[ -n "$WOSIGN_XTMPDIR" ] || ac_set_tmpdir WOSIGN_XTMPDIR
|
||||
[ -n "$WOSIGN_JTMPDIR" ] || ac_set_tmpdir WOSIGN_JTMPDIR
|
||||
return 0
|
||||
else
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function __issjar() {
|
||||
[ "${1%.sjar}" != "$1" ]
|
||||
}
|
||||
|
||||
function __tosjar() {
|
||||
local jarname="$(basename "$1")"
|
||||
local jardir="${1%$jarname}"
|
||||
local sjarname= jarbn="$(basename "$jarname" .jar)"
|
||||
if [ "$jarbn" != "$jarname" ]; then
|
||||
sjarname="$jarbn.sjar"
|
||||
else
|
||||
sjarname="$jarname.sjar"
|
||||
fi
|
||||
echo "$jardir$sjarname"
|
||||
}
|
||||
|
||||
function __tojar() {
|
||||
local jarname="$(basename "$1")"
|
||||
local jardir="${1%$jarname}"
|
||||
local jarbn="$(basename "$jarname" .sjar)"
|
||||
[ "$jarbn" != "$jarname" ] && jarname="$jarbn.jar"
|
||||
echo "$jardir$jarname"
|
||||
}
|
||||
|
||||
function wosign_jar() {
|
||||
local default=1 sign= unsign=
|
||||
while [ -n "$1" ]; do
|
||||
case "$1" in
|
||||
-s) default=; sign=1;;
|
||||
-d) default=; unsign=1;;
|
||||
*) break;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
[ -n "$default" ] && sign=1
|
||||
|
||||
local curdir="$(pwd)"
|
||||
local jar="$(abspath "$1")"
|
||||
local cjar="$WOSIGN_JTMPDIR/$(basename "$jar")"
|
||||
local sjar="$(__tosjar "$jar")"
|
||||
|
||||
cd "$WOSIGN_XTMPDIR"
|
||||
rm -rf *
|
||||
jar xf "$jar"
|
||||
rm -f META-INF/*.{SF,RSA,DSA}
|
||||
|
||||
jar cf "$cjar" *
|
||||
if [ -n "$unsign" ]; then
|
||||
cp "$cjar" "$jar"
|
||||
fi
|
||||
|
||||
if [ -n "$sign" ]; then
|
||||
rm -f "$sjar"
|
||||
jarsigner -keystore "$WOSIGN_KEYSTORE" ${WOSIGN_STOREPASS:+-storepass "$WOSIGN_STOREPASS" }-signedjar "$sjar" "$cjar" $WOSIGN_KEYALIAS
|
||||
fi
|
||||
|
||||
cd "$curdir"
|
||||
}
|
||||
|
||||
function wosignable() {
|
||||
if [ -z "$WOSIGN_KEYSTORE" ]; then
|
||||
echo "Il faut spécifier le paramètre keystore"
|
||||
return 1
|
||||
elif [ -z "$WOSIGN_KEYALIAS" ]; then
|
||||
echo "Il faut spécifier le parammètre keyalias"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local srcdir="$1"
|
||||
if endswith "$srcdir" .woa; then
|
||||
srcdir="$srcdir/Contents/WebServerResources/Java"
|
||||
elif endswith "$1" .framework; then
|
||||
srcdir="$srcdir/WebServerResources/Java"
|
||||
fi
|
||||
if [ -d "$srcdir" ]; then
|
||||
if [ -z "$(list_files "$srcdir" "*.jar")" ]; then
|
||||
echo "Il n'y a pas de jars à signer"
|
||||
return 1
|
||||
fi
|
||||
elif [ -f "$srcdir" ]; then
|
||||
if ! endswith "$srcdir" .jar; then
|
||||
echo "Le fichier spécifié n'est pas un jar"
|
||||
return 1
|
||||
fi
|
||||
else
|
||||
echo "Il faut spécifier un répertoire ou un jar individuel"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function __may_sign() {
|
||||
# Si l'option -f est spécifiée, retourner true
|
||||
# Si ce jar a une version signée associée, retourner true
|
||||
# Si ce jar n'a pas de version signée associée, retourner true
|
||||
# Si ce jar est la version signée d'un autre jar, retourner false
|
||||
[ "$1" != "-f" ] && __issjar "$1" && [ -f "$(__tojar "$1")" ] && return 1
|
||||
return 0
|
||||
}
|
||||
|
||||
function __should_sign() {
|
||||
# Si l'option -f est spécifiée, retourner true
|
||||
# Sinon retourner true si la version signée n'existe pas
|
||||
# On assume que __may_sign est vrai.
|
||||
[ "$1" != "-f" ] && [ -f "$(__tosjar "$1")" ] && return 1
|
||||
return 0
|
||||
}
|
||||
|
||||
function wosign() {
|
||||
# Signer un bundle, les jars d'un répertoire, ou un jar
|
||||
# L'option -f force la resignature des jars d'un répertoire ou d'un
|
||||
# bundle. Elle force aussi la signature d'un jar, même s'il semble qu'il
|
||||
# soit la version signée d'un autre jar
|
||||
# on présuppose que wosignable a retourné true
|
||||
local default=1 sign= unsign= resign=
|
||||
while [ -n "$1" ]; do
|
||||
case "$1" in
|
||||
-s) default=; sign=1;;
|
||||
-d) default=; unsign=1;;
|
||||
-f) resign=1;;
|
||||
*) break;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
[ -n "$default" ] && sign=1
|
||||
|
||||
local srcdir="$1"
|
||||
local candidates jars jar jarname jardir
|
||||
|
||||
if endswith "$srcdir" .woa; then
|
||||
srcdir="$srcdir/Contents/WebServerResources/Java"
|
||||
elif endswith "$1" .framework; then
|
||||
srcdir="$srcdir/WebServerResources/Java"
|
||||
fi
|
||||
|
||||
if [ -d "$srcdir" ]; then
|
||||
array_from_lines candidates "$(list_files "$srcdir" "*.jar")"
|
||||
jars=()
|
||||
for jar in "${candidates[@]}"; do
|
||||
__may_sign "$srcdir/$jar" && jars=("${jars[@]}" "$srcdir/$jar")
|
||||
done
|
||||
for jar in "${jars[@]}"; do
|
||||
if __should_sign ${resign:+-f }"$jar"; then
|
||||
ebegin "$(ppath "$jar")"
|
||||
wosign_jar ${sign:+-s }${unsign:+-d }"$jar" &
|
||||
ewait $!
|
||||
eend
|
||||
fi
|
||||
done
|
||||
elif [ -f "$srcdir" ]; then
|
||||
jar="$srcdir"
|
||||
if ! __may_sign ${resign:+-f }"$jar"; then
|
||||
jardir="$(dirname "$jar")"
|
||||
jarname="$(basename "$jar")"
|
||||
eerror "$(ppath "$jar"): Ce jar est la version signée de $(ppath "$jardir/${jarname#s}")"
|
||||
elif __should_sign ${resign:+-f }"$jar"; then
|
||||
ebegin "$(ppath "$jar")"
|
||||
wosign_jar ${sign:+-s }${unsign:+-d }"$jar" &
|
||||
ewait $!
|
||||
eend
|
||||
fi
|
||||
fi
|
||||
}
|
||||
57
ulib/wotaskd
57
ulib/wotaskd
@@ -1,57 +0,0 @@
|
||||
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
## Pilotage de wotaskd
|
||||
##@cooked nocomments
|
||||
##@require base
|
||||
##@require sysinfos
|
||||
##@require webobjects
|
||||
uprovide wotaskd
|
||||
urequire base sysinfos webobjects
|
||||
|
||||
WOT_DEFAULT_HOST=localhost
|
||||
WOT_DEFAULT_PORT="${WOTASKD_PORT:-1085}"
|
||||
|
||||
function __get_woturl() {
|
||||
# $1 est un nom d'hôte de la forme host[:port]
|
||||
# Le transfomer en url pour attaquer le wotaskd:
|
||||
# http://host:port/cgi-bin/WebObjects/wotaskd.woa/$2[&$3...]
|
||||
# $2 est l'url relative à attaquer. Si $3 est spécifié, c'est le mot de
|
||||
# passe pour l'accès au moniteur. Si $4...* sont spécifiés, ce sont d'autres
|
||||
# paramètres.
|
||||
local host port paramsep="?"
|
||||
splitpair "$1" host port; shift
|
||||
[ -n "$host" ] || host="$WOT_DEFAULT_HOST"
|
||||
[ -n "$port" ] || port="$WOT_DEFAULT_PORT"
|
||||
|
||||
local woturl="http://$host:$port/cgi-bin/WebObjects/wotaskd.woa"
|
||||
if [ -n "$1" ]; then
|
||||
[ "${1#/}" == "$1" ] && woturl="$woturl/"
|
||||
woturl="$woturl$1"
|
||||
fi; shift
|
||||
if [ -n "$1" ]; then
|
||||
woturl="$woturl${paramsep}pw=$1"
|
||||
paramsep="&"
|
||||
fi; shift
|
||||
while [ -n "$1" ]; do
|
||||
woturl="$woturl${paramsep}$1"; shift
|
||||
paramsep="&"
|
||||
done
|
||||
echo "$woturl"
|
||||
}
|
||||
|
||||
function wot_config() {
|
||||
# Afficher la configuration de wotaskd
|
||||
local clean status=1
|
||||
if [ -z "$WORAURL_DATA" ]; then
|
||||
local WORAURL_DATA
|
||||
ac_set_tmpfile WORAURL_DATA
|
||||
clean=1
|
||||
fi
|
||||
if wogeturl "$(__get_woturl "$1" wa/woconfig)"; then
|
||||
cat "$WORAURL_DATA"
|
||||
status=0
|
||||
else
|
||||
status=1
|
||||
fi
|
||||
[ -n "$clean" ] && rm -f "$WORAURL_DATA"
|
||||
return $status
|
||||
}
|
||||
Reference in New Issue
Block a user