Periksa untuk melihat apakah skrip python sedang berjalan

Saya memiliki daemon python yang berjalan sebagai bagian dari aplikasi web saya / Bagaimana saya dapat dengan cepat memeriksa (menggunakan python) apakah daemon saya sedang berjalan dan, jika tidak, meluncurkannya?

Saya ingin melakukannya dengan cara itu untuk memperbaiki error apa pun pada daemon, sehingga skrip tidak harus dijalankan secara manual, skrip akan berjalan secara otomatis segera setelah dipanggil dan kemudian tetap berjalan.

Bagaimana cara memeriksa (menggunakan python) jika skrip saya berjalan?

Jatuhkan pidfile di suatu tempat (misalnya / tmp). Kemudian Anda dapat memeriksa untuk melihat apakah proses sedang berjalan dengan memeriksa apakah PID dalam file tersebut ada. Jangan lupa untuk menghapus file saat Anda mematikannya dengan bersih, dan periksa saat Anda memulai.

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

Kemudian Anda dapat memeriksa apakah proses sedang berjalan dengan memeriksa apakah konten /tmp/mydaemon.pid adalah proses yang sudah ada. Monit (disebutkan di atas) dapat melakukan ini untuk Anda, atau Anda dapat menulis skrip shell sederhana untuk memeriksanya menggunakan kode pengembalian dari ps.

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

Untuk kredit tambahan, Anda dapat menggunakan modul atexit untuk memastikan bahwa program Anda membersihkan pidfile-nya dalam keadaan apa pun (saat dimatikan, pengecualian dimunculkan, dll.).

Sebuah teknik yang berguna pada sistem Linux menggunakan soket domain:

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)

Ini adalah atom dan menghindari masalah memiliki file kunci tergeletak di sekitar jika proses Anda dikirim SIGKILL

Anda dapat membaca di dokumentasi untuksocket.close soket itu secara otomatis ditutup saat sampah dikumpulkan.

The pid perpustakaan dapat melakukan hal ini.

from pid import PidFile

with PidFile():
  do_something()

Ini juga akan secara otomatis menangani kasus di mana pidfile ada tetapi prosesnya tidak berjalan.

Tentu saja contoh dari Dan tidak akan berfungsi sebagaimana mestinya.

Memang jika script crash, memunculkan eksepsi, atau tidak membersihkan file pid, script tersebut akan dijalankan berkali-kali.

Saya menyarankan yang berikut ini berdasarkan dari situs web lain:

Ini untuk memeriksa apakah sudah ada file kunci

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

Ini adalah bagian dari kode tempat kami meletakkan file PID di file kunci

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

Kode ini akan memeriksa nilai pid dibandingkan dengan proses yang sedang berjalan, menghindari eksekusi ganda.

Saya harap ini akan membantu.

Ada paket yang sangat bagus untuk memulai ulang proses di UNIX. Salah satu yang memiliki tutorial bagus tentang membangun dan mengonfigurasinya adalah monit . Dengan beberapa tweaking Anda dapat memiliki teknologi yang terbukti kokoh menjaga daemon Anda.

Solusi saya adalah memeriksa proses dan argumen baris perintah Diuji pada windows dan 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)

Ada banyak sekali pilihan. Salah satu metode adalah menggunakan panggilan sistem atau pustaka python yang melakukan panggilan seperti itu untuk Anda. Cara lainnya adalah dengan menghasilkan proses seperti:

ps ax | grep processName

dan parsing hasilnya. Banyak orang memilih pendekatan ini, menurut saya pendekatan ini tidak selalu buruk.

Menemukan sendiri pertanyaan lama ini mencari solusi.

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

Saya penggemar berat Supervisor untuk mengelola daemon. Ini ditulis dengan Python, jadi ada banyak contoh bagaimana berinteraksi dengan atau memperluasnya dari Python. Untuk tujuan Anda, API kontrol proses XML-RPC harus bekerja dengan baik.

Coba versi lain ini

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)

Daripada mengembangkan solusi file PID Anda sendiri (yang memiliki lebih banyak kehalusan dan kasus sudut daripada yang Anda kira), lihat supervisord - ini adalah sistem kontrol proses yang memudahkan untuk membungkus kontrol pekerjaan dan perilaku daemon di sekitar Python yang ada naskah.

Jawaban lainnya bagus untuk hal-hal seperti cron job, tetapi jika Anda menjalankan daemon, Anda harus memantaunya dengan sesuatu seperti daemontools .

ps ax | grep processName

jika skrip debug Anda di pycharm selalu keluar

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

coba ini:

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

Berikut adalah kode yang lebih berguna (dengan memeriksa apakah sebenarnya python mengeksekusi skrip):

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

Ini stringnya:

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

mengembalikan 0 jika "grep" berhasil, dan proses "python" sedang berjalan dengan nama skrip Anda sebagai parameter.

Contoh sederhana jika Anda hanya mencari nama proses ada atau tidak:

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

Pertimbangkan contoh berikut untuk menyelesaikan masalah Anda:

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

Saya menyarankan skrip ini karena hanya dapat dijalankan satu kali.

Menggunakan bash untuk mencari proses dengan nama skrip saat ini. Tidak ada file tambahan.

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

Untuk menguji, tambahkan

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

Inilah yang saya gunakan di Linux untuk menghindari memulai skrip jika sudah berjalan:

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

Pendekatan ini bekerja dengan baik tanpa ketergantungan pada modul eksternal.