J'essaye donc de mettre en place un travail cron comme une sorte de chien de garde pour un démon que j'ai créé. Si le démon échoue et échoue, je veux que le travail cron le redémarre périodiquement ... Je ne sais pas si c'est possible, mais j'ai lu quelques didacticiels cron et je n'ai rien trouvé qui ferait ce que je je cherche ...

Mon démon démarre à partir d'un script shell, donc je recherche simplement un moyen d'exécuter une tâche cron UNIQUEMENT si l'exécution précédente de cette tâche n'est pas encore en cours d'exécution.

J'ai trouvé cet article , qui fournissait une solution à ce que j'essaie de faire en utilisant des fichiers de verrouillage, mais je ne suis pas sûr qu'il existe une meilleure façon de le faire ...

Merci de votre aide.

Je fais cela pour un programme de spouleur d'impression que j'ai écrit, c'est juste un script 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

Il fonctionne toutes les deux minutes et est assez efficace. Je l'ai envoyé par e-mail avec des informations spéciales si, pour une raison quelconque, le processus ne fonctionne pas.

Utilisez flock. C'est nouveau. C'est mieux.

Vous n'avez plus besoin d'écrire le code vous-même. Découvrez plus de raisons ici: https://serverfault.com/a/82863

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

Comme d'autres l'ont indiqué, écrire et vérifier un fichier PID est une bonne solution. Voici ma mise en œuvre 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}"

Il est surprenant que personne n'ait parlé de run-one . J'ai résolu mon problème avec ça.

 apt-get install run-one

puis ajoutez run-oneavant votre script crontab

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

Découvrez cette réponse askubuntu SE. Vous pouvez également y trouver un lien vers des informations détaillées.

N'essayez pas de le faire via cron. Demandez à cron d'exécuter un script quoi qu'il arrive, puis demandez au script de décider si le programme est en cours d'exécution et de le démarrer si nécessaire (notez que vous pouvez utiliser Ruby ou Python ou votre langage de script préféré pour ce faire)

Vous pouvez également le faire en one-liner directement dans votre crontab:

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

La façon dont je le fais lorsque j'exécute des scripts php est:

Le crontab:

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

Le code php:

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

Cette commande recherche dans la liste des processus système le nom de fichier php actuel s'il existe, le compteur de ligne (wc -l) sera supérieur à un car la commande de recherche elle-même contenant le nom de fichier

donc si vous exécutez php crons, ajoutez le code ci-dessus au début de votre code php et il ne fonctionnera qu'une seule fois.

Pour faire suite à la réponse d'Earlz, vous avez besoin d'un script wrapper qui crée un fichier $ PID.running au démarrage et le supprime lorsqu'il se termine. Le script wrapper appelle le script que vous souhaitez exécuter. L'encapsuleur est nécessaire en cas d'échec du script cible ou d'erreur, le fichier pid est supprimé.

Avec, lockrunvous n'avez pas besoin d'écrire un script wrapper pour votre tâche cron. http://www.unixwiz.net/tools/lockrun.html

Je recommanderais d'utiliser un outil existant tel que monit , il surveillera et redémarrera automatiquement les processus. Il y a plus d'informations disponibles ici . Il devrait être facilement disponible dans la plupart des distributions.

Celui-ci ne m'a jamais manqué:

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}

travail cron :

* * * * * /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
}

MISE À JOUR .. meilleure façon d'utiliser flock:

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

Je suggérerais ce qui suit pour améliorer la réponse de rsanden (je posterais comme commentaire, mais je n'ai pas assez de réputation ...):

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

Cela évite d'éventuelles fausses correspondances (et la surcharge de grepping), et supprime la sortie et ne repose que sur l'état de sortie de ps.

Un simple php personnalisé suffit à atteindre. Pas besoin de confondre avec le script shell.

Supposons que vous vouliez exécuter php /home/mypath/example.php s'il n'est pas en cours d'exécution

Ensuite, utilisez le script PHP personnalisé suivant pour faire le même travail.

créer suivant /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);
    }
?>

Puis dans votre cron, ajoutez ce qui suit

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

Pensez à utiliser pgrep (si disponible) plutôt que ps acheminé via grep si vous allez suivre cette route. Bien que, personnellement, j'ai beaucoup de kilomètres à parcourir avec les scripts du formulaire

while(1){
  call script_that_must_run
  sleep 5
}

Bien que cela puisse échouer et que les tâches cron soient souvent le meilleur moyen d'effectuer des tâches essentielles. Juste une autre alternative.

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

solo est un script très simple (10 lignes) qui empêche un programme d'exécuter plus d'une copie à la fois. Il est utile avec cron de s'assurer qu'une tâche ne s'exécute pas avant la fin d'une précédente.

Exemple

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