Python 스크립트가 실행 중인지 확인하십시오.

웹 앱의 일부로 파이썬 데몬을 실행하고 있습니다 / 데몬이 실행 중인지 (파이썬 사용) 빠르게 확인하고 그렇지 않은 경우 시작하려면 어떻게해야합니까?

데몬의 크래시를 수정하기 위해 그렇게하고 싶습니다. 그래서 스크립트를 수동으로 실행할 필요가 없으며, 호출되는 즉시 자동으로 실행 된 다음 계속 실행됩니다.

내 스크립트가 실행 중인지 어떻게 확인할 수 있습니까 (python 사용)?

어딘가에 pidfile을 놓으십시오 (예 : / tmp). 그런 다음 파일에 PID가 있는지 확인하여 프로세스가 실행 중인지 확인할 수 있습니다. 완전히 종료 할 때 파일을 삭제하는 것을 잊지 말고 시작할 때 확인하십시오.

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

그런 다음 /tmp/mydaemon.pid의 내용이 기존 프로세스인지 확인하여 프로세스가 실행 중인지 확인할 수 있습니다. Monit (위에 언급 됨)이이를 수행하거나 ps의 리턴 코드를 사용하여이를 확인하는 간단한 쉘 스크립트를 작성할 수 있습니다.

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

추가 신용을 얻으려면 atexit 모듈을 사용하여 프로그램이 어떤 상황 (죽었을 때, 예외 발생 등)에서도 pidfile을 정리하도록 할 수 있습니다.

Linux 시스템에서 편리한 기술은 도메인 소켓을 사용하는 것입니다.

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)

그것은 원자 적이며 프로세스가 SIGKILL을 보내면 잠금 파일이 주변에 놓이는 문제를 피합니다.

당신은 수 의 문서를 읽어socket.close 쓰레기 수집 때 소켓이 자동으로 닫힙니다.

PID 라이브러리는 정확히이 작업을 수행 할 수 있습니다.

from pid import PidFile

with PidFile():
  do_something()

또한 pidfile이 존재하지만 프로세스가 실행되지 않는 경우를 자동으로 처리합니다.

물론 Dan의 예는 제대로 작동하지 않습니다.

실제로 스크립트가 충돌하거나 예외가 발생하거나 pid 파일을 정리하지 않으면 스크립트가 여러 번 실행됩니다.

다른 웹 사이트에서 다음을 제안합니다.

잠금 파일이 이미 존재하는지 확인하는 것입니다.

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

이것은 잠금 파일에 PID 파일을 넣는 코드의 일부입니다.

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

이 코드는 기존 실행 프로세스와 비교하여 pid 값을 확인하여 이중 실행을 방지합니다.

도움이 되길 바랍니다.

UNIX에서 프로세스를 다시 시작하기위한 아주 좋은 패키지가 있습니다. 빌드 및 구성에 대한 훌륭한 튜토리얼이있는 것은 monit 입니다. 약간의 조정으로 데몬을 유지하는 견고한 입증 된 기술을 가질 수 있습니다.

내 해결책은 Windows 및 우분투 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)

무수히 많은 옵션이 있습니다. 한 가지 방법은 이러한 호출을 수행하는 시스템 호출 또는 Python 라이브러리를 사용하는 것입니다. 다른 하나는 다음과 같은 프로세스를 생성하는 것입니다.

ps ax | grep processName

출력을 구문 분석하십시오. 많은 사람들이이 접근 방식을 선택하지만 제 생각에는 반드시 나쁜 접근 방식은 아닙니다.

해결책을 찾기 위해이 오래된 질문을 보았습니다.

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

나는 데몬을 관리하는 Supervisor 의 열렬한 팬입니다 . Python으로 작성되었으므로 Python과 상호 작용하거나 Python에서 확장하는 방법에 대한 많은 예가 있습니다. 귀하의 목적을 위해 XML-RPC 프로세스 제어 API 는 잘 작동해야합니다.

이 다른 버전 시도

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)

자신의 PID 파일 솔루션 (생각할 수있는 것보다 더 미묘한 경우가 많음)을 개발하는 대신 supervisord를 살펴보십시오. 이것은 기존 Python 주위에 작업 제어 및 데몬 동작을 쉽게 래핑 할 수있는 프로세스 제어 시스템입니다. 스크립트.

다른 답변은 cron 작업과 같은 작업에 적합하지만 데몬을 실행하는 경우 daemontools 와 같은 것으로 모니터링해야합니다 .

ps ax | grep processName

pycharm의 yor 디버그 스크립트가 항상 종료되면

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

이 시도:

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

다음은 더 유용한 코드입니다 (정확히 python이 스크립트를 실행하는지 확인).

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

다음은 문자열입니다.

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

"grep"이 성공하고 "python"프로세스가 현재 스크립트 이름을 매개 변수로 사용하여 실행 중이면 0을 반환합니다.

프로세스 이름이 존재하는지 여부 만 찾는 경우 간단한 예 :

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

문제를 해결하려면 다음 예를 고려하십시오.

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

이 스크립트는 한 번만 실행할 수 있기 때문에 제안합니다.

bash를 사용하여 현재 스크립트 이름으로 프로세스를 찾습니다. 추가 파일이 없습니다.

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

테스트하려면

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

이것은 이미 실행중인 경우 스크립트를 시작하지 않기 위해 Linux에서 사용하는 것입니다.

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

이 접근 방식은 외부 모듈에 대한 종속성없이 잘 작동합니다.