nutools/ulib

378 lines
12 KiB
Plaintext
Raw Normal View History

#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$(dirname -- "$0")/lib/ulib/auto" || exit 1
function display_help() {
uecho "$scriptname: Gestion des librairies ulib et pyulib
USAGE
$scriptname [options] --destdir DESTDIR [options]
$scriptname [options] --version [options]
$scriptname [options] --shell [options]
SYNCHRONISER ULIB/PYULIB
-S, --sync
Synchroniser ulib, pyulib et les scripts de support
-d, --destdir DESTDIR
Synchroniser ulib et/ou pyulib dans le répertoire destdir.
Les options -u et -p permettent de choisir ce qui est synchronisé
-u, --ulib
Copier/mettre à jour ulib (par défaut)
-p, --pyulib
Copier/mettre à jour pyulib
-s, --support
Copier/mettre à jour les scripts de support
GERER LA VERSION DE ULIB
-v, --version
Gérer la version de ulib
-l, --show
Afficher la version de la librairie (par défaut)
-s, --system
Afficher aussi la version de la librairie système
-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.
-V, --set-version VERSION
Forcer la version de ulib
-u, --update
Incrémenter la version de ulib. Les options -x, -z, -p permettent de
choisir le numéro qui est incrémenté.
-x, --major
Augmenter le numéro de version majeure
-z, --minor
Augmenter le numéro de version mineure. C'est l'option par défaut
-p, --patchlevel
Augementer le numéro de patch
LANCER UN SHELL (par défaut)
-s, --shell
Lancer un shell dans lequel les modules de ulib spécifiés sont chargés.
De plus, PATH est modifié pour que $scriptdir soit ajouté en premier.
Les arguments restants sont passés inchangés au shell.
-r, --require module
Spécifier un module à charger avec urequire. Plusieurs modules peuvent
être spécifiés en les séparant par ':'
Par défaut, seul le module DEFAULTS est chargé.
--force-reload
Forcer le (re)chargement des modules avec urequire. Cette option est
utile pour le développement. En effet, dans le shell, la commande
'urequire module' (re)charge toujours le module, même s'il avait déjà
été chargé."
}
function formatversion() {
local major="${1:-${major:-0}}" minor="${2:-${minor:-0}}" patch="${3:-${patch:-0}}"
while [ ${#major} -lt 3 ]; do major="0$major"; done
while [ ${#minor} -lt 3 ]; do minor="0$minor"; done
while [ ${#patch} -lt 3 ]; do patch="0$patch"; done
echo "$major$minor$patch"
}
function parsepversion() {
local v M m p
if [[ "$1" == *.* ]]; then
local v="$1"; shift
local M=0 m=0 p=0
if [[ "$v" == *.* ]]; then
p="${v##*.}"; v="${v%.*}"
if [[ "$v" == *.* ]]; then
m="${v##*.}"; v="${v%.*}"
if [[ "$v" == *.* ]]; then
M="${v##*.}"; v="${v%.*}"
else
M="$v"
fi
else
m="$v"
fi
else
p="$v"
fi
parseversion "$(formatversion "$M" "$m" "$p")" "$@"
else
parseversion "$@"
fi
}
function parseversion() {
if [ -n "$2" ]; then
local version="${1:-${version:-000000000}}"
local major minor patch pversion
else
version="${1:-${version:-000000000}}"
fi
while [ ${#version} -lt 9 ]; do version="0$version"; done
major="${version:0:3}"; while [ ${#major} -gt 1 -a "${major#0}" != "$major" ]; do major="${major#0}"; done
minor="${version:3:3}"; while [ ${#minor} -gt 1 -a "${minor#0}" != "$minor" ]; do minor="${minor#0}"; done
patch="${version:6:3}"; while [ ${#patch} -gt 1 -a "${patch#0}" != "$patch" ]; do patch="${patch#0}"; done
pversion="$major.$minor.$patch"
[ -n "$2" ] && eval "${2}version=\$version; ${2}major=\$major; ${2}minor=\$minor; ${2}patch=\$patch; ${2}pversion=\$pversion"
}
# mode de fonctionnement
case "$scriptname" in
ulibsync) mode=sync;;
ulibversion) mode=version;;
ulibshell) mode=shell;;
*) mode=auto;;
esac
# mode sync
destdir=
syncwhat=auto
synculib=
syncpyulib=
syncsupport=
# mode version
action=show
system=
min_version=
set_version=
inc_version=minor
# mode shell
modules=()
# options courtes partagées
u_opt=; p_opt=; s_opt=
parse_opts + "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
-S,--sync mode=sync \
-d:,--destdir: '$mode=sync; set@ destdir' \
--ulib '$mode=sync; syncwhat=; synculib=1' \
--pyulib '$mode=sync; syncwhat=; syncpyulib=1' \
--support '$mode=sync; syncwhat=; syncsupport=1' \
-v,--version mode=version \
-l,--show '$mode=version; action=show' \
--system '$mode=version; action=show; system=1' \
-c:,--check: '$mode=version; action=check; set@ min_version' \
-V:,--set-version: '$mode=version; action=set; set@ set_version' \
--update '$mode=version; action=inc' \
-x,--major '$mode=version; action=inc; inc_version=major' \
-z,--minor '$mode=version; action=inc; inc_version=minor' \
--patchlevel '$mode=version; action=inc; inc_version=patch' \
--shell mode=shell \
-r:,--require: '$mode=shell; add@ modules' \
--force-reload '$mode=shell; __ULIB_FORCE_RELOAD=1' \
-u u_opt=1 \
-p p_opt=1 \
-s s_opt=1 \
@ args -- "$@" && set -- "${args[@]}" || die "$args"
case "$mode" in
auto)
mode=
if [ -n "$u_opt" ]; then
mode=version; action=inc
fi
if [ -n "$p_opt" -a -n "$u_opt" ]; then
# support de -up
mode=version; action=inc; inc_version=patch
elif [ -n "$p_opt" ]; then
die "getopt: invalid option 'p'"
fi
if [ -n "$s_opt" ]; then
mode=shell
fi
;;
esac
[ -n "$mode" ] || mode=shell
case "$mode" in
sync)
[ -n "$u_opt" ] && { syncwhat=; synculib=1; }
[ -n "$p_opt" ] && { syncwhat=; syncpyulib=1; }
[ -n "$s_opt" ] && { syncwhat=; syncsupport=1; }
[ "$syncwhat" == auto ] && {
synculib=1
#syncpyulib=
#syncsupport=
}
2014-07-08 11:03:07 +04:00
[ -n "$destdir" ] || destdir="$1"
[ -z "$destdir" -a -n "$synculib" -a -d lib/ulib ] && destdir=lib
[ -z "$destdir" -a -n "$syncpyulib" -a -d lib/pyulib ] && destdir=lib
[ -n "$destdir" ] || destdir=.
2014-07-08 11:03:07 +04:00
ask_yesno "Voulez-vous copier ${synculib:+
- la librairie ulib}${syncpyulib:+
- la librairie pyulib}${syncsupport:+
- scripts de support}
dans $(ppath "$destdir")?" O || die
urequire install
if [ -n "$synculib" ]; then
__ulib_install_show_args ulib "$destdir" 1
ulibsync "$destdir"
fi
if [ -n "$syncpyulib" ]; then
urequire pyulib/pyulib
__ulib_install_show_args pyulib "$destdir" 1
pyulibsync "$destdir"
fi
if [ -n "$syncsupport" ]; then
2014-07-08 11:03:07 +04:00
adestdir="$(abspath "$destdir")"
for i in .nutools-bootstrap; do
if [ "${adestdir%/lib}" != "$adestdir" ]; then
# cas particulier: synchro vers un répertoire lib/
# dans ce cas, copier le fichier .nutools-bootstrap dans le
# répertoire parent.
copy_update "$scriptdir/$i" "$(dirname -- "$destdir")"
else
copy_update "$scriptdir/$i" "$destdir"
fi
done
2014-07-08 11:03:07 +04:00
# calculer le nom du répertoire de destination, pour nommer les fichiers
# local-uinst
destpfix="${adestdir%/lib}"
destpfix="${destpfix##*/}"
destpfix="${destpfix:-local}"
for i in lib/ulib/support/local-uinst lib/ulib/support/local-uinst.sh; do
destname="$destpfix-${i#lib/ulib/support/local-}"
2014-07-08 11:03:07 +04:00
copy_update "$scriptdir/$i" "$destdir/$destname"
done
fi
exit 0
;;
version)
[ -n "$u_opt" ] && { action=inc; }
[ -n "$p_opt" ] && { action=inc; inc_version=patch; }
[ -n "$s_opt" ] && { action=show; system=1; }
setx version formatversion 0 0 0
versionfile="$scriptdir/lib/ulib/.ulibver"
[ -f "$versionfile" ] || echo "$version" >"$versionfile"
[ -f "$versionfile" ] && version="$(<"$versionfile")"
parseversion "$(<"$versionfile")"
if [ "$action" == set -o "$action" == inc ]; then
[ -f "$scriptdir/.nutools-devel" ] ||
die "Cette installation de ulib est déjà déployé en version $pversion: impossible de la mettre à jour."
fi
if [ "$action" == show ]; then
if [ -n "$system" ]; then
setx sversion formatversion 0 0 0
sversionfile="/etc/.ulibver"
[ -f "$sversionfile" ] && sversion="$(<"$sversionfile")"
parseversion "$(<"$versionfile")" s
fi
if isatty; then
eecho "ulib est en version $pversion"
[ -n "$system" ] && eecho "/etc/ulib est en version $spversion"
else
echo "$pversion"
[ -n "$system" ] && echo "$spversion"
fi
elif [ "$action" == set ]; then
parsepversion "$set_version"
formatversion >"$versionfile"
eecho "ulib est maintenant en version $pversion"
elif [ "$action" == inc ]; then
case "$inc_version" in
major) major=$(($major + 1)); minor=0; patch=0;;
minor) minor=$(($minor + 1)); patch=0;;
patch) patch=$(($patch + 1));;
esac
formatversion >"$versionfile"
parseversion "$(<"$versionfile")"
eecho "ulib est maintenant en version $pversion"
elif [ "$action" == check ]; then
r=1
parsepversion "$min_version" m
[ "$version" -ge "$mversion" ] && r=0
if [ $r -eq 0 ]; then
eecho "ulib est en version $pversion >= $mpversion ${COULEUR_VERTE}[OK]${COULEUR_NORMALE}"
else
eecho "ulib est en version $pversion < $mpversion ${COULEUR_ROUGE}[KO]${COULEUR_NORMALE}"
fi
exit $r
else
die "BUG: action inconnue $action"
fi
;;
shell)
[ -n "$u_opt" ] && die "getopt: invalid option 'u'"
[ -n "$p_opt" ] && die "getopt: invalid option 'p'"
[ -n "$s_opt" ] && { mode=shell; } # FYI, ici $mode vaut déjà shell
ac_set_tmpfile bashrc
echo "\
if ! grep -q '/etc/bash.bashrc' /etc/profile; then
[ -f /etc/bash.bashrc ] && source /etc/bash.bashrc
fi
if ! grep -q '~/.bashrc' ~/.bash_profile; then
[ -f ~/.bashrc ] && source ~/.bashrc
fi
[ -f /etc/profile ] && source /etc/profile
[ -f ~/.bash_profile ] && source ~/.bash_profile
if ! grep -q '$scriptdir/bashrc' ~/.bashrc; then
if [ -f '$scriptdir/bashrc' ]; then
if ! grep -q @@dest@@ '$scriptdir/bashrc'; then
# ne lire que si le répertoire est déployé
source '$scriptdir/bashrc'
fi
fi
function uprovide() { :; }
source '$scriptdir/lib/ulib/uenv'
__uenv_source_dirs '$scriptdir/lib/bashrc.d'
__uenv_cleanup
fi
if ! grep -q '$scriptdir/profile' ~/.bash_profile; then
if [ -f '$scriptdir/profile' ]; then
if grep -q @@dest@@ '$scriptdir/profile'; then
# répertoire non déployé
# la ligne suivante est copiée du fichier profile
[ -z '$USER' -a -n '$LOGNAME' ] && export USER='$LOGNAME'
else
# ne lire que si le répertoire est déployé
source '$scriptdir/profile'
fi
fi
function uprovide() { :; }
source '$scriptdir/lib/ulib/uenv'
__uenv_source_dirs '$scriptdir/lib/profile.d'
__uenv_cleanup
fi
# Modifier le PATH. Ajouter aussi le chemin vers les uapps python
PATH=$(qval "$scriptdir:$scriptdir/lib/pyulib/src/uapps:$PATH")
if [ -n '$DEFAULT_PS1' ]; then
DEFAULT_PS1=$(qval "[ulibshell] $DEFAULT_PS1")
else
if [ -z '$PS1' ]; then
PS1='\\u@\\h \\w \\$ '
fi
PS1=\"[ulibshell] \$PS1\"
fi
$(qvals source "$scriptdir/lib/ulib/ulib")
__ULIB_FORCE_RELOAD=$(qval "$__ULIB_FORCE_RELOAD")
urequire DEFAULTS" >"$bashrc"
array_fix_paths modules
if [ -n "${modules[*]}" ]; then
etitle "Chargement des modules"
for module in "${modules[@]}"; do
estep "$module"
qvals urequire "$module" >>"$bashrc"
done
eend
fi
estep "Lancement du sous-shell"
"$SHELL" --rcfile "$bashrc" -i -- "$@"
# note: ne pas faire exec "$SHELL", parce que sinon le fichier temporaire bashrc
# n'est pas supprimé
ac_clean "$bashrc"
;;
esac