Verifique se o script python está em execução

Eu tenho um daemon python em execução como parte do meu aplicativo da web / Como posso verificar rapidamente (usando o python) se meu daemon está em execução e, se não, iniciá-lo?

Quero fazer isso dessa forma para consertar qualquer travamento do daemon e, para que o script não precise ser executado manualmente, ele será executado automaticamente assim que for chamado e continuará em execução.

Como posso verificar (usando python) se meu script está sendo executado?

Solte um arquivo pid em algum lugar (por exemplo, / tmp). Em seguida, você pode verificar se o processo está em execução verificando se o PID no arquivo existe. Não se esqueça de excluir o arquivo ao encerrar de forma limpa e verifique-o ao iniciar.

#/usr/bin/env python

import os
import sys

pid = str(os.getpid())
pidfile = "/tmp/mydaemon.pid"

if os.path.isfile(pidfile):
    print "%s already exists, exiting" % pidfile
    sys.exit()
file(pidfile, 'w').write(pid)
try:
    # Do some actual work here
finally:
    os.unlink(pidfile)

Em seguida, você pode verificar se o processo está em execução verificando se o conteúdo de /tmp/mydaemon.pid é um processo existente. Monit (mencionado acima) pode fazer isso por você, ou você pode escrever um script de shell simples para verificar para você usando o código de retorno do ps.

ps up `cat /tmp/mydaemon.pid ` >/dev/null && echo "Running" || echo "Not running"

Para obter crédito extra, você pode usar o módulo atexit para garantir que seu programa limpe seu pidfile sob quaisquer circunstâncias (quando eliminado, exceções levantadas etc.).

Uma técnica útil em um sistema Linux é usar soquetes de domínio:

import socket
import sys
import time

def get_lock(process_name):
    # Without holding a reference to our socket somewhere it gets garbage
    # collected when the function exits
    get_lock._lock_socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)

    try:
        # The null byte (\0) means the the socket is created 
        # in the abstract namespace instead of being created 
        # on the file system itself.
        # Works only in Linux
        get_lock._lock_socket.bind('\0' + process_name)
        print 'I got the lock'
    except socket.error:
        print 'lock exists'
        sys.exit()


get_lock('running_test')
while True:
    time.sleep(3)

É atômico e evita o problema de ter arquivos de bloqueio espalhados se o seu processo for enviado por um SIGKILL

Você pode ler na documentaçãosocket.close que os soquetes são fechados automaticamente quando o lixo é coletado.

A biblioteca pid pode fazer exatamente isso.

from pid import PidFile

with PidFile():
  do_something()

Ele também tratará automaticamente o caso em que o pidfile existe, mas o processo não está em execução.

É claro que o exemplo de Dan não funcionará como deveria.

Na verdade, se o script travar, gerar uma exceção ou não limpar o arquivo pid, o script será executado várias vezes.

Sugiro o seguinte com base em outro site:

Isso é para verificar se já existe um arquivo de bloqueio existente

\#/usr/bin/env python
import os
import sys
if os.access(os.path.expanduser("~/.lockfile.vestibular.lock"), os.F_OK):
        #if the lockfile is already there then check the PID number
        #in the lock file
        pidfile = open(os.path.expanduser("~/.lockfile.vestibular.lock"), "r")
        pidfile.seek(0)
        old_pid = pidfile.readline()
        # Now we check the PID from lock file matches to the current
        # process PID
        if os.path.exists("/proc/%s" % old_pid):
                print "You already have an instance of the program running"
                print "It is running as process %s," % old_pid
                sys.exit(1)
        else:
                print "File is there but the program is not running"
                print "Removing lock file for the: %s as it can be there because of the program last time it was run" % old_pid
                os.remove(os.path.expanduser("~/.lockfile.vestibular.lock"))

Isso é parte do código onde colocamos um arquivo PID no arquivo de bloqueio

