nutools/uscrontab

452 lines
17 KiB
Plaintext
Raw Normal View History

2013-08-27 15:14:44 +04:00
#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
2014-04-23 11:36:26 +04:00
source "$(dirname "$0")/ulib/ulib" || exit 1; urequire DEFAULTS crontab
2013-08-27 15:14:44 +04:00
function display_help() {
uecho "$scriptname: lancer une suite de commande en respectant une planification de type cron
USAGE
$scriptname [options] [/path/to/crontab]
$scriptname -e [/path/to/crontab]
$scriptname -l
2013-08-27 15:14:44 +04:00
2013-09-29 16:58:08 +04:00
La première forme du script doit normalement être lancé toutes les minutes par
une tâche cron. Utiliser l'option --install pour ajouter automatique la ligne
dans la crontab de l'utilisateur.
Si aucun fichier n'est spécifié, fusionner s'il existe le fichier
2014-04-23 12:26:18 +04:00
$USCRONTAB_USERFILE
avec chacun des fichiers du répertoire
2014-04-23 12:26:18 +04:00
$USCRONTAB_USERDIR
puis exécuter le fichier résultat avec le nom virtuel
2014-04-23 12:26:18 +04:00
$USCRONTAB_USER
note: le nom virtuel est utilisé pour le verrouillage avec --lock
2013-09-29 16:58:08 +04:00
A chaque lancement du script, il examine quels scripts doivent être exécutés
dans le fichier crontab spécifié. Ce fichier est composé de lignes dans un
format particulier, qui sont analysées et traitées dans l'ordre.
2013-08-27 15:14:44 +04:00
Quelles que soient les lignes qui sont sélectionnées pour le lancement, elles
2013-09-29 16:58:08 +04:00
sont garanties de s'exécuter dans l'ordre du fichier, l'une après l'autre.
2013-08-27 15:14:44 +04:00
Les lignes commençant par # sont des commentaires et sont ignorées
== Définitions de variables et exécution de commandes ==
Les lignes de la forme suivante sont des définitions de variable:
[export] var=\"valeur de la variable\"
Ces lignes sont des définitions de variable bash qui sont exécutées telles
quelles. Il n'est donc pas autorisé de mettre des espaces autour de =. Par
exemple, les lignes suivantes sont des erreurs de syntaxe:
var = bad
var=pas de quotes autour de la valeur
alors que celles-ci sont correctes:
var=ok
var=\"valeur avec des espaces\"
var='on peut utiliser des quotes aussi'
Il est possible de manipuler les variables de type PATH avec une syntaxe
particulière de l'opérateur d'assignation. Les opérateurs += et %= utilisent
uaddpath(), #= utilise uinspath() et -= utilise udelpath(). Par exemple, les
lignes suivantes ajoutent respectivement /usr/local/nutools puis enlèvent
/opt/rogue au PATH:
PATH+=/usr/local/nutools
PATH-=/opt/rogue
Bien sûr, il ne faut pas oublier de quoter les espaces:
PATH+=\"/path/to/dir with spaces\"
Les lignes de la forme suivante permettent d'exécuter une commande
quelconque:
2013-11-27 17:36:17 +04:00
\$one-line-command
2013-11-15 13:27:18 +04:00
Une variante permet de spécifier des commandes sur plusieurs lignes.
2013-11-27 17:36:17 +04:00
ATTENTION! \${ et $} doivent être tous seuls sur la ligne.
2013-11-15 13:27:18 +04:00
2013-11-27 17:36:17 +04:00
\${
2013-11-15 13:27:18 +04:00
several
commands
...
$}
Ces commandes sont exécutées systématiquement et ignorent la planification.
On peut s'en servir notamment pour lire un fichier de configuration qui
définit des variables ou des fonctions:
2013-11-27 17:36:17 +04:00
\$source path/to/file
== Planification de commandes ==
Les autres lignes doivent être au format d'une ligne de crontab:
minutes hours days months dows command-line
command-line peut être n'importe quelle ligne de commande bash, pourvu
qu'elle soit sur une seule ligne.
Certaines extensions par rapport à la syntaxe de crontab sont autorisées. Il
est en particulier possible de spécifier plusieurs planifications pour une
seule commande. Par exemple, les lignes suivantes permettent d'exécuter
'command' toutes les heures ET à 1h05:
0 * * * *
5 1 * * * command
Il est aussi possible d'utiliser la même planification pour plusieurs
commandes sans devoir répéter la définition de la planification. Les lignes
suivantes planifient command1 et command2 toutes les heures:
0 * * * * command1
command2
Pour être prise en compte, la ligne command2 doit commencer par au moins un
espace ou une tabulation. Pour la lisibilité, la syntaxe suivante est
supportée aussi:
0 * * * *
command1
command2
== Fonctions disponibles ==
La fonction check_pidfile() est disponible, et permet de vérifier qu'une
opération n'est pas déjà en cours. Si cette fonction est utilisée, il ne
faut pas modifier la valeur de -k. Par exemple:
2013-10-02 14:14:01 +04:00
0 1 * * *
check_pidfile /path/to/pid [args]
long-running-script
check_pidfile() doit être utilisée toute seule sur la ligne et s'utilise
avec les argument suivants:
check_pidfile PIDFILE [DESC] [BARRIER]
2013-08-27 15:14:44 +04:00
- PIDFILE est le fichier de PID qui est vérifié
- DESC est la description du traitement qui est effectué. La valeur par
défaut est \"Une synchronisation\". Si le fichier de PID est présent, le
message suivant est affiché:
DESC est en cours.
Si vous pensez que c'est une erreur, veuillez vérifier le process de pid PID
puis supprimez le cas échéant le fichier PIDFILE
- BARRIER est un fichier qui est créé avec le contenu 'PID' s'il n'existe
pas encore, et si la vérification du fichier de PID est faite avec succès.
2013-11-14 09:16:49 +04:00
La présence de ce fichier peut-être vérifiée par un processus externe pour
empêcher par exemple de mettre à jour les scripts pendant qu'il sont en
train de tourner.
Son contenu peut être examiné pour connaître le PID du processus qui l'a
créé initialement. Le fichier est automatiquement supprimé à la fin de ce
script.
Attention: ce fichier n'est pas un verrou, il peut être supprimé à tout
moment. Notamment, si deux scripts sont configurés pour créer le même
fichier barrière, le premier script supprimera le fichier barrière avant
la fin de l'exécution du second script.
2013-08-27 15:14:44 +04:00
La fonction remove_pidfile() permet de supprimer un fichier de pid pour
spécifier qu'une opération est terminée. Considérons l'exemple suivant:
2013-08-27 15:14:44 +04:00
2013-10-02 14:14:01 +04:00
0 1 * * *
check_pidfile /path/to/pid
script1
script2
remove_pidfile /path/to/pid
script3
2013-08-27 15:14:44 +04:00
Dans cet exemple, il ne faut pas qu'une autre occurence de script1 tourne
pendant que script2 tourne. Par contre, plusieurs occurences de script3
peuvent tourner en parallèle.
2013-08-27 15:14:44 +04:00
OPTIONS
2013-09-29 16:58:08 +04:00
-A, --install
Installer une planification toutes les minutes du script dans la crontab
de l'utilisateur. Si l'argument /path/to/crontab n'est pas spécifié,
c'est une planification générique qui exécute les fichiers par défaut.
2013-09-29 16:58:08 +04:00
-R, --uninstall
Désinstaller la planification toutes les minutes du script du crontab de
l'utilisateur. Si l'argument /path/to/crontab est spécifié, cette
instance est désinstallée. Sinon, ne désinstaller que la planification
générique.
-e, --edit
Lancer un editeur pour modifier la crontab spécifiée. Si aucun fichier
2014-04-23 12:26:18 +04:00
n'est spécifié, éditer $USCRONTAB_USERFILE
-r, --remove
Supprimer le fichier $USCRONTAB_USERFILE s'il existe
Si l'argument /path/to/crontab est spécifié, il est ignoré.
2013-09-29 16:58:08 +04:00
-l, --list
Si l'argument /path/to/crontab est spécifié, afficher le contenu de ce
fichier. Sinon, lister les contenus des fichiers crontab qui sont
exécutés avec la planification actuelle. Si une planification générique
est installée, ou si aucune planification n'est en cours, afficher le
contenu du fichier
2014-04-23 12:26:18 +04:00
$USCRONTAB_USERFILE
et chacun des fichiers du répertoire
2014-04-23 12:26:18 +04:00
$USCRONTAB_USERDIR
2013-09-29 16:58:08 +04:00
-n, --fake
Afficher au lieu de les exécuter les commandes qui doivent être lancées
OPTIONS AVANCEES
2013-08-27 15:14:44 +04:00
--lock LOCKFILE
Inscrire dans le fichier spécifié des informations permettant d'éviter
les invocations simultanées de ce script. Si selon ce fichier, le script
2014-04-23 11:36:26 +04:00
tourne depuis plus de $USCRONTAB_LOCKDELAY heures, un message d'erreur
est consigné et un message d'avertissement est affiché au plus une fois.
2013-08-27 15:14:44 +04:00
Utiliser --lock '' pour désactiver cette fonctionnalité
Par défaut, si ce script est lancé en root, le fichier utilisé pour le
verrouillage est de la forme /var/run/$scriptname/abspath/to/crontab
Si le script est lancé avec un compte utilisateur, aucun verrouillage
n'est effectué.
--lockdelay LOCKDELAY[=$USCRONTAB_LOCKDELAY]
2013-08-27 15:14:44 +04:00
Changer le nombre d'heures pendant lesquelles on autorise le script a
verrouiller l'exécution avant d'afficher un avertissement.
-c, --continuous
Par défaut, ce script s'arrête à la première commande qui retourne avec
une code d'erreur. Avec cette option, ce script ne s'arrête jamais, bien
qu'il retourne toujours un code d'erreur si une erreur s'est produite.
-k, --stopec EXITCODE[=101]
Spécifier un code d'erreur spécial qui arrête ce script sans erreur, ou
'' pour désactiver cette fonctionnalité. Ceci permet en début de script
de faire des tests par exemple sur l'environnement avant de lancer les
scripts planifiés. Si l'environnement ne convient pas, il suffit au
script de contrôle de retourner le code d'erreur spécifique pour arrêter
le traitement."
}
function set_usercrontabs() {
# initialiser le tableau $1(=usercrontabs) avec la liste suivante: le
# fichier $USCRONTAB_USERFILE s'il existe, puis la liste des fichiers dans
# le répertoire $USCRONTAB_USERDIR
local -a _userfile _userdir
[ -f "$USCRONTAB_USERFILE" ] && _userfile=("$USCRONTAB_USERFILE")
array_lsfiles _userdir "$USCRONTAB_USERDIR"
eval "${1:-usercrontabs}"'=("${_userfile[@]}" "${_userdir[@]}")'
}
USCRONTAB_CTLINE="* * * * * $script"
USCRONTAB_LOCKDELAY=8
USCRONTAB_STOPEC=101
USCRONTAB_BASEDIR=/var/uscrontab
2014-04-23 12:26:18 +04:00
USCRONTAB_USERFILE="$USCRONTAB_BASEDIR/crontabs/$USER"
USCRONTAB_USERDIR="$USCRONTAB_BASEDIR/$USER.d"
USCRONTAB_USER="$USCRONTAB_BASEDIR/$USER"
2013-09-12 14:06:14 +04:00
2013-08-27 15:14:44 +04:00
action=run
lockfile=auto
lockdelay=
fake=
continuous=
parse_opts "${PRETTYOPTS[@]}" \
--help '$exit_with display_help' \
2013-09-29 16:58:08 +04:00
-A,--add,--install action=install \
-R,--remove,--uninstall action=uninstall \
2013-08-27 15:14:44 +04:00
--lock: lockfile= \
--lockdelay: lockdelay= \
-n,--fake fake=1 \
-c,--continuous continuous=1 \
-k:,--stop: USCRONTAB_STOPEC= \
2013-09-29 16:58:08 +04:00
-l,--list action=list \
-e,--edit action=edit \
-r,--remove action=remove \
2013-08-27 15:14:44 +04:00
@ args -- "$@" && set -- "${args[@]}" || die "$args"
crontab="$1"; shift
if [ "$action" == "edit" ]; then
if [ -z "$crontab" ]; then
basedir="$(dirname "$USCRONTAB_USERFILE")"
[ -d "$basedir" ] || die "$basedir: ce répertoire n'existe pas. Vérifiez l'installation de nutools"
crontab="$USCRONTAB_USERFILE"
fi
enote "Edition de $crontab"
"${EDITOR:-vi}" "$crontab"
exit 0
elif [ "$action" == "remove" ]; then
[ -n "$crontab" ] && ewarn "$crontab: cet argument a été ignoré"
crontab="$USCRONTAB_USERFILE"
if [ -f "$crontab" ]; then
ask_yesno "Voulez-vous supprimer le fichier $crontab?" C || die
enote "Suppression de $crontab"
rm "$crontab" || die
fi
exit 0
elif [ "$action" == "list" ]; then
if [ -n "$crontab" ]; then
crontab="$(abspath "$crontab")"
array_from_lines ctfiles "$(crontab -l 2>/dev/null | awkrun script="$script" crontab="$crontab" '$6 == script && $7 == crontab { print $7 }')"
if [ ${#ctfiles[*]} -eq 0 ]; then
ewarn "$(ppath "$crontab"): non planifié"
ctfiles=("$crontab")
fi
else
array_from_lines ctfiles "$(crontab -l 2>/dev/null | awkrun script="$script" '$6 == script { if ($7) print $7; else print "GENERIC" }')"
if array_contains ctfiles "GENERIC"; then
# il y a une planification générique
array_del ctfiles "GENERIC"
set_usercrontabs usercrontabs
array_extend ctfiles usercrontabs
elif [ ${#ctfiles[*]} -eq 0 ]; then
einfo "aucune planification en cours"
set_usercrontabs ctfiles
fi
fi
2013-09-29 16:58:08 +04:00
r=1
2013-09-29 16:58:08 +04:00
for ctfile in "${ctfiles[@]}"; do
r=0 # il y a au moins une planification
etitle "$(ppath "$ctfile")" \
2013-09-29 16:58:08 +04:00
cat "$ctfile"
done
exit $r
2013-09-29 16:58:08 +04:00
fi
[ -z "$crontab" -o -f "$crontab" ] || die "$crontab: fichier introuvable"
[ -n "$crontab" ] && crontab="$(abspath "$crontab")"
2013-08-27 15:14:44 +04:00
if [ "$action" == "install" ]; then
ctline="$USCRONTAB_CTLINE"
[ -n "$crontab" ] && ctline="$ctline $(quoted_arg "$crontab")"
enable_in_crontab "$ctline" && estep "add_to_crontab $ctline"
2013-08-27 15:14:44 +04:00
elif [ "$action" == "uninstall" ]; then
ctline="$USCRONTAB_CTLINE"
[ -n "$crontab" ] && ctline="$ctline $(quoted_arg "$crontab")"
remove_from_crontab "$ctline" && estep "remove_from_crontab $ctline"
2013-08-27 15:14:44 +04:00
elif [ "$action" == "run" ]; then
clean_crontab=
if [ -n "$crontab" ]; then
default_lockfile="/var/run/$scriptname$crontab.lock"
else
set_usercrontabs usercrontabs
ac_set_tmpfile crontab
clean_crontab=1
for usercrontab in "${usercrontabs[@]}"; do
echo "# $usercrontab" >>"$crontab"
cat "$usercrontab" >>"$crontab"
done
default_lockfile="/var/run/$scriptname$USCRONTAB_USER.lock"
fi
2013-08-27 15:14:44 +04:00
if [ "$lockfile" == auto ]; then
if is_root; then
lockfile="$default_lockfile"
2013-08-27 15:14:44 +04:00
mkdirof "$lockfile" || die
else
lockfile=
fi
fi
[ -n "$lockdelay" ] || lockdelay="$USCRONTAB_LOCKDELAY"
2013-08-27 15:14:44 +04:00
if [ -n "$lockfile" ]; then
lockwarn="${lockfile%.lock}.lockwarn"
autoclean "$lockwarn"
2013-08-27 15:14:44 +04:00
retry=1
while [ -n "$retry" ]; do
case "$(lf_trylock -h "$lockdelay" "$lockfile")" in
locked)
edebug "Arrêt du script parce que le verrou $lockfile est posé"
exit 0
;;
stale)
msg="Un verrou sur '$scriptname $crontab' est posé depuis plus de $lockdelay heures. Veuillez faire vos vérification et supprimer le cas échéant le fichier $lockfile"
logger -p cron.warn -t "$scriptname" -- "$msg"
if [ -f "$lockwarn" ]; then
edebug "$msg"
else
touch "$lockwarn"
ewarn "$msg"
fi
exit 1
;;
retry) :;;
*) retry=;;
esac
done
ac_clean "$lockwarn"
2013-08-27 15:14:44 +04:00
autoclean "$lockfile"
fi
function __ctexec() {
local ec=0
if [ -n "$fake" ]; then
echo "$*"
else
edebug "$*"
if [ "${1#check_pidfile }" != "$1" ]; then
# cas particulier, c'est une fonction à exécuter dans le
# contexte courant, et non pas dans un sous-shell
eval "$*"; ec=$?
else
(eval "$*"); ec=$?
fi
2013-08-27 15:14:44 +04:00
fi
[ -n "$USCRONTAB_STOPEC" -a "$ec" == "$USCRONTAB_STOPEC" ] && exit 0
2013-08-27 15:14:44 +04:00
[ -z "$continuous" -a "$ec" != 0 ] && exit "$ec"
return 0
}
function __cterror() {
die "$*"
}
ctscript="$(ctresolve <"$crontab")"
ec=0
edebug "$ctscript"
(
2014-04-23 18:51:10 +04:00
# tableau des fichiers de pid en cours. la conséquence est que ce n'est
# pas une erreur d'appeler à plusieurs reprises check_pidfile avec le
# même fichier
__USCRONTAB_PIDFILES=()
function check_pidfile() {
if [ -n "$1" ]; then
2014-04-23 18:51:10 +04:00
local pidfile="$(abspath "$1")"
if ! array_contains __USCRONTAB_PIDFILES "$pidfile"; then
local status
pidfile_set -r "$pidfile"; status=$?
case "$status" in
1)
eerror "${2:-Une synchronisation} est en cours.
Si vous pensez que c'est une erreur, veuillez vérifier le process de pid $(<"$pidfile")
puis supprimez le cas échéant le fichier $pidfile"
return "$USCRONTAB_STOPEC"
;;
10)
die "Une erreur s'est produite pendant l'écriture du fichier de pid. Impossible de continuer"
;;
esac
array_add __USCRONTAB_PIDFILES "$pidfile"
fi
fi
if [ -n "$3" -a -w "$(dirname "$3")" ]; then
(set -o noclobber
echo_ $$ >"$3" &&
chmod 644 "$3"
) 2>/dev/null &&
autoclean "$3"
fi
return 0
}
function remove_pidfile() {
2014-04-23 18:51:10 +04:00
if [ -n "$1" ]; then
local pidfile="$(abspath "$1")"
ac_clean "$pidfile"
array_del __USCRONTAB_PIDFILES "$pidfile"
fi
}
__ac_forgetall
eval "$ctscript"
ac_cleanall
); ec=$?
ac_clean "$lockfile"
2013-08-27 15:14:44 +04:00
exit "$ec"
fi