Come faccio a scrivere uno script bash per riavviare un processo se muore?

Ho uno script Python che controllerà una coda ed eseguirà un'azione su ogni elemento:

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

Come faccio a scrivere uno script bash che controllerà se è in esecuzione e, in caso contrario, avviarlo. Circa il seguente pseudo codice (o forse dovrebbe fare qualcosa del genere ps | grep?):

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

run checkqueue.py
write processid to processidfile

Lo chiamerò da un crontab:

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

Evita file PID, cron o qualsiasi altra cosa che tenti di valutare processi che non sono i loro figli.

C'è un ottimo motivo per cui in UNIX puoi SOLO aspettare i tuoi figli. Qualsiasi metodo (analisi ps, pgrep, memorizzazione di un PID, ...) che tenta di aggirare il problema è difettoso e presenta buchi aperti. Di 'solo di no .

È invece necessario che il processo che monitora il processo sia il genitore del processo. Cosa significa questo? Significa che solo il processo che avvia il processo può attendibilmente attenderne la fine. In bash, questo è assolutamente banale.

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

Il pezzo sopra di codice bash viene eseguito myserverin un untilciclo. La prima riga inizia myservere attende che termini. Al termine, untilcontrolla il suo stato di uscita. Se lo stato di uscita è 0, significa che è terminato con grazia (il che significa che hai chiesto di chiuderlo in qualche modo, e lo ha fatto con successo). In tal caso non vogliamo riavviarlo (abbiamo appena chiesto di spegnerlo!). Se lo stato di uscita è non 0 , untilverrà eseguito il corpo del ciclo, che emette un messaggio di errore sul STDERR e riavvia il loop (torna alla linea 1) dopo 1 secondo .

Perché aspettiamo un secondo? Perché se qualcosa non va nella sequenza di avvio di myservere si blocca immediatamente, avrai un ciclo molto intenso di riavvio e arresto costante nelle tue mani. Il sleep 1toglie il ceppo da quello.

Ora tutto ciò che devi fare è avviare questo script bash (in modo asincrono, probabilmente), e lo monitorerà myservere lo riavvierà secondo necessità. Se vuoi avviare il monitor all'avvio (facendo "sopravvivere" al riavvio del server), puoi programmarlo nel cron (1) del tuo utente con una @rebootregola. Apri le tue regole cron con crontab:

crontab -e

Quindi aggiungi una regola per avviare lo script del monitor:

@reboot /usr/local/bin/myservermonitor

In alternativa; guarda inittab (5) e / etc / inittab. Puoi aggiungere una riga lì dentro per myserveriniziare a un certo livello di init ed essere rigenerato automaticamente.

Modificare.

Vorrei aggiungere alcune informazioni sul perché non utilizzare i file PID. Mentre sono molto popolari; sono anche molto imperfetti e non c'è motivo per non farlo nel modo giusto.

Considera questo:

1. Riciclo PID (interrompendo il processo sbagliato):

   • /etc/init.d/foo start: start foo, scrivi fooil PID su/var/run/foo.pid
   • Poco dopo: foomuore in qualche modo.
   • Qualche tempo dopo: qualsiasi processo casuale che inizia (chiamalo bar) prende un PID casuale, immagina che prenda fooil vecchio PID.
   • Noti fooche non c'è più: /etc/init.d/foo/restartlegge /var/run/foo.pid, controlla per vedere se è ancora vivo, trova bar, pensa che lo sia foo, lo uccide, ne inizia uno nuovo foo.

2. I file PID diventano obsoleti. È necessaria una logica troppo complicata (o dovrei dire non banale) per verificare se il file PID è obsoleto e tale logica è nuovamente vulnerabile 1..

3. Cosa succede se non si ha nemmeno accesso in scrittura o ci si trova in un ambiente di sola lettura?

4. È inutile complicazioni eccessive; guarda quanto è semplice il mio esempio sopra. Non è necessario complicarlo affatto.

Vedi anche: I file PID sono ancora imperfetti quando lo fai "giusto"?

A proposito; anche peggio dei file PID sta analizzando ps! Non farlo mai.

1. psè molto insostituibile. Mentre lo trovi su quasi tutti i sistemi UNIX; i suoi argomenti variano notevolmente se si desidera un output non standard. E l'output standard è SOLO per il consumo umano, non per l'analisi tramite script!
2. L'analisi psporta a MOLTI falsi positivi. Prendi l' ps aux | grep PIDesempio e ora immagina che qualcuno inizi un processo con un numero da qualche parte come argomento che sembra essere lo stesso del PID con cui hai fissato il tuo demone! Immagina due persone che iniziano una sessione X e stai chiedendo a X di uccidere la tua. È solo ogni tipo di male.

Se non vuoi gestire tu stesso il processo; ci sono alcuni sistemi perfettamente validi là fuori che fungeranno da monitor per i tuoi processi. Guarda runit , per esempio.

Dai un'occhiata a monit ( http://mmonit.com/monit/ ). Gestisce l'avvio, l'arresto e il riavvio dello script e può eseguire controlli di integrità e riavvii se necessario.

O fai un semplice script:

while true
do
/your/script
sleep 1
done

Il modo più semplice per farlo è usare flock su file. Nello script Python lo faresti

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()

In shell puoi effettivamente verificare se è in esecuzione:

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

Ma ovviamente non devi testarlo, perché se è già in esecuzione e lo riavvii, uscirà con 'other instance already running'

Quando il processo termina, tutti i descrittori dei file vengono chiusi e tutti i blocchi vengono rimossi automaticamente.

Dovresti usare monit, uno strumento unix standard in grado di monitorare diverse cose sul sistema e reagire di conseguenza.

Dai documenti: http://mmonit.com/monit/documentation/monit.html#pid_testing

controllare il processo checkqueue.py con pidfile /var/run/checkqueue.pid
       se modificato pid, esegui "checkqueue_restart.sh"

Puoi anche configurare monit per inviarti un'e-mail quando fa un riavvio.

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

Non sono sicuro di quanto sia portatile tra i sistemi operativi, ma potresti verificare se il tuo sistema contiene il comando 'run-one', ovvero "man run-one". Nello specifico, questo set di comandi include 'run-one-costantemente', che sembra essere esattamente ciò che è necessario.

Dalla pagina man:

run-one-costantemente COMANDO [ARGS]

Nota: ovviamente questo potrebbe essere chiamato dall'interno del tuo script, ma rimuove anche la necessità di avere uno script.

Ho usato il seguente script con grande successo su numerosi server:

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

Appunti:

• Sta cercando un processo Java, quindi posso usare jps, questo è molto più coerente tra le distribuzioni rispetto a ps
• $INSTALLATION contiene abbastanza del percorso del processo che è totalmente inequivocabile
• Usa il sonno mentre aspetti che il processo muoia, evita le risorse di hogging :)

Questo script viene effettivamente utilizzato per chiudere un'istanza in esecuzione di Tomcat, che voglio chiudere (e attendere) dalla riga di comando, quindi avviarlo come processo figlio non è un'opzione per me.

Lo uso per il mio processo npm

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