Python实现Linux下守护进程的编写方法

# Core modules 
importatexit 
importos 
importsys 
importtime 
importsignal 
classDaemon(object): 
  """ 
A generic daemon class. 
Usage: subclass the Daemon class and override the run() method 
""" 
  def __init__(self, pidfile, stdin=os.devnull, 
         stdout=os.devnull, stderr=os.devnull, 
         home_dir='.', umask=022, verbose=1): 
    self.stdin = stdin 
    self.stdout = stdout 
    self.stderr = stderr 
    self.pidfile = pidfile 
    self.home_dir = home_dir 
    self.verbose = verbose 
    self.umask = umask 
    self.daemon_alive = True 
  def daemonize(self): 
    """ 
Do the UNIX double-fork magic, see Stevens' "Advanced 
Programming in the UNIX Environment" for details (ISBN 0201563177) 
""" 
    try: 
      pid = os.fork() 
      if pid > 0: 
        # Exit first parent 
        sys.exit(0) 
    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(self.home_dir) 
    os.setsid() 
    os.umask(self.umask) 
    # 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) 
    if sys.platform != 'darwin': # This block breaks on OS X 
      # Redirect standard file descriptors 
      sys.stdout.flush() 
      sys.stderr.flush() 
      si = file(self.stdin, 'r') 
      so = file(self.stdout, 'a+') 
      if self.stderr: 
        se = file(self.stderr, 'a+', 0) 
      else: 
        se = so 
      os.dup2(si.fileno(), sys.stdin.fileno()) 
      os.dup2(so.fileno(), sys.stdout.fileno()) 
      os.dup2(se.fileno(), sys.stderr.fileno()) 
    def sigtermhandler(signum, frame): 
      self.daemon_alive = False 
      signal.signal(signal.SIGTERM, sigtermhandler) 
      signal.signal(signal.SIGINT, sigtermhandler) 
    if self.verbose >= 1: 
      print "Started" 
    # Write pidfile 
    atexit.register( 
      self.delpid) # Make sure pid file is removed if we quit 
    pid = str(os.getpid()) 
    file(self.pidfile, 'w+').write("%s\n" % pid) 
  def delpid(self): 
    os.remove(self.pidfile) 
  def start(self, *args, **kwargs): 
    """ 
Start the daemon 
""" 
    if self.verbose >= 1: 
      print "Starting..." 
    # Check for a pidfile to see if the daemon already runs 
    try: 
      pf = file(self.pidfile, 'r') 
      pid = int(pf.read().strip()) 
      pf.close() 
    except IOError: 
      pid = None 
    except SystemExit: 
      pid = None 
    if pid: 
      message = "pidfile %s already exists. Is it already running" 
      sys.stderr.write(message % self.pidfile) 
      sys.exit(1) 
    # Start the daemon 
    self.daemonize() 
    self.run(*args, **kwargs) 
  def stop(self): 
    """ 
Stop the daemon 
""" 
    if self.verbose >= 1: 
      print "Stopping..." 
    # Get the pid from the pidfile 
    pid = self.get_pid() 
    if not pid: 
      message = "pidfile %s does not exist. Not running" 
      sys.stderr.write(message % self.pidfile) 
      # Just to be sure. A ValueError might occur if the PID file is 
      # empty but does actually exist 
      if os.path.exists(self.pidfile): 
        os.remove(self.pidfile) 
      return # Not an error in a restart 
    # Try killing the daemon process 
    try: 
      i = 0 
      while 1: 
        os.kill(pid, signal.SIGTERM) 
        time.sleep(0.1) 
        i = i + 1 
        if i % 10 == 0: 
          os.kill(pid, signal.SIGHUP) 
    except OSError, err: 
      err = str(err) 
      if err.find("No such process") > 0: 
        if os.path.exists(self.pidfile): 
          os.remove(self.pidfile) 
      else: 
        print str(err) 
        sys.exit(1) 
    if self.verbose >= 1: 
      print "Stopped" 
  def restart(self): 
    """ 
Restart the daemon 
""" 
    self.stop() 
    self.start() 
  def get_pid(self): 
    try: 
      pf = file(self.pidfile, 'r') 
      pid = int(pf.read().strip()) 
      pf.close() 
    except IOError: 
      pid = None 
    except SystemExit: 
      pid = None 
    return pid 
  def is_running(self): 
    pid = self.get_pid() 
    print(pid) 
    return pid and os.path.exists('/proc/%d' % pid) 
  def run(self): 
    """ 
You should override this method when you subclass Daemon. 
It will be called after the process has been 
daemonized by start() or restart(). 
"""