Então, estou tentando configurar um trabalho cron como uma espécie de watchdog para um daemon que eu criei. Se o daemon errar e falhar, quero que a tarefa cron o reinicie periodicamente ... Não tenho certeza de como isso é possível, mas li alguns tutoriais do cron e não consegui encontrar nada que fizesse o que eu fazia. estou procurando ...

Meu daemon é iniciado a partir de um script de shell, então estou apenas procurando uma maneira de executar um trabalho cron SOMENTE se a execução anterior desse trabalho ainda não estiver em execução.

Encontrei este post , que forneceu uma solução para o que estou tentando fazer usando arquivos de bloqueio, não sei se existe uma maneira melhor de fazê-lo ...

Obrigado pela ajuda.

Eu faço isso para um programa de spooler de impressão que escrevi, é apenas um script de 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

É executado a cada dois minutos e é bastante eficaz. Eu tenho um e-mail com informações especiais se, por algum motivo, o processo não estiver em execução.

Usar flock . É novo. É melhor.

Agora você não precisa escrever o código sozinho. Confira mais motivos aqui: https://serverfault.com/a/82863

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

Como outros já declararam, escrever e verificar um arquivo PID é uma boa solução. Aqui está minha implementação do 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}"

É surpreendente que ninguém tenha mencionado corrida . Eu resolvi meu problema com isso.

 apt-get install run-one

então adicione run-one antes do seu script crontab

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

Confira esta resposta do askubuntu SE. Você também pode encontrar um link para informações detalhadas.

Não tente fazer isso via cron. Faça com que o cron execute um script, não importa o quê, e faça com que o script decida se o programa está sendo executado e inicie-o, se necessário (observe que você pode usar Ruby ou Python ou sua linguagem de script favorita para fazer isso)

Você também pode fazer isso como uma linha diretamente no seu crontab:

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

A maneira como faço quando estou executando scripts php é:

O crontab:

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

O código php:

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

Este comando está pesquisando na lista de processos do sistema o nome do arquivo php atual, se existir, o contador de linha (wc -l) será maior que um, porque o próprio comando de pesquisa que contém o nome do arquivo

portanto, se você estiver executando o php crons, adicione o código acima ao início do seu código php e ele será executado apenas uma vez.

Como resposta à resposta do Earlz, você precisa de um script de wrapper que crie um arquivo $ PID.running quando for iniciado e exclua quando terminar. O script do wrapper chama o script que você deseja executar. O wrapper é necessário no caso de o script de destino falhar ou ocorrer erros, o arquivo pid é excluído.

Com lockrunvocê, não é necessário escrever um script de wrapper para seu trabalho cron. http://www.unixwiz.net/tools/lockrun.html

Eu recomendaria usar uma ferramenta existente, como o monit , ele monitorará e reiniciará automaticamente os processos. Há mais informações disponíveis aqui . Deve estar facilmente disponível na maioria das distribuições.

Este nunca me falhou:

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}

trabalho 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
}

ATUALIZAÇÃO .. melhor maneira de usar rebanho:

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

Sugiro o seguinte como uma melhoria na resposta de rsanden (eu postaria como um comentário, mas não tenho reputação suficiente ...):

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

Isso evita possíveis correspondências falsas (e a sobrecarga do grepping) e suprime a saída e depende apenas do status de saída do ps.

PHP personalizado simples é suficiente para alcançar. Não há necessidade de confundir com o shell script.

vamos assumir que você deseja executar o php /home/mypath/example.php se não estiver executando

Em seguida, use o seguinte script php personalizado para fazer o mesmo trabalho.

crie o seguinte /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);
    }
?>

Em seguida, no seu cron, adicione o seguinte

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

Considere usar o pgrep (se disponível) em vez do ps canalizado através do grep se você for seguir esse caminho. Embora, pessoalmente, eu tenha muita quilometragem dos scripts do formulário

while(1){
  call script_that_must_run
  sleep 5
}

Embora isso possa falhar e os trabalhos cron geralmente são a melhor maneira de coisas essenciais. Apenas outra alternativa.

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

solo é um script muito simples (10 linhas) que impede que um programa execute mais de uma cópia por vez. É útil com o cron garantir que um trabalho não seja executado antes que um anterior seja concluído.

Exemplo

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