Quindi sto cercando di impostare un lavoro cron come una sorta di cane da guardia per un demone che ho creato. Se il demone si guasta e fallisce, voglio che il processo cron lo riavvii periodicamente ... Non sono sicuro di quanto sia possibile, ma ho letto un paio di tutorial cron e non sono riuscito a trovare nulla che potesse fare quello che sto cercando ...

Il mio demone viene avviato da uno script di shell, quindi sto davvero cercando un modo per eseguire un lavoro cron SOLO se la precedente esecuzione di quel lavoro non è ancora in esecuzione.

Ho trovato questo post , che ha fornito una soluzione per quello che sto cercando di fare usando i file di blocco, non sono sicuro che ci sia un modo migliore per farlo ...

Grazie per l'aiuto.

Lo faccio per un programma di spooler di stampa che ho scritto, è solo uno script di shell:

#!/bin/sh
if ps -ef | grep -v grep | grep doctype.php ; then
        exit 0
else
        /home/user/bin/doctype.php >> /home/user/bin/spooler.log &
        #mailing program
        /home/user/bin/simplemail.php "Print spooler was not running...  Restarted." 
        exit 0
fi

Funziona ogni due minuti ed è abbastanza efficace. Ho ricevuto un'email con informazioni speciali se per qualche motivo il processo non è in esecuzione.

Usa flock. È nuovo. È meglio.

Ora non devi scrivere tu stesso il codice. Scopri altri motivi qui: https://serverfault.com/a/82863

/usr/bin/flock -n /tmp/my.lockfile /usr/local/bin/my_script

Come altri hanno già detto, scrivere e controllare un file PID è una buona soluzione. Ecco la mia implementazione bash:

#!/bin/bash

mkdir -p "$HOME/tmp"
PIDFILE="$HOME/tmp/myprogram.pid"

if [ -e "${PIDFILE}" ] && (ps -u $(whoami) -opid= |
                           grep -P "^\s*$(cat ${PIDFILE})$" &> /dev/null); then
  echo "Already running."
  exit 99
fi

/path/to/myprogram > $HOME/tmp/myprogram.log &

echo $! > "${PIDFILE}"
chmod 644 "${PIDFILE}"

È sorprendente che nessuno abbia parlato del run-one . Ho risolto il mio problema con questo.

 apt-get install run-one

quindi aggiungi run-oneprima del tuo script crontab

*/20 * * * * * run-one python /script/to/run/awesome.py

Dai un'occhiata a questa domanda di askubuntu SE. Qui puoi trovare anche un link a informazioni dettagliate.

Non provare a farlo tramite cron. Chiedi a cron di eseguire uno script in qualsiasi caso, quindi chiedi allo script di decidere se il programma è in esecuzione e di avviarlo se necessario (nota che puoi usare Ruby o Python o il tuo linguaggio di script preferito per farlo)

Puoi anche farlo come one-liner direttamente nel tuo crontab:

* * * * * [ `ps -ef|grep -v grep|grep <command>` -eq 0 ] && <command>

Il modo in cui lo faccio quando eseguo script php è:

Il crontab:

* * * * * php /path/to/php/script.php &

Il codice php:

<?php
if (shell_exec('ps aux | grep ' . __FILE__ . ' | wc  -l') > 1) {
    exit('already running...');
}
// do stuff

Questo comando sta cercando nell'elenco dei processi di sistema il nome file php corrente se esiste il contatore di linea (wc -l) sarà maggiore di uno perché il comando di ricerca stesso contenente il nome file

quindi se esegui php crons aggiungi il codice sopra all'inizio del tuo codice php e verrà eseguito solo una volta.

Come risposta alla risposta di Earlz, è necessario uno script wrapper che crei un file $ PID.running all'avvio e lo elimini al termine. Lo script wrapper chiama lo script che si desidera eseguire. Il wrapper è necessario nel caso in cui lo script target fallisca o si guasti, il file pid viene eliminato.

Con lockrunte non è necessario scrivere uno script wrapper per il tuo lavoro cron. http://www.unixwiz.net/tools/lockrun.html

Consiglierei di utilizzare uno strumento esistente come Monit , che monitorerà e riavvierà automaticamente i processi. Ulteriori informazioni sono disponibili qui . Dovrebbe essere facilmente disponibile nella maggior parte delle distribuzioni.

Questo non mi ha mai deluso:

one.sh :

LFILE=/tmp/one-`echo "$@" | md5sum | cut -d\  -f1`.pid
if [ -e ${LFILE} ] && kill -0 `cat ${LFILE}`; then
   exit
fi

trap "rm -f ${LFILE}; exit" INT TERM EXIT
echo $$ > ${LFILE}

$@

rm -f ${LFILE}

cron job :

* * * * * /path/to/one.sh <command>

# one instance only (works unless your cmd has 'grep' in it)
ALREADY_RUNNING_EXIT_STATUS=0
bn=`basename $0`
proc=`ps -ef | grep -v grep | grep "$bn" | grep -v " $$ "`
[ $? -eq 0 ] && {
    pid=`echo $proc | awk '{print $2}'`
    echo "$bn already running with pid $pid"
    exit $ALREADY_RUNNING_EXIT_STATUS
}

AGGIORNAMENTO .. ​​modo migliore usando flock:

/usr/bin/flock -n /tmp/your-app.lock /path/your-app args 

Suggerirei quanto segue come miglioramento della risposta di rsanden ( pubblicherei come commento, ma non ho abbastanza reputazione ...):

#!/usr/bin/env bash

PIDFILE="$HOME/tmp/myprogram.pid"

if [ -e "${PIDFILE}" ] && (ps -p $(cat ${PIDFILE}) > /dev/null); then
  echo "Already running."
  exit 99
fi

/path/to/myprogram

Questo evita possibili false corrispondenze (e il sovraccarico del grepping) e sopprime l'output e si basa solo sullo stato di uscita di ps.

È sufficiente un semplice PHP personalizzato. Non c'è bisogno di confondere con lo script della shell.

supponiamo che tu voglia eseguire php /home/mypath/example.php se non in esecuzione

Quindi utilizzare il seguente script php personalizzato per fare lo stesso lavoro.

crea il seguente /home/mypath/forever.php

<?php
    $cmd = $argv[1];
    $grep = "ps -ef | grep '".$cmd."'";
    exec($grep,$out);
    if(count($out)<5){
        $cmd .= ' > /dev/null 2>/dev/null &';
        exec($cmd,$out);
        print_r($out);
    }
?>

Quindi nel tuo cron aggiungi seguente

* * * * * php /home/mypath/forever.php 'php /home/mypath/example.php'

Prendi in considerazione l'utilizzo di pgrep (se disponibile) anziché ps inoltrato tramite grep se intendi seguire questa strada. Anche se, personalmente, ho un sacco di chilometraggio dagli script del modulo

while(1){
  call script_that_must_run
  sleep 5
}

Anche se questo può fallire e i lavori cron sono spesso il modo migliore per le cose essenziali. Solo un'altra alternativa.

Documenti: https://www.timkay.com/solo/

solo è uno script molto semplice (10 righe) che impedisce a un programma di eseguire più di una copia alla volta. È utile con cron assicurarsi che un lavoro non venga eseguito prima che uno precedente sia terminato.

Esempio

* * * * * solo -port=3801 ./job.pl blah blah