Controlla se lo script Python è in esecuzione

Ho un demone python in esecuzione come parte della mia app web / Come posso verificare rapidamente (usando python) se il mio demone è in esecuzione e, in caso contrario, avviarlo?

Voglio farlo in questo modo per correggere eventuali arresti anomali del demone, quindi lo script non deve essere eseguito manualmente, verrà eseguito automaticamente non appena viene chiamato e quindi rimarrà in esecuzione.

Come posso verificare (usando python) se il mio script è in esecuzione?

Rilascia un pidfile da qualche parte (ad esempio / tmp). Quindi puoi verificare se il processo è in esecuzione controllando per vedere se il PID nel file esiste. Non dimenticare di eliminare il file quando lo spegni in modo pulito e di controllarlo all'avvio.

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

Quindi puoi verificare se il processo è in esecuzione controllando se il contenuto di /tmp/mydaemon.pid è un processo esistente. Monit (menzionato sopra) può farlo per te, oppure puoi scrivere un semplice script di shell per controllarlo usando il codice di ritorno da ps.

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

Per un credito extra, puoi usare il modulo atexit per assicurarti che il tuo programma ripulisca il suo pidfile in qualsiasi circostanza (quando ucciso, eccezioni sollevate, ecc.).

Una tecnica utile su un sistema Linux è l'utilizzo di socket di dominio:

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)

È atomico ed evita il problema di avere file di blocco in giro se il tuo processo viene inviato un SIGKILL

È possibile leggere nella documentazionesocket.close che i socket vengono chiusi automaticamente quando vengono raccolti i dati inutili.

La libreria pid può fare esattamente questo.

from pid import PidFile

with PidFile():
  do_something()

Gestirà automaticamente anche il caso in cui il pidfile esiste ma il processo non è in esecuzione.

Ovviamente l'esempio di Dan non funzionerà come dovrebbe.

Infatti, se lo script si blocca, genera un'eccezione o non pulisce il file pid, lo script verrà eseguito più volte.

Suggerisco quanto segue sulla base di un altro sito Web:

Questo serve per verificare se esiste già un file di blocco

\#/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"))

Questo fa parte del codice in cui inseriamo un file PID nel file di blocco

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

Questo codice controllerà il valore di pid rispetto al processo in esecuzione esistente, evitando la doppia esecuzione.

Spero che sarà di aiuto.

Esistono ottimi pacchetti per riavviare i processi su UNIX. Uno che ha un ottimo tutorial su come costruirlo e configurarlo è monit . Con alcune modifiche puoi avere una tecnologia solida come una roccia che tiene il passo del tuo demone.

La mia soluzione è controllare il processo e gli argomenti della riga di comando Testato su 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)

Ci sono una miriade di opzioni. Un metodo consiste nell'usare chiamate di sistema o librerie Python che eseguono tali chiamate per te. L'altro è semplicemente generare un processo come:

ps ax | grep processName

e analizza l'output. Molte persone scelgono questo approccio, non è necessariamente un cattivo approccio a mio avviso.

Mi sono imbattuto in questa vecchia domanda cercando io stesso una soluzione.

Usa 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'])

Sono un grande fan di Supervisor per la gestione dei demoni. È scritto in Python, quindi ci sono molti esempi di come interagire o estenderlo da Python. Per i tuoi scopi, l' API di controllo del processo XML-RPC dovrebbe funzionare bene.

Prova quest'altra versione

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)

Piuttosto che sviluppare la tua soluzione di file PID (che ha più sottigliezze e casi d'angolo di quanto potresti pensare), dai un'occhiata a supervisord : questo è un sistema di controllo dei processi che semplifica il controllo del lavoro e i comportamenti del demone attorno a un Python esistente script.

Le altre risposte sono ottime per cose come cron job, ma se stai eseguendo un demone dovresti monitorarlo con qualcosa come daemontools .

ps ax | grep processName

se il tuo script di debug in pycharm esce sempre

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

prova questo:

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

Ecco un codice più utile (con il controllo se esattamente Python esegue lo 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)

Ecco la stringa:

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

restituisce 0 se "grep" ha esito positivo e il processo "python" è attualmente in esecuzione con il nome del tuo script come parametro.

Un semplice esempio se stai cercando solo un nome di processo esiste o no:

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

Considera il seguente esempio per risolvere il tuo 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)

Suggerisco questo script perché può essere eseguito una sola volta.

Usare bash per cercare un processo con il nome dello script corrente. Nessun file aggiuntivo.

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);

Per testare, aggiungi

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

Questo è ciò che uso in Linux per evitare di avviare uno script se già in esecuzione:

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()

Questo approccio funziona bene senza alcuna dipendenza da un modulo esterno.