Como reiniciar o script Python automaticamente se ele é morto ou morre

Estou executando meu script Python em segundo plano na minha máquina Ubuntu (12.04) como esta -

nohup python testing.py > test.out &

Agora, é possível que, em algum momento, minha descrição Python scriptpossa morrer por qualquer motivo.

Então, eu estou pensando em ter algum tipo de cron agentscript shell bash que pode reiniciar meu script Python acima automaticamente se for morto por qualquer motivo.

Isso é possível? Se sim, qual é a melhor maneira de resolver esse tipo de problema?

ATUALIZAR:

Depois de criar o testing.confarquivo assim -

chdir /tekooz
exec python testing.py
respawn

Corri abaixo do comando sudo para iniciá-lo, mas não consigo ver esse processo atrasado usando o ps ax?

root@bx13:/bezook# sudo start testing
testing start/running, process 27794
root@bx13:/bezook# ps ax | grep testing.py
27806 pts/3    S+     0:00 grep --color=auto testing.py

Alguma idéia de por que px ax não está me mostrando nada? E como verifico se meu programa está sendo executado ou não?

Este é o meu script python -

#!/usr/bin/python
while True:
    print "Hello World"
    time.sleep(5)

No Ubuntu (até 14.04, 16.04 e posterior, use systemd) pode usar o upstart para fazer isso, melhor do que um trabalho cron. Você coloca uma configuração /etc/inite certifique-se de especificar o reaparecimento

Pode ser um arquivo mínimo /etc/init/testing.conf(edite como root):

chdir /your/base/directory
exec python testing.py
respawn

E você pode testar com /your/base/directory/testing.py:

from __future__ import print_function

import time

with open('/var/tmp/testing.log', 'a') as fp:
    print(time.time(), 'done', file=fp)
    time.sleep(3)

e comece com:

sudo start testing

e siga o que acontece (em outra janela) com:

tail -f /var/tmp/testing.log

e pare com:

sudo stop testing

Você também pode adicionar [start on][2]para que o comando seja iniciado na inicialização do sistema.

Você também pode adotar uma abordagem mais orientada a shell. Ter o seu cronolhar para o seu script e relançá-lo se ele morre.

1. Crie um novo crontab executando crontab -e. Isso abrirá uma janela do seu editor de texto favorito.

2. Adicione esta linha ao arquivo que acabou de abrir

   */5 * * * * pgrep -f testing.py || nohup python /home/you/scripts/testing.py > test.out

3. Salve o arquivo e saia do editor.

Você acabou de criar um novo crontabque será executado a cada 5 minutos e iniciará seu script, a menos que ele já esteja em execução. Veja aqui um pequeno tutorial sobre cron. Os documentos oficiais do Ubuntu cronestão aqui .

O comando real pgrepque está sendo executado é o que procura processos em execução pela cadeia de caracteres fornecida na linha de comandos. pgrep fooprocurará um programa nomeado fooe retornará seu identificador de processo . pgrep -ffaz com que pesquise toda a linha de comando usada para iniciar o programa e não apenas o nome do programa (útil porque este é um script python).

O ||símbolo significa "faça isso se o comando anterior falhar". Portanto, se o seu script não estiver em execução, pgrepele falhará, pois não encontrará nada e seu script será iniciado.

Você pode fazer com que o programa de teste redirecione a saída usando uma opção de linha de comando e use um script python simples para reiniciar o programa indefinidamente:

import subprocess

while True:
    try:
        print subprocess.check_output(['python', 'testing.py'])
    except KeyboardInterrupt:
        break

você pode colocar esse programa em segundo plano e, quando quiser parar, basta puxá-lo para o primeiro plano e matá-lo.

Você realmente não deve usar isso para produção, mas pode:

#!/bin/sh

while true; do
  nohup python testing.py >> test.out
done &

Se, por qualquer motivo, o processo python sair, o loop do shell continuará e o reiniciará, acrescentando ao .outarquivo conforme desejado. Quase sem sobrecarga e leva muito pouco tempo para configurar.

