Python中无限期守护进程的产生

Question

我正在尝试构建一个启动其他完全独立进程的Python守护进程。

一般的想法是针对给定的shell命令，每隔几秒轮询一次并确保命令的k个实例正在运行。 我们保持PID文件的目录，当我们轮询我们删除PID文件，其PID是不再运行和启动（并为PID文件）然而，许多流程，我们需要让到k他们。

子进程也需要完全独立，这样如果父进程死掉，子进程就不会被杀死。 从我所看到的，似乎没有办法用subprocess模块做到这一点。 为此，我使用了这里提到的片段：

http://code.activestate.com/recipes/66012-fork-a-daemon-process-on-unix/

我做了一些必要的修改（你会在附加的代码片段中看到注释掉的行）：

1. 原始父进程无法退出，因为我们需要启动程序守护程序无限期地保留。
2. 子进程需要以与父进程相同的cwd开始。

这是我的spawn fn和测试：

import os
import sys
import subprocess
import time

def spawn(cmd, child_cwd):
    """
    do the UNIX double-fork magic, see Stevens' "Advanced 
    Programming in the UNIX Environment" for details (ISBN 0201563177)
    http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
    """
    try: 
        pid = os.fork() 
        if pid > 0:
            # exit first parent
            #sys.exit(0) # parent daemon needs to stay alive to launch more in the future
            return
    except OSError, e: 
        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
        sys.exit(1)

    # decouple from parent environment
    #os.chdir("/") # we want the children processes to 
    os.setsid() 
    os.umask(0) 

    # do second fork
    try: 
        pid = os.fork() 
        if pid > 0:
            # exit from second parent
            sys.exit(0) 
    except OSError, e: 
        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
        sys.exit(1) 

    # redirect standard file descriptors
    sys.stdout.flush()
    sys.stderr.flush()
    si = file('/dev/null', 'r')
    so = file('/dev/null', 'a+')
    se = file('/dev/null', 'a+', 0)
    os.dup2(si.fileno(), sys.stdin.fileno())
    os.dup2(so.fileno(), sys.stdout.fileno())
    os.dup2(se.fileno(), sys.stderr.fileno())

    pid = subprocess.Popen(cmd, cwd=child_cwd, shell=True).pid

    # write pidfile       
    with open('pids/%s.pid' % pid, 'w') as f: f.write(str(pid))
    sys.exit(1)

def mkdir_if_none(path):
    if not os.access(path, os.R_OK):
        os.mkdir(path)

if __name__ == '__main__':
    try:
        cmd = sys.argv[1]
        num = int(sys.argv[2])
    except:
        print 'Usage: %s <cmd> <num procs>' % __file__
        sys.exit(1)
    mkdir_if_none('pids')
    mkdir_if_none('test_cwd')

    for i in xrange(num):
        print 'spawning %d...'%i
        spawn(cmd, 'test_cwd')
        time.sleep(0.01) # give the system some breathing room

在这种情况下，事情似乎工作正常，即使父母被杀，子进程也会持续存在。 但是，我仍然遇到原始父级的生成限制。 在~650次生成（不同时，孩子们已经完成）之后，父进程会出现错误：

spawning 650...
fork #2 failed: 35 (Resource temporarily unavailable)

有没有办法重写我的spawn函数，以便我可以无限期地生成这些独立的子进程？ 谢谢！

Answer 1

感谢您的流程列表，我愿意说这是因为您遇到了许多基本限制之一：

• rlimit nproc允许给定用户执行的最大进程数 - 有关每用户进程限制的详细信息，请参阅setrlimit(2) ， bash(1) ulimit内置和/etc/security/limits.conf 。
• rlimit nofile允许给定进程一次打开的最大文件描述符数。 （每个新进程可能在父级中为子级的stdin ， stdout和stderr描述符创建三个新管道。）
• 全系统最大进程数; 请参阅/proc/sys/kernel/pid_max 。
• 系统范围内最大打开文件数; 请参阅/proc/sys/fs/file-max 。

因为你没有收获你死去的孩子，所以这些资源中的许多资源的开放时间比他们应该的要长。 你的第二个孩子正在由init(8)正确处理 - 他们的父母已经死了，所以他们被重新设为init(8) ， init(8)将在他们死后（ wait(2) ）清理。

但是，您的计划负责在第一组孩子之后进行清理。 C程序通常为SIGCHLD安装一个signal(7)处理程序，它调用wait(2)或waitpid(2)来获取子SIGCHLD的退出状态，从而从内核的内存中删除它的条目。

但脚本中的信号处理有点烦人。 如果您可以明确地将SIGCHLD信号处置设置为SIG_IGN ，则内核将知道您对退出状态不感兴趣并且将为您收集子项。

尝试添加：

import signal
signal.signal(signal.SIGCHLD, signal.SIG_IGN)

靠近程序的顶部。

请注意，我不知道Subprocess 。 它可能不高兴。 如果是这种情况，那么您需要安装一个信号处理程序来为您调用wait(2) 。

Answer 2

我稍微修改了你的代码，并且能够运行5000个进程而没有任何问题。 因此，我同意@sarnold您的一些基本限制。 我的修改是：

proc = subprocess.Popen(cmd, cwd=child_cwd, shell=True, close_fds=True)    
pid = proc.pid

# write pidfile       
with open('pids/%s.pid' % pid, 'w') as f: f.write(str(pid))
proc.wait()
sys.exit(1)