This module can be used on UNIX to fork a daemon process. It is based on Jürgen Hermann's Cookbook recipe.

An example script might look like this:

   from ll import daemon

   counter = daemon.Daemon(
      stdin="/dev/null",
      stdout="/tmp/daemon.log",
      stderr="/tmp/daemon.log",
      pidfile="/var/run/counter/counter.pid",
      user="nobody"
   )

   if __name__ == "__main__":
      if counter.service():
         import sys, os, time
         sys.stdout.write("Daemon started with pid {}\n".format(os.getpid()))
         sys.stdout.write("Daemon stdout output\n")
         sys.stderr.write("Daemon stderr output\n")
         c = 0
         while True:
            sys.stdout.write('{}: {}\n'.format(c, time.ctime(time.time())))
            sys.stdout.flush()
            c += 1
            time.sleep(1)


==============================
class ``Daemon``​(``object``):
==============================

The ``Daemon`` class provides methods for starting and stopping a daemon process as well as handling command line arguments.


def ``__init__``​(``self``, ``stdin``=``'/dev/null'``, ``stdout``=``'/dev/null'``, ``stderr``=``'/dev/null'``, ``pidfile``=``None``, ``user``=``None``, ``group``=``None``):
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

The ``stdin``, ``stdout``, and ``stderr`` arguments are file names that will be opened and be used to replace the standard file descriptors in ``sys.stdin``, ``sys.stdout``, and ``sys.stderr``. These arguments are optional and default to ``"/dev/null"``. Note that stderr is opened unbuffered, so if it shares a file with stdout then interleaved output may not appear in the order that you expect.

``pidfile`` must be the name of a file. ``start`` will write the pid of the newly forked daemon to this file. ``stop`` uses this file to kill the daemon.

``user`` can be the name or uid of a user. ``start`` will switch to this user for running the service. If ``user`` is ``None`` no user switching will be done.

In the same way ``group`` can be the name or gid of a group. ``start`` will switch to this group.


def ``openstreams``​(``self``):
-------------------------------

Open the standard file descriptors stdin, stdout and stderr as specified in the constructor.


def ``handlesighup``​(``self``, ``signum``, ``frame``):
-------------------------------------------------------

Handle a ``SIG_HUP`` signal: Reopen standard file descriptors.


def ``handlesigterm``​(``self``, ``signum``, ``frame``):
--------------------------------------------------------

Handle a ``SIG_TERM`` signal: Remove the pid file and exit.


def ``switchuser``​(``self``, ``user``, ``group``):
---------------------------------------------------

Switch the effective user and group. If ``user`` and ``group`` are both ``None`` nothing will be done. ``user`` and ``group`` can be an ``int`` (i.e. a user/group id) or ``str`` (a user/group name).


def ``start``​(``self``):
-------------------------

Daemonize the running script. When this method returns the process is completely decoupled from the parent environment.


def ``stop``​(``self``):
------------------------

Send a ``SIGTERM`` signal to a running daemon. The pid of the daemon will be read from the pidfile specified in the constructor.


def ``argparser``​(``self``):
-----------------------------

Return an ``argparse`` parser for parsing the command line arguments. This can be overwritten in subclasses to add more arguments.


def ``parseargs``​(``self``, ``parser``, ``args``=``None``):
------------------------------------------------------------

Use the parser returned by ``argparser`` to parse the argument sequence ``args``, modify ``self`` accordingly and return the result of the parsers ``parse_args`` call.


def ``service``​(``self``, ``args``=``None``):
----------------------------------------------

Handle command line arguments and start or stop the daemon accordingly.

``args`` must be a list of command line arguments (including the program name in ``args[0]``). If ``args`` is ``None`` or unspecified ``sys.argv`` is used.

The return value is true when a starting option has been specified as the command line argument, i.e. if the daemon should be started.

The ``argparse`` arguments are available afterwards as ``self.args``.