pidfile = open(os.path.expanduser("~/.lockfile.vestibular.lock"), "w")
pidfile.write("%s" % os.getpid())
pidfile.close()

Este código verificará o valor de pid em comparação com o processo em execução existente., Evitando execução dupla.

Eu espero que isso ajude.

Existem pacotes muito bons para reiniciar processos no UNIX. Aquele que tem um ótimo tutorial sobre como construir e configurar é monit . Com alguns ajustes, você pode ter uma tecnologia comprovada e sólida para manter seu daemon.

Minha solução é verificar o processo e os argumentos de linha de comando testados em windows e ubuntu linux

import psutil
import os

def is_running(script):
    for q in psutil.process_iter():
        if q.name().startswith('python'):
            if len(q.cmdline())>1 and script in q.cmdline()[1] and q.pid !=os.getpid():
                print("'{}' Process is already running".format(script))
                return True

    return False


if not is_running("test.py"):
    n = input("What is Your Name? ")
    print ("Hello " + n)

Existem inúmeras opções. Um método é usar chamadas de sistema ou bibliotecas Python que realizam essas chamadas para você. A outra é simplesmente gerar um processo como:

ps ax | grep processName

e analisar a saída. Muitas pessoas escolhem essa abordagem, não é necessariamente uma abordagem ruim na minha opinião.

Me deparei com essa velha questão procurando uma solução sozinho.

Use psutil :

import psutil
import sys
from subprocess import Popen

for process in psutil.process_iter():
    if process.cmdline() == ['python', 'your_script.py']:
        sys.exit('Process found: exiting.')

print('Process not found: starting it.')
Popen(['python', 'your_script.py'])

Sou um grande fã do Supervisor para gerenciamento de demônios. É escrito em Python, portanto, existem muitos exemplos de como interagir ou estendê-lo a partir de Python. Para seus propósitos, a API de controle de processo XML-RPC deve funcionar bem.

Experimente esta outra versão

def checkPidRunning(pid):        
    '''Check For the existence of a unix pid.
    '''
    try:
        os.kill(pid, 0)
    except OSError:
        return False
    else:
        return True

# Entry point
if __name__ == '__main__':
    pid = str(os.getpid())
    pidfile = os.path.join("/", "tmp", __program__+".pid")

    if os.path.isfile(pidfile) and checkPidRunning(int(file(pidfile,'r').readlines()[0])):
            print "%s already exists, exiting" % pidfile
            sys.exit()
    else:
        file(pidfile, 'w').write(pid)

    # Do some actual work here
    main()

    os.unlink(pidfile)

Em vez de desenvolver sua própria solução de arquivo PID (que tem mais sutilezas e casos extremos do que você imagina), dê uma olhada no supervisord - este é um sistema de controle de processo que torna mais fácil envolver o controle de tarefas e comportamentos daemon em um Python existente roteiro.

As outras respostas são ótimas para tarefas como cron jobs, mas se você estiver executando um daemon, deverá monitorá-lo com algo como daemontools .

ps ax | grep processName

se o seu script de depuração no pycharm sempre sair

pydevd.py --multiproc --client 127.0.0.1 --port 33882 --file processName

tente isto:

#/usr/bin/env python
import os, sys, atexit

try:
    # Set PID file
    def set_pid_file():
        pid = str(os.getpid())
        f = open('myCode.pid', 'w')
        f.write(pid)
        f.close()

    def goodby():
        pid = str('myCode.pid')
        os.remove(pid)

    atexit.register(goodby)
    set_pid_file()
    # Place your code here

except KeyboardInterrupt:
    sys.exit(0)

Aqui está um código mais útil (verificando se exatamente o python executa o script):

#! /usr/bin/env python

import os
from sys import exit


