Ich versuche also, einen Cron-Job als eine Art Watchdog für einen von mir erstellten Daemon einzurichten. Wenn der Daemon ausfällt und fehlschlägt, möchte ich, dass der Cron-Job ihn regelmäßig neu startet ... Ich bin mir nicht sicher, wie dies möglich ist, aber ich habe ein paar Cron-Tutorials durchgelesen und konnte nichts finden, was das tun würde, was ich tun würde suche ...

Mein Daemon wird von einem Shell-Skript aus gestartet, daher suche ich wirklich nur nach einer Möglichkeit, einen Cron-Job NUR auszuführen, wenn die vorherige Ausführung dieses Jobs noch nicht ausgeführt wird.

Ich habe diesen Beitrag gefunden , der eine Lösung für das bietet, was ich mit Sperrdateien versuche. Ich bin mir nicht sicher, ob es einen besseren Weg gibt ...

Danke für Ihre Hilfe.

Ich mache das für ein Print-Spooler-Programm, das ich geschrieben habe, es ist nur ein Shell-Skript:

#!/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

Es läuft alle zwei Minuten und ist sehr effektiv. Ich habe eine E-Mail mit speziellen Informationen, wenn der Prozess aus irgendeinem Grund nicht ausgeführt wird.

Verwenden Sie flock. Es ist neu. Es ist besser.

Jetzt müssen Sie den Code nicht mehr selbst schreiben. Weitere Gründe finden Sie hier: https://serverfault.com/a/82863

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

Wie bereits erwähnt, ist das Schreiben und Überprüfen einer PID-Datei eine gute Lösung. Hier ist meine Bash-Implementierung:

#!/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}"

Es ist überraschend, dass niemand von Run-One gesprochen hat . Ich habe mein Problem damit gelöst.

 apt-get install run-one

run-oneFügen Sie dann vor Ihrem Crontab-Skript hinzu

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

Schauen Sie sich diese Antwort von askubuntu SE an. Dort finden Sie auch einen Link zu detaillierten Informationen.

Versuchen Sie nicht, es über Cron zu tun. Lassen Sie cron ein Skript ausführen, egal was passiert, und lassen Sie das Skript dann entscheiden, ob das Programm ausgeführt wird, und starten Sie es gegebenenfalls (beachten Sie, dass Sie dazu Ruby oder Python oder Ihre bevorzugte Skriptsprache verwenden können).

Sie können dies auch als Einzeiler direkt in Ihrem Crontab tun:

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

Die Art und Weise, wie ich es mache, wenn ich PHP-Skripte ausführe, ist:

Die Crontab:

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

Der PHP-Code:

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

Dieser Befehl sucht in der Systemprozessliste nach dem aktuellen PHP-Dateinamen, falls vorhanden. Der Zeilenzähler (wc -l) ist größer als eins, da der Suchbefehl selbst den Dateinamen enthält

Wenn Sie also PHP-Crones ausführen, fügen Sie den obigen Code am Anfang Ihres PHP-Codes hinzu und er wird nur einmal ausgeführt.

Als Antwort auf die Antwort von Earlz benötigen Sie ein Wrapper-Skript, das beim Start eine $ PID.running-Datei erstellt und beim Ende löscht. Das Wrapper-Skript ruft das Skript auf, das Sie ausführen möchten. Der Wrapper ist erforderlich, falls das Zielskript fehlschlägt oder Fehler auftreten. Die PID-Datei wird gelöscht.

Mit müssen lockrunSie kein Wrapper-Skript für Ihren Cron-Job schreiben. http://www.unixwiz.net/tools/lockrun.html

Ich würde empfehlen, ein vorhandenes Tool wie monit zu verwenden , das Prozesse überwacht und automatisch neu startet. Weitere Informationen finden Sie hier . Es sollte in den meisten Distributionen leicht verfügbar sein.

Dieser hat mich nie im Stich gelassen:

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
}

UPDATE .. besserer Weg mit Herde:

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

Ich würde Folgendes als Verbesserung von Rsandens Antwort vorschlagen (ich würde als Kommentar posten, aber nicht genug Ruf haben ...):

#!/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

Dies vermeidet mögliche falsche Übereinstimmungen (und den Aufwand für das Greppen), unterdrückt die Ausgabe und hängt nur vom Exit-Status von ps ab.

Einfache benutzerdefinierte PHP ist genug zu erreichen. Keine Notwendigkeit, mit Shell-Skript zu verwechseln.

Nehmen wir an, Sie möchten php /home/mypath/example.php ausführen, wenn es nicht ausgeführt wird

Verwenden Sie dann das folgende benutzerdefinierte PHP-Skript, um den gleichen Job auszuführen.

Erstelle folgendes /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);
    }
?>

Fügen Sie dann in Ihrem Cron Folgendes hinzu

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

Verwenden Sie pgrep (falls verfügbar) anstelle von ps, das durch grep geleitet wird, wenn Sie diesen Weg gehen möchten. Obwohl ich persönlich eine Menge Kilometer mit Skripten des Formulars habe

while(1){
  call script_that_must_run
  sleep 5
}

Dies kann jedoch fehlschlagen und Cron-Jobs sind oft der beste Weg für wichtige Dinge. Nur eine andere Alternative.

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

solo ist ein sehr einfaches Skript (10 Zeilen), das verhindert, dass ein Programm mehr als eine Kopie gleichzeitig ausführt. Mit cron ist es hilfreich sicherzustellen, dass ein Job nicht ausgeführt wird, bevor ein vorheriger abgeschlossen wurde.

Beispiel

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