src/daemon.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Public Domain
   4 #
   5 # Copyright 2007, 2009 Sander Marechal <s.marechal@jejik.com>
   6 # Copyright 2010, 2011 Jack Kaliko <efrim@azylum.org>
   7 #
   8 # http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/
   9
  10 import atexit
  11 import os
  12 import sys
  13 import time
  14 from signal import signal, SIGTERM
  15
  16
  17 class Daemon(object):
  18     """
  19     A generic daemon class.
  20
  21     Usage: subclass the Daemon class and override the run() method
  22     """
  23     def __init__(self, pidfile,
  24             stdin='/dev/null',
  25             stdout='/dev/null',
  26             stderr='/dev/null'):
  27         self.stdin = stdin
  28         self.stdout = stdout
  29         self.stderr = stderr
  30         self.pidfile = pidfile
  31
  32     def daemonize(self):
  33         """
  34         do the UNIX double-fork magic, see Stevens' "Advanced
  35         Programming in the UNIX Environment" for details (ISBN 0201563177)
  36         http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
  37         """
  38         try:
  39             pid = os.fork()
  40             if pid > 0:
  41                 # exit first parent
  42                 sys.exit(0)
  43         except OSError, e:
  44             sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
  45             sys.exit(1)
  46
  47         # Decouple from parent environment
  48         os.chdir("/")
  49         os.setsid()
  50         os.umask(0)
  51
  52         # Do second fork
  53         try:
  54             pid = os.fork()
  55             if pid > 0:
  56                 # exit from second parent
  57                 sys.exit(0)
  58         except OSError, e:
  59             sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
  60             sys.exit(1)
  61
  62         self.write_pid()
  63         # redirect standard file descriptors
  64         sys.stdout.flush()
  65         sys.stderr.flush()
  66         si = file(self.stdin, 'r')
  67         so = file(self.stdout, 'a+')
  68         se = file(self.stderr, 'a+', 0)
  69         os.dup2(si.fileno(), sys.stdin.fileno())
  70         os.dup2(so.fileno(), sys.stdout.fileno())
  71         os.dup2(se.fileno(), sys.stderr.fileno())
  72
  73         atexit.register(self.shutdown)
  74         self.signal_management()
  75
  76     def write_pid(self):
  77         # write pidfile
  78         if not self.pidfile:
  79             return
  80         pid = str(os.getpid())
  81         try:
  82             file(self.pidfile, 'w').write('%s\n' % pid)
  83             #except IOError, wpid_err:
  84         except Exception, wpid_err:
  85             sys.stderr.write(u'Error trying to write pid file to %s: %s\n' %
  86                    (unicode(self.pidfile, 'utf-8'), wpid_err))
  87             sys.exit(1)
  88         atexit.register(self.delpid)
  89
  90     def signal_management(self):
  91         # Declare signal handlers
  92         signal(SIGTERM, self.exit_handler)
  93
  94     def exit_handler(self, signum, frame):
  95         sys.exit(1)
  96
  97     def delpid(self):
  98         os.remove(self.pidfile)
  99
 100     def start(self):
 101         """
 102         Start the daemon
 103         """
 104         # Check for a pidfile to see if the daemon already runs
 105         try:
 106             pf = file(self.pidfile, 'r')
 107             pid = int(pf.read().strip())
 108             pf.close()
 109         except IOError:
 110             pid = None
 111
 112         if pid:
 113             message = "pidfile %s already exist. Daemon already running?\n"
 114             sys.stderr.write(message % self.pidfile)
 115             sys.exit(1)
 116
 117         # Start the daemon
 118         self.daemonize()
 119         self.run()
 120
 121     def foreground(self):
 122         """
 123         Foreground/debug mode
 124         """
 125         self.write_pid()
 126         atexit.register(self.shutdown)
 127         self.run()
 128
 129     def stop(self):
 130         """
 131         Stop the daemon
 132         """
 133         # Get the pid from the pidfile
 134         try:
 135             pf = file(self.pidfile, 'r')
 136             pid = int(pf.read().strip())
 137             pf.close()
 138         except IOError:
 139             pid = None
 140
 141         if not pid:
 142             message = "pidfile %s does not exist. Daemon not running?\n"
 143             sys.stderr.write(message % self.pidfile)
 144             return  # not an error in a restart
 145
 146         # Try killing the daemon process
 147         try:
 148             os.kill(pid, SIGTERM)
 149             time.sleep(0.1)
 150         except OSError, err:
 151             err = str(err)
 152             if err.find("No such process") > 0:
 153                 if os.path.exists(self.pidfile):
 154                     message = "Daemon not running? removing pid file %s.\n"
 155                     sys.stderr.write(message % self.pidfile)
 156                     os.remove(self.pidfile)
 157             else:
 158                 print str(err)
 159                 sys.exit(1)
 160
 161     def restart(self):
 162         """
 163         Restart the daemon
 164         """
 165         self.stop()
 166         self.start()
 167
 168     def shutdown(self):
 169         """
 170         You should override this method when you subclass Daemon. It will be
 171         called when the process is being stopped.
 172         Pay attention:
 173         Daemon() uses atexit to call Daemon().shutdown(), as a consequence
 174         shutdown and any other functions registered via this module are not
 175         called when the program is killed by an un-handled/unknown signal.
 176         This is the reason of Daemon().signal_management() existence.
 177         """
 178
 179     def run(self):
 180         """
 181         You should override this method when you subclass Daemon. It will be
 182         called after the process has been daemonized by start() or restart().
 183         """
 184
 185
 186 def main():
 187     pass
 188
 189 # Script starts here
 190 if __name__ == '__main__':
 191     main()
 192
 193 # VIM MODLINE
 194 # vim: ai ts=4 sw=4 sts=4 expandtab