A simple unix/linux daemon in Python

I've written a simple Python class for creating daemons on unix/linux systems. It was pieced together for various other examples, mostly corrections to variousPython Cookbook articles and a couple of examples posted to the Python mailing lists. It has support for a pidfile to keep track of the process. I hope it's useful to someone.

Below is the Daemon class. To use it, simply subclass it and implement the run() method.Download this file.

Update 2009-05-31: An anonymous contributor has written a version of the Daemon class suitable for Python 3.x.Download the Python 3.x version here. The code below is for Python 2.x

    #!/usr/bin/env python
     
    import sys, os, time, atexit
    from signal import SIGTERM
     
    class Daemon:
            """
            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)
           
                    # 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())
           
                    # write pidfile
                    atexit.register(self.delpid)
                    pid = str(os.getpid())
                    file(self.pidfile,'w+').write("%s\n" % pid)
           
            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 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:
                            while 1:
                                    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):
                                            os.remove(self.pidfile)
                            else:
                                    print str(err)
                                    sys.exit(1)
     
            def restart(self):
                    """
                    Restart the daemon
                    """
                    self.stop()
                    self.start()
     
            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().
                    """

And here is an example implementation. It implements the daemon as well as it's controlling client. Simply invoke this script with start, stop or restart as it's first argument.Download this file.

    #!/usr/bin/env python
     
    import sys, time
    from daemon import Daemon
     
    class MyDaemon(Daemon):
            def run(self):
                    while True:
                            time.sleep(1)
     
    if __name__ == "__main__":
            daemon = MyDaemon('/tmp/daemon-example.pid')
            if len(sys.argv) == 2:
                    if 'start' == sys.argv[1]:
                            daemon.start()
                    elif 'stop' == sys.argv[1]:
                            daemon.stop()
                    elif 'restart' == sys.argv[1]:
                            daemon.restart()
                    else:
                            print "Unknown command"
                            sys.exit(2)
                    sys.exit(0)
            else:
                    print "usage: %s start|stop|restart" % sys.argv[0]
                    sys.exit(2)

That's it! I hope this is of some use to someone. Happy coding!

http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/