Überprüfen Sie, ob das Python-Skript ausgeführt wird

Drop ein pidfile irgendwo (z.B. /tmp). Dann können Sie überprüfen, um zu sehen, ob der Prozess ausgeführt wird überprüfen, um zu sehen, ob die PID in der Datei vorhanden ist. Vergessen Sie nicht, um die Datei zu löschen, wenn Sie sauber heruntergefahren werden, und überprüfen Sie es, wenn Sie starten.

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

Dann können Sie überprüfen, um zu sehen, ob der Prozess ausgeführt wird überprüfen, um zu sehen, ob der Inhalt von /tmp/mydaemon.pid sind ein bestehender Prozess. Monit (oben erwähnt), kann dies für Sie tun, oder Sie können schreiben, ein einfaches shell-Skript, um zu überprüfen es für Sie mit der return-code von ps.

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

Für zusätzliche Kredite, die Sie verwenden können, die atexit-Modul, um sicherzustellen, dass Ihr Programm säubert seine PID-Datei unter keinen Umständen (wenn Sie getötet werden, Ausnahmen, etc.).

InformationsquelleAutor der Antwort Dan Udey

Den pid Bibliothek kann genau das tun.

from pid import PidFile

with PidFile():
  do_something()

Wird es automatisch auch den Fall behandeln, wo die PID-Datei existiert, aber der Prozess wird nicht ausgeführt.

InformationsquelleAutor der Antwort Decko

Natürlich das Beispiel von Dan wird nicht so funktionieren, wie es sein sollte.

In der Tat, wenn das Skript zum Absturz, steigen eine Ausnahme, oder nicht sauber pid-Datei, wird das Skript mehrmals ausgeführt werden.

Schlage ich die folgenden basierend auf einer anderen website:

Dies ist zu überprüfen, ob bereits eine lock-Datei vorhandenen

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

Dies ist Teil des Codes, wo wir eine PID-Datei in die lock-Datei

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

Dieser code prüft den Wert von pid im Vergleich zu den bisherigen Laufenden Prozess., vermeiden doppelter Ausführung.

Ich hoffe, es wird helfen.

InformationsquelleAutor der Antwort Shylock

Gibt es eine Vielzahl von Optionen. Eine Methode ist die Verwendung von Systemaufrufen oder python-Bibliotheken, die Durchführung solcher Anrufe für Sie. Der andere ist einfach zu laichen, ein Verfahren, wie:

ps ax | grep processName

und analysieren Sie die Ausgabe. Viele Menschen wählen diesen Ansatz, es ist nicht unbedingt ein schlechter Ansatz in meinen Augen.

InformationsquelleAutor der Antwort BobbyShaftoe

Die anderen Antworten sind ideal für Dinge wie cron-jobs, aber wenn Sie läuft ein daemon, sollten Sie überwachen Sie mit so etwas wie daemontools.

InformationsquelleAutor der Antwort bobpoekert

Anstatt die Entwicklung Ihrer eigenen PID-Datei-Lösung (die hat mehr Feinheiten und Ecken Fällen, als Sie vielleicht denken), haben Sie einen Blick auf supervisord -- dies ist ein Prozess-Kontroll-system macht es leicht zu wickeln job-Steuerung und daemon Verhaltensweisen rund um eine vorhandene Python-Skript.

InformationsquelleAutor der Antwort Chris Johnson

Hier gibt es noch weitere nützliche code (mit Prüfung ob genau python führt das Skript):

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

Hier ist string:

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

gibt 0 zurück, wenn "grep" erfolgreich ist, und der Prozess "python" ist derzeit mit dem Namen des Skripts als parameter .

InformationsquelleAutor der Antwort Dmitry Allyanov

Bin auf diese alte Frage sucht Lösung für mich.

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

InformationsquelleAutor der Antwort NST

Betrachten Sie das folgende Beispiel, um Ihr problem zu lösen:

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

Schlage ich vor, dieses script, weil es sein kann, genau ein mal ausgeführt.

InformationsquelleAutor der Antwort edisonex