From 5ccfc6d3e18ead1c13109af66befcd7a56d85d93 Mon Sep 17 00:00:00 2001 From: Efrim Date: Mon, 31 Jan 2011 10:53:56 +0100 Subject: [PATCH 1/1] Initial import --- src/daemon.py | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 src/daemon.py diff --git a/src/daemon.py b/src/daemon.py new file mode 100644 index 0000000..787cb65 --- /dev/null +++ b/src/daemon.py @@ -0,0 +1,194 @@ +# -*- coding: utf-8 -*- + +# Public Domain +# +# Copyright 2007, 2009 Sander Marechal +# Copyright 2010, 2011 Jack Kaliko +# +# http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/ + +import atexit +import os +import sys +import time +from signal import signal, SIGTERM + + +class Daemon(object): + """ + A generic daemon class. + + Usage: subclass the Daemon class and override the run() method + """ + def __init__(self, pidfile, + stdin='/dev/null', + stdout='/dev/null', + stderr='/dev/null'): + self.stdin = stdin + self.stdout = stdout + self.stderr = stderr + self.pidfile = pidfile + + def daemonize(self): + """ + 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) + 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("/") + 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) + + self.write_pid() + # redirect standard file descriptors + sys.stdout.flush() + sys.stderr.flush() + si = file(self.stdin, 'r') + so = file(self.stdout, 'a+') + se = file(self.stderr, 'a+', 0) + os.dup2(si.fileno(), sys.stdin.fileno()) + os.dup2(so.fileno(), sys.stdout.fileno()) + os.dup2(se.fileno(), sys.stderr.fileno()) + + atexit.register(self.shutdown) + self.signal_management() + + def write_pid(self): + # write pidfile + if not self.pidfile: + return + pid = str(os.getpid()) + try: + file(self.pidfile, 'w').write('%s\n' % pid) + #except IOError, wpid_err: + except Exception, wpid_err: + sys.stderr.write(u'Error trying to write pid file to %s: %s\n' % + (unicode(self.pidfile, 'utf-8'), wpid_err)) + sys.exit(1) + atexit.register(self.delpid) + + def signal_management(self): + # Declare signal handlers + signal(SIGTERM, self.exit_handler) + + def exit_handler(self, signum, frame): + sys.exit(1) + + def delpid(self): + os.remove(self.pidfile) + + def start(self): + """ + Start the daemon + """ + # 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 + + if pid: + message = "pidfile %s already exist. Daemon already running?\n" + sys.stderr.write(message % self.pidfile) + sys.exit(1) + + # Start the daemon + self.daemonize() + self.run() + + def foreground(self): + """ + Foreground/debug mode + """ + self.write_pid() + atexit.register(self.shutdown) + self.run() + + def stop(self): + """ + Stop the daemon + """ + # Get the pid from the pidfile + try: + pf = file(self.pidfile, 'r') + pid = int(pf.read().strip()) + pf.close() + except IOError: + pid = None + + if not pid: + message = "pidfile %s does not exist. Daemon not running?\n" + sys.stderr.write(message % self.pidfile) + return # not an error in a restart + + # Try killing the daemon process + try: + os.kill(pid, SIGTERM) + time.sleep(0.1) + except OSError, err: + err = str(err) + if err.find("No such process") > 0: + if os.path.exists(self.pidfile): + message = "Daemon not running? removing pid file %s.\n" + sys.stderr.write(message % self.pidfile) + os.remove(self.pidfile) + else: + print str(err) + sys.exit(1) + + def restart(self): + """ + Restart the daemon + """ + self.stop() + self.start() + + def shutdown(self): + """ + You should override this method when you subclass Daemon. It will be + called when the process is being stopped. + Pay attention: + Daemon() uses atexit to call Daemon().shutdown(), as a consequence + shutdown and any other functions registered via this module are not + called when the program is killed by an un-handled/unknown signal. + This is the reason of Daemon().signal_management() existence. + """ + + 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(). + """ + + +def main(): + pass + +# Script starts here +if __name__ == '__main__': + main() + +# VIM MODLINE +# vim: ai ts=4 sw=4 sts=4 expandtab -- 2.39.5