Python模块整理(六)：守护进程

qazxsw1

　　守护进程三个特征：在后台运行，与启动它的进程脱离，无须控制终端。
　　>>> def run(program, *args):
　　...     pid = os.fork()
　　...     if pid==0:#pid==0为在子进程内 在子进程内，执行（等同于 not pid （not 0)）
　　...             os.execvp(program, (program,) +  args)
　　...     return os.wait()
　　...
　　>>> run("python", "hello.py")
　　(1874, 0)
　　关于fork函数:pid=os.fork()
　　fork函数在子进程中返回0(这个进程首先从fork返回值),在父进程中返回一个非0的进程标识符(子进程的PID ).
　　也就是说, 只有当我们在父进程的时候.(即在子进程中pid为0，pid==0为真，在父进行中not pid(not 0)/pid>0 为真)
　　编写一个daemonizer函数，写成模块里的函数，可以让多个程序使用，如果和daemon里面包了程序，那么只能为特定程序使用
　　#!/usr/bin/env python
　　import sys,os
　　def daemonizer(stdin='/dev/null',stdout='/dev/null',stderr='/dev/null')
　　#perform first fork
　　try:
　　pid=os.fork()
　　if pid>0: #在父进行中，子进行的PID>0，退出父进程，第二个特性:与启动它的进程脱离
　　sys.exit(0)
　　except OSError,e:
　　sys.stderr.write("fork #1 faild:(%d) %s\n" % (e.errno,e.strerror))
　　sys.exit(1)
　　#decouple from parent environment #分离启动进程的环境变量，开始设置自己的环境变
　　os.chdir("/")  #将守护进程放到总是存在目录中。
　　os.umask(0)    #修改文件模式，让进程有最大权限，保证进程有读写执行权限，这个不是一个好的方法。
　　os.setsid()       #该方法做一系列的事：首先它使得该进程成为一个新会话的领导者，接下来它将进程转变一个新进程组的领导者
　　#最后该进程不再控制终端 #守护进程的第三个特定：无须控制终端。
　　#perform second fork #第一个fork和setsid为第二个fork设置环境。第二个fork不是必须的。
　　try:
　　pid=os.fork()
　　if pid>0:
　　sys.exit(0)
　　except OSError,e:
　　sys.stderr.write("fork #2 faild:(%d) %s\n" % (e.errno,e.strerror))
　　sys.exit(1)
　　#The process is now daemonized,redirect standard file descriptors.
　　for f in sys.stdout,sys.stderr:f.flush()
　　si=file(stdin,"r")
　　so=file(stdout,"a+")
　　se=file(stderr,"a+",0)
　　os.dup2(si.fileno(),sys.stdin.fileno())
　　os.dup2(so.fileno(),sys.stdout.fileno())
　　os.dup2(se.fileno(),sys.stderr.fileno())
　　使用daemonizer函数
　　# ee mod_5_watcher
　　#!/usr/bin/env python
　　import sys,time
　　from daemonizer import daemonizer
　　def mod_5_watcher():
　　start_time=time.time()
　　end_time=start_time()+20
　　while time.time() < end_time:
　　now=time.time()
　　if int(now)%5 ==0:
　　sys.stderr.write(&quot;MOD 5 at %s\n&quot; % now)
　　else:
　　sys.stdout.write(&quot;No mod 5 at %s\n&quot; % now)
　　time.sleep(1)
　　if __name__==&quot;__main__&quot;:
　　daemonizer(stdout='/tmp/stdout.log',stderr='/tmp/stderr.log')
　　mod_5_watcher()
　　# cat /tmp/stderr.log
　　# cat /tmp/stdout.log
　　其他网友写的
　　http://blog.csdn.net/snleo/article/details/4410305
　　import sys, os
　　def main():
　　&quot;&quot;&quot; A demo daemon main routine, write a datestamp to
　　/tmp/daemon-log every 10 seconds.
　　&quot;&quot;&quot;
　　import time
　　f = open(&quot;/tmp/daemon-log&quot;, &quot;w&quot;)
　　while 1:
　　f.write('%s/n' % time.ctime(time.time()))
　　f.flush()
　　time.sleep(10)
　　if __name__ == &quot;__main__&quot;:
　　# do the UNIX double-fork magic, see Stevens' &quot;Advanced
　　# Programming in the UNIX Environment&quot; for details (ISBN 0201563177)
　　try:
　　pid = os.fork()
　　if pid > 0:
　　# exit first parent
　　sys.exit(0)
　　except OSError, e:
　　print >>sys.stderr, &quot;fork #1 failed: %d (%s)&quot; % (e.errno, e.strerror)
　　sys.exit(1)
　　# decouple from parent environment
　　os.chdir(&quot;/&quot;)
　　os.setsid()
　　os.umask(0)
　　# do second fork
　　try:
　　pid = os.fork()
　　if pid > 0:
　　# exit from second parent, print eventual PID before
　　print &quot;Daemon PID %d&quot; % pid
　　sys.exit(0)
　　except OSError, e:
　　print >>sys.stderr, &quot;fork #2 failed: %d (%s)&quot; % (e.errno, e.strerror)
　　sys.exit(1)
　　# start the daemon main loop
　　main()
　　以上代码中main()函数包括了一个永久循环过程：把时间戳写入一个文件。
　　运行的时候，建立一个进程，linux会分配个进程号。然后调用os.fork()创建子进程。若pid>0就是自己，自杀。子进程跳过if语句，通过os.setsid()成为linux中的独立于终端的进程（不响应sigint，sighup等）。
　　第二次os.fork再创建一个子进程，自己自杀。原因是os.setsid()后成为父进程，虽然已经不被动响应信号，但访问终端文件时控制权还是会失去。这次创建的进程真的是孤魂野鬼的daemon，并且外界对它影响被控制在最小。
　　更多可参考http://my.oschina.net/tenking/blog/29520