def checkPidRunning(pid):
    global script_name
    if pid<1:
        print "Incorrect pid number!"
        exit()
    try:
        os.kill(pid, 0)
    except OSError:
        print "Abnormal termination of previous process."
        return False
    else:
        ps_command = "ps -o command= %s | grep -Eq 'python .*/%s'" % (pid,script_name)
        process_exist = os.system(ps_command)
        if process_exist == 0:
            return True
        else:
            print "Process with pid %s is not a Python process. Continue..." % pid
            return False


if __name__ == '__main__':
    script_name = os.path.basename(__file__)
    pid = str(os.getpid())
    pidfile = os.path.join("/", "tmp/", script_name+".pid")
    if os.path.isfile(pidfile):
        print "Warning! Pid file %s existing. Checking for process..." % pidfile
        r_pid = int(file(pidfile,'r').readlines()[0])
        if checkPidRunning(r_pid):
            print "Python process with pid = %s is already running. Exit!" % r_pid
            exit()
        else:
            file(pidfile, 'w').write(pid)
    else:
        file(pidfile, 'w').write(pid)

# main programm
....
....

os.unlink(pidfile)

Aqui está a string:

ps_command = "ps -o command= %s | grep -Eq 'python .*/%s'" % (pid,script_name)

retorna 0 se "grep" for bem-sucedido e o processo "python" estiver em execução com o nome do seu script como parâmetro.

Um exemplo simples se você está procurando apenas um nome de processo existe ou não:

import os

def pname_exists(inp):
    os.system('ps -ef > /tmp/psef')
    lines=open('/tmp/psef', 'r').read().split('\n')
    res=[i for i in lines if inp in i]
    return True if res else False

Result:
In [21]: pname_exists('syslog')
Out[21]: True

In [22]: pname_exists('syslog_')
Out[22]: False

Considere o seguinte exemplo para resolver seu problema:

#!/usr/bin/python
# -*- coding: latin-1 -*-

import os, sys, time, signal

def termination_handler (signum,frame):
    global running
    global pidfile
    print 'You have requested to terminate the application...'
    sys.stdout.flush()
    running = 0
    os.unlink(pidfile)

running = 1
signal.signal(signal.SIGINT,termination_handler)

pid = str(os.getpid())
pidfile = '/tmp/'+os.path.basename(__file__).split('.')[0]+'.pid'

if os.path.isfile(pidfile):
    print "%s already exists, exiting" % pidfile
    sys.exit()
else:
    file(pidfile, 'w').write(pid)

# Do some actual work here

while running:
  time.sleep(10)

Sugiro este script porque só pode ser executado uma vez.

Usando bash para procurar um processo com o nome do script atual. Nenhum arquivo extra.

import commands
import os
import time
import sys

def stop_if_already_running():
    script_name = os.path.basename(__file__)
    l = commands.getstatusoutput("ps aux | grep -e '%s' | grep -v grep | awk '{print $2}'| awk '{print $2}'" % script_name)
    if l[1]:
        sys.exit(0);

Para testar, adicione

stop_if_already_running()
print "running normally"
while True:
    time.sleep(3)

É o que eu uso no Linux para evitar iniciar um script se ele já estiver em execução:

import os
import sys


script_name = os.path.basename(__file__)
pidfile = os.path.join("/tmp", os.path.splitext(script_name)[0]) + ".pid"


def create_pidfile():
    if os.path.exists(pidfile):
        with open(pidfile, "r") as _file:
            last_pid = int(_file.read())

        # Checking if process is still running
        last_process_cmdline = "/proc/%d/cmdline" % last_pid
        if os.path.exists(last_process_cmdline):
            with open(last_process_cmdline, "r") as _file:
                cmdline = _file.read()
            if script_name in cmdline:
                raise Exception("Script already running...")

    with open(pidfile, "w") as _file:
        pid = str(os.getpid())
        _file.write(pid)


def main():
    """Your application logic goes here"""


if __name__ == "__main__":
    create_pidfile()
    main()

Essa abordagem funciona bem sem qualquer dependência de um módulo externo.