[Python]一个简单的守护进程

mystérieux

                                                                import os
import sys
def create_daemon():
        pid = os.fork()  
  if pid == 0:
    os.setsid()
    if pid == 0:
      os.chdir('/usr/python/daemon')
      os.umask(0)  
    else:
      os._exit(0)
  else:
    os._exit(0)
if __name__ == "__main__"
  create_daemon()
    ...               
               
               
               
               
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u1/43271/showart_387216.html

wmjie

1. 
   
2. '''
   
3.     This module is used to fork the current process into a daemon.
   
4.     Almost none of this is necessary (or advisable) if your daemon
   
5.     is being started by inetd. In that case, stdin, stdout and stderr are
   
6.     all set up for you to refer to the network connection, and the fork()s
   
7.     and session manipulation should not be done (to avoid confusing inetd).
   
8.     Only the chdir() and umask() steps remain as useful.
   
9.     References:
   
10.         UNIX Programming FAQ
    
11.             1.7 How do I get my program to act like a daemon?
    
12.                 [url]http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16[/url]
    
13.         Advanced Programming in the Unix Environment
    
14.             W. Richard Stevens, 1992, Addison-Wesley, ISBN 0-201-56317-7.
    
15. 
    
16.     History:
    
17.       2001/07/10 by Juergen Hermann
    
18.       2002/08/28 by Noah Spurrier
    
19.       2003/02/24 by Clark Evans
    
20.       2003/11/01 by Irmen de Jong --- adapted a bit for Snakelets
    
21.                                     (raises exception at certain points)
    
22.       
    
23.       [url]http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66012[/url]
    
24. '''
    
25. import sys, os, time
    
26. from signal import SIGINT,SIGTERM,SIGKILL
    
27. 
    
28. def daemonize(stdout='/dev/null', stderr=None, stdin='/dev/null',
    
29.               pidfile=None, startmsg = 'started with pid %s' ):
    
30.     '''
    
31.         This forks the current process into a daemon.
    
32.         The stdin, stdout, and stderr arguments are file names that
    
33.         will be opened and be used to replace the standard file descriptors
    
34.         in sys.stdin, sys.stdout, and sys.stderr.
    
35.         These arguments are optional and default to /dev/null.
    
36.         Note that stderr is opened unbuffered, so
    
37.         if it shares a file with stdout then interleaved output
    
38.         may not appear in the order that you expect.
    
39.     '''
    
40. 
    
41.     # flush io
    
42.     sys.stdout.flush()
    
43.     sys.stderr.flush()
    
44. 
    
45.     # Do first fork.
    
46.     try:
    
47.         pid = os.fork()
    
48.         if pid > 0: sys.exit(0) # Exit first parent.
    
49.     except OSError, e:
    
50.         sys.stderr.write("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror))
    
51.         sys.exit(1)
    
52.         
    
53.     # Decouple from parent environment.
    
54.     os.chdir("/")
    
55.     os.umask(0)
    
56.     os.setsid()
    
57.    
    
58.     # Do second fork.
    
59.     try:
    
60.         pid = os.fork()
    
61.         if pid > 0: sys.exit(0) # Exit second parent.
    
62.     except OSError, e:
    
63.         sys.stderr.write("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror))
    
64.         sys.exit(1)
    
65.    
    
66.     # Open file descriptors and print start message
    
67.     if not stderr: stderr = stdout
    
68.     si = file(stdin, 'r')
    
69.     so = file(stdout, 'a+')
    
70.     se = file(stderr, 'a+', 0)  #unbuffered
    
71.     pid = str(os.getpid())
    
72.     sys.stderr.write("\n%s\n" % startmsg % pid)
    
73.     sys.stderr.flush()
    
74.     if pidfile: file(pidfile,'w+').write("%s\n" % pid)
    
75.    
    
76.     # Redirect standard file descriptors.
    
77.     os.dup2(si.fileno(), sys.stdin.fileno())
    
78.     os.dup2(so.fileno(), sys.stdout.fileno())
    
79.     os.dup2(se.fileno(), sys.stderr.fileno())
    
80. 
    
81. 
    
82. class DaemonizeError(Exception): pass
    
83. 
    
84. 
    
85. def startstop(stdout='/dev/null', stderr=None, stdin='/dev/null',
    
86.               pidfile='pid.txt', startmsg = 'started with pid %s', action=None ):
    
87.               
    
88.     if not action and len(sys.argv) > 1:
    
89.         action = sys.argv[1]
    
90. 
    
91.     if action:
    
92.         try:
    
93.             pf  = file(pidfile,'r')
    
94.             pid = int(pf.read().strip())
    
95.             pf.close()
    
96.         except IOError:
    
97.             pid = None
    
98.         if 'stop' == action or 'restart' == action:
    
99.             if not pid:
    
100.                 mess = "Could not stop, pid file '%s' missing.\n"
     
101.                 raise DaemonizeError(mess % pidfile)
     
102.             try:
     
103.                while 1:
     
104.                    print "sending SIGINT to",pid
     
105.                    os.kill(pid,SIGINT)
     
106.                    time.sleep(2)
     
107.                    print "sending SIGTERM to",pid
     
108.                    os.kill(pid,SIGTERM)
     
109.                    time.sleep(2)
     
110.                    print "sending SIGKILL to",pid
     
111.                    os.kill(pid,SIGKILL)
     
112.                    time.sleep(1)
     
113.             except OSError, err:
     
114.                print "process has been terminated."
     
115.                os.remove(pidfile)
     
116.                if 'stop' == action:
     
117.                    return    ## sys.exit(0)
     
118.                action = 'start'
     
119.                pid = None
     
120.         if 'start' == action:
     
121.             if pid:
     
122.                 mess = "Start aborted since pid file '%s' exists. Server still running?\n"
     
123.                 raise DaemonizeError(mess % pidfile)
     
124.             daemonize(stdout,stderr,stdin,pidfile,startmsg)
     
125.             return
     
126.     print "usage: %s start|stop|restart" % sys.argv[0]
     
127.     raise DaemonizeError("invalid command")
     
128. 
     
129. def test():
     
130.     '''
     
131.         This is an example main function run by the daemon.
     
132.         This prints a count and timestamp once per second.
     
133.     '''
     
134.     sys.stdout.write ('Message to stdout...')
     
135.     sys.stderr.write ('Message to stderr...')
     
136.     c = 0
     
137.     while 1:
     
138.         sys.stdout.write ('%d: %s\n' % (c, time.ctime(time.time())) )
     
139.         sys.stdout.flush()
     
140.         c = c + 1
     
141.         time.sleep(1)
     
142. 
     
143. if __name__ == "__main__":
     
144.     startstop(stdout='/tmp/daemonize.log',
     
145.               pidfile='/tmp/daemonize.pid')
     
146.     if sys.argv[1]in ('start', 'restart'):
     
147.         test()

复制代码