Comment écrire un script bash pour redémarrer un processus s'il meurt?

J'ai un script python qui vérifiera une file d'attente et effectuera une action sur chaque élément:

# checkqueue.py
while True:
  check_queue()
  do_something()

Comment puis-je écrire un script bash qui vérifiera s'il est en cours d'exécution et sinon, le démarrera. À peu près le pseudo-code suivant (ou peut-être qu'il devrait faire quelque chose comme ps | grep?):

# keepalivescript.sh
if processidfile exists:
  if processid is running:
     exit, all ok

run checkqueue.py
write processid to processidfile

J'appellerai ça depuis une crontab:

# crontab
*/5 * * * * /path/to/keepalivescript.sh

Évitez les fichiers PID, les crons ou tout autre élément qui tente d'évaluer des processus qui ne sont pas leurs enfants.

Il y a une très bonne raison pour laquelle sous UNIX, vous ne pouvez attendre que vos enfants. Toute méthode (analyse ps, pgrep, stockage d'un PID, ...) qui essaie de contourner ce problème est défectueuse et comporte des trous béants. Dites simplement non .

Au lieu de cela, vous avez besoin du processus qui surveille votre processus pour être le parent du processus. Qu'est-ce que ça veut dire? Cela signifie que seul le processus qui démarre votre processus peut attendre de manière fiable qu'il se termine. En bash, c'est absolument trivial.

until myserver; do
    echo "Server 'myserver' crashed with exit code $?.  Respawning.." >&2
    sleep 1
done

Le morceau de code bash ci-dessus s'exécute myserveren untilboucle. La première ligne démarre myserveret attend qu'elle se termine. Une fois terminé, untilvérifie son état de sortie. Si l'état de sortie est 0, cela signifie qu'il s'est terminé avec élégance (ce qui signifie que vous lui avez demandé de s'arrêter d'une manière ou d'une autre, et il l'a fait avec succès). Dans ce cas, nous ne voulons pas le redémarrer (nous venons de lui demander de s'arrêter!). Si l'état de sortie n'est pas 0 , untilexécutera le corps de la boucle, qui émet un message d'erreur sur STDERR et redémarre la boucle (retour à la ligne 1) après 1 seconde .

Pourquoi attendons-nous une seconde? Parce que si quelque chose ne va pas avec la séquence de démarrage de myserveret qu'elle se bloque immédiatement, vous aurez une boucle très intensive de redémarrage et de plantage constant entre vos mains. Le sleep 1enlève la souche à partir de cela.

Maintenant, tout ce que vous devez faire est de démarrer ce script bash (de manière asynchrone, probablement), et il le surveillera myserveret le redémarrera si nécessaire. Si vous souhaitez démarrer le moniteur au démarrage (pour que le serveur "survienne" aux redémarrages), vous pouvez le planifier dans le cron (1) de votre utilisateur avec une @rebootrègle. Ouvrez vos règles cron avec crontab:

crontab -e

Ajoutez ensuite une règle pour démarrer votre script de moniteur:

@reboot /usr/local/bin/myservermonitor

Alternativement; regardez inittab (5) et / etc / inittab. Vous pouvez y ajouter une ligne pour myservercommencer à un certain niveau d'initialisation et être réapparu automatiquement.

Éditer.

Permettez-moi d'ajouter quelques informations sur pourquoi ne pas utiliser les fichiers PID. Bien qu'ils soient très populaires; ils sont également très imparfaits et il n'y a aucune raison pour que vous ne le fassiez pas simplement de la bonne façon.

Considère ceci:

1. Recyclage PID (tuant le mauvais processus):

   • /etc/init.d/foo start: démarrer foo, écrire foole PID de/var/run/foo.pid
   • Un peu plus tard: foomeurt en quelque sorte.
   • Un peu plus tard: tout processus aléatoire qui démarre (appelez-le bar) prend un PID aléatoire, imaginez qu'il prenne fool'ancien PID.
   • Vous remarquez que c'est fooparti: /etc/init.d/foo/restartlit /var/run/foo.pid, vérifie pour voir s'il est toujours vivant, trouve bar, pense que c'est foo, tue, commence un nouveau foo.

2. Les fichiers PID deviennent périmés. Vous avez besoin d'une logique trop compliquée (ou devrais-je dire, non triviale) pour vérifier si le fichier PID est périmé, et une telle logique est à nouveau vulnérable 1..

3. Et si vous n'avez même pas accès en écriture ou si vous êtes dans un environnement en lecture seule?

4. C'est une surcompensation inutile; voyez à quel point mon exemple ci-dessus est simple. Pas besoin de compliquer ça du tout.

Voir aussi: Les fichiers PID sont-ils toujours défectueux lorsqu'ils le font «correctement»?

Au fait; pire encore que l'analyse des fichiers PID ps! Ne fais jamais ça.

1. psest très impraticable. Bien que vous le trouviez sur presque tous les systèmes UNIX; ses arguments varient considérablement si vous souhaitez une sortie non standard. Et la sortie standard est UNIQUEMENT pour la consommation humaine, pas pour l'analyse par script!
2. L'analyse psconduit à BEAUCOUP de faux positifs. Prenons l' ps aux | grep PIDexemple, et imaginez maintenant que quelqu'un démarre un processus avec un nombre quelque part comme argument qui se trouve être le même que le PID avec lequel vous avez regardé votre démon! Imaginez deux personnes qui démarrent une session X et vous attendez que X tue la vôtre. C'est juste toutes sortes de mauvais.

Si vous ne voulez pas gérer le processus vous-même; il existe des systèmes parfaitement bons qui serviront de moniteur pour vos processus. Regardez runit , par exemple.

Jetez un œil à monit ( http://mmonit.com/monit/ ). Il gère le démarrage, l'arrêt et le redémarrage de votre script et peut effectuer des vérifications de l'état et redémarrer si nécessaire.

Ou faites un simple script:

while true
do
/your/script
sleep 1
done

La façon la plus simple de le faire est d'utiliser flock on file. En script Python, vous feriez

lf = open('/tmp/script.lock','w')
if(fcntl.flock(lf, fcntl.LOCK_EX|fcntl.LOCK_NB) != 0): 
   sys.exit('other instance already running')
lf.write('%d\n'%os.getpid())
lf.flush()

Dans le shell, vous pouvez réellement tester s'il fonctionne:

if [ `flock -xn /tmp/script.lock -c 'echo 1'` ]; then 
   echo 'it's not running'
   restart.
else
   echo -n 'it's already running with PID '
   cat /tmp/script.lock
fi

Mais bien sûr, vous n'avez pas à tester, car s'il est déjà en cours d'exécution et que vous le redémarrez, il se fermera avec 'other instance already running'

À la fin du processus, tous ses descripteurs de fichiers sont fermés et tous les verrous sont automatiquement supprimés.

Vous devez utiliser monit, un outil Unix standard qui peut surveiller différentes choses sur le système et réagir en conséquence.

Depuis les documents: http://mmonit.com/monit/documentation/monit.html#pid_testing

vérifier le processus checkqueue.py avec le fichier pid /var/run/checkqueue.pid
       si changé pid alors exécutez "checkqueue_restart.sh"

Vous pouvez également configurer monit pour vous envoyer un e-mail lors d'un redémarrage.

if ! test -f $PIDFILE || ! psgrep `cat $PIDFILE`; then
    restart_process
    # Write PIDFILE
    echo $! >$PIDFILE
fi

Je ne sais pas à quel point il est portable sur les systèmes d'exploitation, mais vous pouvez vérifier si votre système contient la commande «run-one», c'est-à-dire «man run-one». Plus précisément, cet ensemble de commandes comprend «run-one-constant», ce qui semble être exactement ce dont vous avez besoin.

Depuis la page de manuel:

commande run-one-constamment [ARGS]

Remarque: évidemment, cela pourrait être appelé à partir de votre script, mais cela supprime également la nécessité d'avoir un script.

J'ai utilisé le script suivant avec beaucoup de succès sur de nombreux serveurs:

pid=`jps -v | grep $INSTALLATION | awk '{print $1}'`
echo $INSTALLATION found at PID $pid 
while [ -e /proc/$pid ]; do sleep 0.1; done

Remarques:

• Il cherche un processus java, donc je peux utiliser jps, c'est beaucoup plus cohérent entre les distributions que ps
• $INSTALLATION contient suffisamment de chemin de processus qui est c'est totalement sans ambiguïté
• Utilisez le sommeil en attendant la fin du processus, évitez de monopoliser les ressources :)

Ce script est en fait utilisé pour arrêter une instance de tomcat en cours d'exécution, que je veux arrêter (et attendre) sur la ligne de commande, donc le lancer en tant que processus enfant n'est tout simplement pas une option pour moi.

J'utilise ceci pour mon processus npm

#!/bin/bash
for (( ; ; ))
do
date +"%T"
echo Start Process
cd /toFolder
sudo process
date +"%T"
echo Crash
sleep 1
done