Existem várias maneiras de monitorar e reaparecer processos no UNIX / Linux. Uma das mais antigas é uma entrada "respawn" no / etc / inittab ... se você estiver usando o antigo sistema de inicialização do SysV. Outro método é usar o supervisor daemon do pacote daemontools do DJ Bernstein . Outras opções são usar os recursos do Ubuntu upstart ... ou systemd ou outros.

Mas você pode procurar alternativas init e no código Python para o Pardus: mudur daemon em particular.

Se você optar por executar uma tarefa cron (e manipulação de arquivos PID), considere ler este PEP 3143 e talvez usar sua implementação de referência.

Como mencionei em meus outros comentários, o manuseio robusto de arquivos PID é complicado. É propenso a corridas e caixas de esquina. Fica mais complicado se houver alguma chance de o seu arquivo PID terminar em um NFS ou outro sistema de arquivos em rede (parte da atomicidade garante que você obtenha a semântica de manipulação de arquivos em sistemas de arquivos UNIX / Linux locais adequados que desaparecem em algumas versões e implementações do NFS, por exemplo). Além disso, a semântica em torno do bloqueio de arquivos no UNIX pode ser complicada. (Um bloqueio flockou fcntlé liberado imediatamente, no sistema operacional de destino, quando o processo que o mantém é interrompido com o SIGKILL, por exemplo?).

Você também pode usar o monitoramento monit Or Process com o ps-watcher

O Monit é um utilitário de código aberto para gerenciar e monitorar processos, programas, arquivos, diretórios e sistemas de arquivos em um sistema UNIX. A Monit realiza manutenção e reparo automáticos e pode executar ações causais significativas em situações de erro.

Aqui está um exemplo para o seu cenário:

check process myprocessname
        matching "myprocessname"
        start program = "nohup /usr/bin/python /path/testing.py > /tmp/test.out &"
        stop program = "/usr/bin/killall myprocessname"

Veja exemplos de monit

Você precisa de um supervisor, pode usar o supervisor . É um supervisor baseado em python, portanto, fácil de modificar, se necessário.

O controle é com arquivos com sintaxe de arquivo .ini.

A resposta de Terdon não funcionou para mim, porque pgrep -f testing.pynunca 'falhou'. Ele pegaria o pid para o trabalho cron (por causa da opção -f). No entanto, sem a opção -f, o pgrep não encontrará o testing.py porque não há um processo chamado testing.py.

Minha solução para isso foi mudar

pgrep -f testing.py

para

pgrep -f testing.py | pgrep python

isso significa que o trabalho completo do crontab seria:

*/5 * * * * pgrep -f testing.py | pgrep python || nohup python /home/you/scripts/testing.py > test.out

No meu caso, como uma solução rápida, eu queria manter meu programa em execução quando ele saiu com um erro de erro ou foi morto. Por outro lado, eu queria interromper a execução quando o programa foi finalizado corretamente (código de retorno = 0)

Eu testei no Bash. Deve funcionar bem em qualquer outro shell

#!/bin/sh

echo ""
echo "Use: $0 ./instagram.py"
echo ""

echo "Executing $1 ..."

EXIT_CODE=1
(while [ $EXIT_CODE -gt 0 ]; do
    $1
    # loops on error code: greater-than 0
    EXIT_CODE=$?
done)

Para a resposta de terdon, pgrep -f testing.pynunca retornará falso de acordo com os comentários aqui :

Eu acho que a questão é que o cron gera um shell para executar seu comando, e os argumentos desse shell são correspondidos pelo pgrep desde que você esteja usando -f

Para a resposta de Matt, pgrep -f testing.pyé inútil, pois pgrep pythoncorresponde a qualquer script Python em execução. Portanto, se o cronjob de dois scripts Python, o segundo cronjob nunca será executado.

E então eu encontrei a solução para resolver pgrep -f testing.pyno comentário aqui: https://askubuntu.com/questions/1014559/running-pgrep-in-a-crontab?noredirect=1&lq=1

Meu cron para executar dois scripts Python:

* * * * * pgrep -f '^/usr/bin/python36 /home/ec2-user/myscript1\.py' || nohup /usr/bin/python36 /home/ec2-user/myscript1.py

0 * * * * pgrep -f '^/usr/bin/python36 /home/ec2-user/myscript2\.py' || nohup /usr/bin/python36 /home/ec2-user/myscript2.py