pythonDaemon.py

"""
***
Modified generic daemon class
***

Author:         http://www.jejik.com/articles/2007/02/
                        a_simple_unix_linux_daemon_in_python/www.boxedice.com
                https://github.com/serverdensity/python-daemon

License:        http://creativecommons.org/licenses/by-sa/3.0/

Changes:        Various fixes where added in signal handling, pid file handling,
                return codes and exception handling

"""

# Core modules
import atexit
import os
import sys
import time
import signal
import logging
import traceback


class Daemon(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

    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))
            os._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))
            os._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())

            signal.signal(signal.SIGTERM, self._shutdown)
            signal.signal(signal.SIGINT, self._shutdown)

        if self.verbose >= 1:
            logging.info("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):
        if os.path.exists(self.pidfile):
            try:
                os.remove(self.pidfile)
            except OSError, e:
                sys.stderr.write("Could not delete pidfile: %d (%s)\n" % (e.errno, e.strerror))

    def start(self, return_on_exit=False, overwrite_pid=False, *args, **kwargs):
        """
        Start the daemon
        """

        if self.verbose >= 1:
            logging.info('Start daemon')

        # Check for a pidfile to see if the daemon already runs
        if os.path.exists(self.pidfile):
            if overwrite_pid:
                self.delpid()
            else:
                message = "pidfile %s already exists. Daemon already running?\n"
                sys.stderr.write(message % self.pidfile)
                if return_on_exit:
                    return False
                sys.exit(1)

        # Start the daemon
        _exitcode = 0

        self.daemonize()

        try:
            logging.info('Running process')
            self.run(*args, **kwargs)
            logging.info('Process finished normally.')
        except Exception as e:
            logging.error('Daemonized process threw an exception [%s].' % e)
            tb = traceback.format_exc()
            logging.error(tb)
            _exitcode = 255
        finally:
            # Make sure the pid file gets deleted even in case of errors
            self.delpid()
            if return_on_exit:
                return _exitcode if _exitcode else False
            sys.exit(_exitcode)

    def _shutdown(self, signum=None, frame=None):
        self.shutdown(frame)

    def shutdown(self, frame=None):
        os.kill(self.pid, signal.SIGTERM)

    def stop(self):
        """
        Stop the daemon
        """

        if self.verbose >= 1:
            logging.info("Stopping daemon...")

        # Get the pid from the pidfile
        pid = self.get_pid()

        if not pid:
            if os.path.exists(self.pidfile):
                message = "pidfile %s does not exist. Daemon not running?\n"
            else:
                message = "could not read pid from pidfile %s\n"
            sys.stderr.write(message % self.pidfile)

            # Just to be sure. A ValueError might occur if the PID file is
            # empty but does actually exist
            self.delpid()

            return  # Not an error in a restart

        # Try killing the daemon process
        _signal = signal.SIGTERM
        try:
            os.kill(pid, _signal)
            _stime = time.time() + 10
            while 1:
                os.getpgid(pid)
                time.sleep(0.1)
                if time.time() > _stime:
                    os.kill(pid, _signal)
                    _signal = signal.SIGKILL
                    _stime += 10
        except OSError, err:
            err = str(err)
            if err.find("No such process") > 0:
                self.delpid()
            else:
                print str(err)
                sys.exit(1)

        if self.verbose >= 1:
            logging.info("Stopped daemon")

    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):
        return self.running

    @property
    def running(self):
        pid = self.get_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().
        """
        raise NotImplemented('You should override this method when you subclass Daemon')