Kiểm tra xem tập lệnh python có đang chạy không

Tôi có một trình nền python đang chạy như một phần của ứng dụng web của tôi / Làm cách nào để kiểm tra nhanh (bằng cách sử dụng python) nếu daemon của tôi đang chạy và khởi chạy nó nếu không?

Tôi muốn làm theo cách đó để khắc phục mọi sự cố của daemon và do đó, tập lệnh không phải chạy theo cách thủ công, nó sẽ tự động chạy ngay sau khi nó được gọi và sau đó tiếp tục chạy.

Làm cách nào để kiểm tra (sử dụng python) nếu tập lệnh của tôi đang chạy?

Thả một pidfile ở đâu đó (ví dụ / tmp). Sau đó, bạn có thể kiểm tra xem quá trình có đang chạy hay không bằng cách kiểm tra xem PID trong tệp có tồn tại hay không. Đừng quên xóa tệp khi bạn tắt hoàn toàn và kiểm tra nó khi bạn khởi động.

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

Sau đó, bạn có thể kiểm tra xem quy trình có đang chạy hay không bằng cách kiểm tra xem nội dung của /tmp/mydaemon.pid có phải là quy trình hiện có hay không. Monit (đã đề cập ở trên) có thể làm điều này cho bạn hoặc bạn có thể viết một tập lệnh shell đơn giản để kiểm tra nó cho bạn bằng cách sử dụng mã trả về từ ps.

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

Để có thêm tín dụng, bạn có thể sử dụng mô-đun atexit để đảm bảo rằng chương trình của bạn xóa sạch tệp pidfile của nó trong bất kỳ trường hợp nào (khi bị giết, nâng cấp ngoại lệ, v.v.).

Một kỹ thuật hữu ích trên hệ thống Linux là sử dụng các ổ cắm miền:

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)

Nó là nguyên tử và tránh vấn đề có các tệp khóa nằm xung quanh nếu quy trình của bạn được gửi SIGKILL

Bạn có thể đọc trong tài liệu đểsocket.close biết rằng các ổ cắm sẽ tự động đóng khi thu gom rác.

Các pid thư viện có thể thực hiện chính xác này.

from pid import PidFile

with PidFile():
  do_something()

Nó cũng sẽ tự động xử lý trường hợp pidfile tồn tại nhưng tiến trình không chạy.

Tất nhiên ví dụ từ Dan sẽ không hoạt động như nó phải.

Thật vậy, nếu tập lệnh gặp sự cố, tăng một ngoại lệ hoặc không làm sạch tệp pid, thì tập lệnh sẽ được chạy nhiều lần.

Tôi đề xuất những điều sau dựa trên một trang web khác:

Điều này để kiểm tra xem đã có tệp khóa tồn tại chưa

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

Đây là một phần của mã nơi chúng tôi đặt tệp PID vào tệp khóa

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

Đoạn mã này sẽ kiểm tra giá trị của pid so với tiến trình đang chạy hiện có., Tránh thực thi kép.

Tôi mong nó sẽ có ích.

Có những gói rất tốt để khởi động lại quy trình trên UNIX. Một trong đó có một hướng dẫn tuyệt vời về xây dựng và cấu hình nó được monit . Với một số điều chỉnh, bạn có thể có một công nghệ đã được chứng minh vững chắc theo kịp daemon của bạn.

Giải pháp của tôi là kiểm tra các đối số quy trình và dòng lệnh Đã kiểm tra trên windows và linux ubuntu

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)

Có vô số lựa chọn. Một phương pháp là sử dụng lời gọi hệ thống hoặc thư viện python thực hiện các lệnh gọi như vậy cho bạn. Cách khác chỉ đơn giản là tạo ra một quy trình như:

ps ax | grep processName

và phân tích cú pháp đầu ra. Nhiều người chọn cách tiếp cận này, nó không hẳn là một cách tiếp cận tồi theo quan điểm của tôi.

Đi qua câu hỏi cũ này và tìm kiếm giải pháp cho chính mình.

Sử dụng 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'])

Tôi là một fan hâm mộ lớn của Supervisor để quản lý daemon. Nó được viết bằng Python, vì vậy có rất nhiều ví dụ về cách tương tác với hoặc mở rộng nó từ Python. Đối với mục đích của bạn, API điều khiển quy trình XML-RPC sẽ hoạt động tốt.

Hãy thử phiên bản khác này

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)

Thay vì phát triển giải pháp tệp PID của riêng bạn (có nhiều điểm phức tạp và các trường hợp góc cạnh hơn bạn có thể nghĩ), hãy xem xét giám sát viên - đây là một hệ thống kiểm soát quy trình giúp dễ dàng kết hợp các hành vi kiểm soát công việc và daemon xung quanh Python hiện có kịch bản.

Các câu trả lời khác là tuyệt vời cho những thứ như cron job, nhưng nếu bạn đang chạy một daemon, bạn nên theo dõi nó bằng một thứ gì đó như daemontools .

ps ax | grep processName

nếu bạn gỡ lỗi tập lệnh trong pycharm luôn thoát

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

thử cái này:

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

Đây là mã hữu ích hơn (với việc kiểm tra xem python có thực thi chính xác tập lệnh hay không):

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

Đây là chuỗi:

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

trả về 0 nếu "grep" thành công và quá trình "python" hiện đang chạy với tên tập lệnh của bạn làm tham số.

Một ví dụ đơn giản nếu bạn chỉ đang tìm kiếm một tên quy trình có tồn tại hay không:

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

Hãy xem xét ví dụ sau để giải quyết vấn đề của bạn:

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

Tôi đề xuất tập lệnh này vì nó có thể được thực thi một lần duy nhất.

Sử dụng bash để tìm kiếm tiến trình có tên tập lệnh hiện tại. Không có tệp bổ sung.

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

Để kiểm tra, hãy thêm

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

Đây là những gì tôi sử dụng trong Linux để tránh bắt đầu một tập lệnh nếu đã chạy:

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

Cách tiếp cận này hoạt động tốt mà không phụ thuộc vào mô-đun bên ngoài.