Vérifiez si le script python est en cours d'exécution

J'ai un démon python en cours d'exécution dans le cadre de mon application Web / Comment puis-je vérifier rapidement (en utilisant python) si mon démon est en cours d'exécution et, sinon, le lancer?

Je veux le faire de cette façon pour corriger les plantages du démon, et donc le script n'a pas besoin d'être exécuté manuellement, il s'exécutera automatiquement dès qu'il sera appelé et continuera à fonctionner.

Comment puis-je vérifier (à l'aide de python) si mon script est en cours d'exécution?

Déposez un fichier pid quelque part (par exemple / tmp). Ensuite, vous pouvez vérifier si le processus est en cours d'exécution en vérifiant si le PID dans le fichier existe. N'oubliez pas de supprimer le fichier lorsque vous vous arrêtez proprement et de le vérifier au démarrage.

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

Ensuite, vous pouvez vérifier si le processus est en cours d'exécution en vérifiant si le contenu de /tmp/mydaemon.pid est un processus existant. Monit (mentionné ci-dessus) peut le faire pour vous, ou vous pouvez écrire un simple script shell pour le vérifier pour vous en utilisant le code de retour de ps.

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

Pour un crédit supplémentaire, vous pouvez utiliser le module atexit pour vous assurer que votre programme nettoie son pidfile en toutes circonstances (une fois tué, des exceptions levées, etc.).

Une technique pratique sur un système Linux utilise des sockets de domaine:

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)

C'est atomique et évite le problème d'avoir des fichiers de verrouillage qui traînent si votre processus reçoit un SIGKILL

Vous pouvez lire dans la documentationsocket.close que les sockets sont automatiquement fermés lors du nettoyage de la mémoire.

La bibliothèque pid peut faire exactement cela.

from pid import PidFile

with PidFile():
  do_something()

Il traitera également automatiquement le cas où le pidfile existe mais que le processus ne s'exécute pas.

Bien sûr, l'exemple de Dan ne fonctionnera pas comme il se doit.

En effet, si le script plante, déclenche une exception ou ne nettoie pas le fichier pid, le script sera exécuté plusieurs fois.

Je suggère ce qui suit basé sur un autre site Web:

Ceci permet de vérifier s'il existe déjà un fichier de verrouillage

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

Cela fait partie du code où nous mettons un fichier PID dans le fichier de verrouillage

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

Ce code vérifiera la valeur de pid par rapport au processus en cours d'exécution existant, évitant ainsi la double exécution.

J'espère que cela aidera.

Il existe de très bons packages pour redémarrer les processus sous UNIX. Celui qui a un excellent tutoriel sur la construction et la configuration est monit . Avec quelques ajustements, vous pouvez avoir une technologie éprouvée solide comme le roc pour maintenir votre démon.

Ma solution est de vérifier le processus et les arguments de la ligne de commande Testé sur Windows et 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)

Il existe une myriade d'options. Une méthode consiste à utiliser des appels système ou des bibliothèques python qui effectuent de tels appels pour vous. L'autre consiste simplement à engendrer un processus comme:

ps ax | grep processName

et analysez la sortie. Beaucoup de gens choisissent cette approche, ce n'est pas nécessairement une mauvaise approche à mon avis.

Je suis tombé sur cette vieille question à la recherche d'une solution moi-même.

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

Je suis un grand fan de Supervisor pour la gestion des démons. Il est écrit en Python, il existe donc de nombreux exemples sur la façon d'interagir avec ou de l'étendre à partir de Python. Pour vos besoins, l' API de contrôle de processus XML-RPC devrait fonctionner correctement.

Essayez cette autre version

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)

Plutôt que de développer votre propre solution de fichier PID (qui a plus de subtilités et de cas de coin que vous ne le pensez), jetez un œil à supervisord - il s'agit d'un système de contrôle de processus qui facilite le contrôle des tâches et les comportements de démon autour d'un Python existant scénario.

Les autres réponses sont excellentes pour des choses comme les tâches cron, mais si vous exécutez un démon, vous devriez le surveiller avec quelque chose comme daemontools .

ps ax | grep processName

si votre script de débogage dans pycharm quitte toujours

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

essaye ça:

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

Voici un code plus utile (avec vérification si exactement python exécute le 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)

Voici la chaîne:

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

renvoie 0 si "grep" réussit et que le processus "python" est en cours d'exécution avec le nom de votre script comme paramètre.

Un exemple simple si vous recherchez uniquement un nom de processus existe ou non:

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

Considérez l'exemple suivant pour résoudre votre problème:

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

Je suggère ce script car il ne peut être exécuté qu'une seule fois.

Utilisation de bash pour rechercher un processus avec le nom du script actuel. Aucun fichier supplémentaire.

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

Pour tester, ajoutez

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

C'est ce que j'utilise sous Linux pour éviter de démarrer un script s'il est déjà en cours d'exécution:

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

Cette approche fonctionne bien sans aucune dépendance à un module externe.