| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771 |
- # -*- coding: utf-8 -*-
- # daemon/daemon.py
- # Part of python-daemon, an implementation of PEP 3143.
- #
- # Copyright © 2008–2009 Ben Finney <ben+python@benfinney.id.au>
- # Copyright © 2007–2008 Robert Niederreiter, Jens Klein
- # Copyright © 2004–2005 Chad J. Schroeder
- # Copyright © 2003 Clark Evans
- # Copyright © 2002 Noah Spurrier
- # Copyright © 2001 Jürgen Hermann
- #
- # This is free software: you may copy, modify, and/or distribute this work
- # under the terms of the Python Software Foundation License, version 2 or
- # later as published by the Python Software Foundation.
- # No warranty expressed or implied. See the file LICENSE.PSF-2 for details.
- """ Daemon process behaviour.
- """
- import os
- import sys
- import resource
- import errno
- import signal
- import socket
- import atexit
- class DaemonError(Exception):
- """ Base exception class for errors from this module. """
- class DaemonOSEnvironmentError(DaemonError, OSError):
- """ Exception raised when daemon OS environment setup receives error. """
- class DaemonProcessDetachError(DaemonError, OSError):
- """ Exception raised when process detach fails. """
- class DaemonContext(object):
- """ Context for turning the current program into a daemon process.
- A `DaemonContext` instance represents the behaviour settings and
- process context for the program when it becomes a daemon. The
- behaviour and environment is customised by setting options on the
- instance, before calling the `open` method.
- Each option can be passed as a keyword argument to the `DaemonContext`
- constructor, or subsequently altered by assigning to an attribute on
- the instance at any time prior to calling `open`. That is, for
- options named `wibble` and `wubble`, the following invocation::
- foo = daemon.DaemonContext(wibble=bar, wubble=baz)
- foo.open()
- is equivalent to::
- foo = daemon.DaemonContext()
- foo.wibble = bar
- foo.wubble = baz
- foo.open()
- The following options are defined.
- `files_preserve`
- :Default: ``None``
- List of files that should *not* be closed when starting the
- daemon. If ``None``, all open file descriptors will be closed.
- Elements of the list are file descriptors (as returned by a file
- object's `fileno()` method) or Python `file` objects. Each
- specifies a file that is not to be closed during daemon start.
- `chroot_directory`
- :Default: ``None``
- Full path to a directory to set as the effective root directory of
- the process. If ``None``, specifies that the root directory is not
- to be changed.
- `working_directory`
- :Default: ``'/'``
- Full path of the working directory to which the process should
- change on daemon start.
- Since a filesystem cannot be unmounted if a process has its
- current working directory on that filesystem, this should either
- be left at default or set to a directory that is a sensible “home
- directory” for the daemon while it is running.
- `umask`
- :Default: ``0``
- File access creation mask (“umask”) to set for the process on
- daemon start.
- Since a process inherits its umask from its parent process,
- starting the daemon will reset the umask to this value so that
- files are created by the daemon with access modes as it expects.
- `pidfile`
- :Default: ``None``
- Context manager for a PID lock file. When the daemon context opens
- and closes, it enters and exits the `pidfile` context manager.
- `detach_process`
- :Default: ``None``
- If ``True``, detach the process context when opening the daemon
- context; if ``False``, do not detach.
- If unspecified (``None``) during initialisation of the instance,
- this will be set to ``True`` by default, and ``False`` only if
- detaching the process is determined to be redundant; for example,
- in the case when the process was started by `init`, by `initd`, or
- by `inetd`.
- `signal_map`
- :Default: system-dependent
- Mapping from operating system signals to callback actions.
- The mapping is used when the daemon context opens, and determines
- the action for each signal's signal handler:
- * A value of ``None`` will ignore the signal (by setting the
- signal action to ``signal.SIG_IGN``).
- * A string value will be used as the name of an attribute on the
- ``DaemonContext`` instance. The attribute's value will be used
- as the action for the signal handler.
- * Any other value will be used as the action for the
- signal handler. See the ``signal.signal`` documentation
- for details of the signal handler interface.
- The default value depends on which signals are defined on the
- running system. Each item from the list below whose signal is
- actually defined in the ``signal`` module will appear in the
- default map:
- * ``signal.SIGTTIN``: ``None``
- * ``signal.SIGTTOU``: ``None``
- * ``signal.SIGTSTP``: ``None``
- * ``signal.SIGTERM``: ``'terminate'``
- Depending on how the program will interact with its child
- processes, it may need to specify a signal map that
- includes the ``signal.SIGCHLD`` signal (received when a
- child process exits). See the specific operating system's
- documentation for more detail on how to determine what
- circumstances dictate the need for signal handlers.
- `uid`
- :Default: ``os.getuid()``
- `gid`
- :Default: ``os.getgid()``
- The user ID (“UID”) value and group ID (“GID”) value to switch
- the process to on daemon start.
- The default values, the real UID and GID of the process, will
- relinquish any effective privilege elevation inherited by the
- process.
- `prevent_core`
- :Default: ``True``
- If true, prevents the generation of core files, in order to avoid
- leaking sensitive information from daemons run as `root`.
- `stdin`
- :Default: ``None``
- `stdout`
- :Default: ``None``
- `stderr`
- :Default: ``None``
- Each of `stdin`, `stdout`, and `stderr` is a file-like object
- which will be used as the new file for the standard I/O stream
- `sys.stdin`, `sys.stdout`, and `sys.stderr` respectively. The file
- should therefore be open, with a minimum of mode 'r' in the case
- of `stdin`, and mode 'w+' in the case of `stdout` and `stderr`.
- If the object has a `fileno()` method that returns a file
- descriptor, the corresponding file will be excluded from being
- closed during daemon start (that is, it will be treated as though
- it were listed in `files_preserve`).
- If ``None``, the corresponding system stream is re-bound to the
- file named by `os.devnull`.
- """
- def __init__(
- self,
- chroot_directory=None,
- working_directory='/',
- umask=0,
- uid=None,
- gid=None,
- detach_process=None,
- files_preserve=None,
- pidfile=None,
- stdin=None,
- stdout=None,
- stderr=None,
- signal_map=None,
- ):
- """ Set up a new instance. """
- self.chroot_directory = chroot_directory
- self.working_directory = working_directory
- self.umask = umask
- self.files_preserve = files_preserve
- self.pidfile = pidfile
- self.stdin = stdin
- self.stdout = stdout
- self.stderr = stderr
- if uid is None:
- uid = os.getuid()
- self.uid = uid
- if gid is None:
- gid = os.getgid()
- self.gid = gid
- if detach_process is None:
- detach_process = is_detach_process_context_required()
- self.detach_process = detach_process
- if signal_map is None:
- signal_map = make_default_signal_map()
- self.signal_map = signal_map
- self._is_open = False
- @property
- def is_open(self):
- """ ``True`` if the instance is currently open. """
- return self._is_open
- def open(self):
- """ Become a daemon process.
- :Return: ``None``
- Open the daemon context, turning the current program into a daemon
- process. This performs the following steps:
- * If this instance's `is_open` property is true, return
- immediately. This makes it safe to call `open` multiple times on
- an instance.
- * If the `prevent_core` attribute is true, set the resource limits
- for the process to prevent any core dump from the process.
- * If the `chroot_directory` attribute is not ``None``, set the
- effective root directory of the process to that directory (via
- `os.chroot`).
- This allows running the daemon process inside a “chroot gaol”
- as a means of limiting the system's exposure to rogue behaviour
- by the process. Note that the specified directory needs to
- already be set up for this purpose.
- * Set the process UID and GID to the `uid` and `gid` attribute
- values.
- * Close all open file descriptors. This excludes those listed in
- the `files_preserve` attribute, and those that correspond to the
- `stdin`, `stdout`, or `stderr` attributes.
- * Change current working directory to the path specified by the
- `working_directory` attribute.
- * Reset the file access creation mask to the value specified by
- the `umask` attribute.
- * If the `detach_process` option is true, detach the current
- process into its own process group, and disassociate from any
- controlling terminal.
- * Set signal handlers as specified by the `signal_map` attribute.
- * If any of the attributes `stdin`, `stdout`, `stderr` are not
- ``None``, bind the system streams `sys.stdin`, `sys.stdout`,
- and/or `sys.stderr` to the files represented by the
- corresponding attributes. Where the attribute has a file
- descriptor, the descriptor is duplicated (instead of re-binding
- the name).
- * If the `pidfile` attribute is not ``None``, enter its context
- manager.
- * Mark this instance as open (for the purpose of future `open` and
- `close` calls).
- * Register the `close` method to be called during Python's exit
- processing.
- When the function returns, the running program is a daemon
- process.
- """
- if self.is_open:
- return
- if self.chroot_directory is not None:
- change_root_directory(self.chroot_directory)
- prevent_core_dump()
- change_file_creation_mask(self.umask)
- change_working_directory(self.working_directory)
- change_process_owner(self.uid, self.gid)
- if self.detach_process:
- detach_process_context()
- signal_handler_map = self._make_signal_handler_map()
- set_signal_handlers(signal_handler_map)
- exclude_fds = self._get_exclude_file_descriptors()
- close_all_open_files(exclude=exclude_fds)
- redirect_stream(sys.stdin, self.stdin)
- redirect_stream(sys.stdout, self.stdout)
- redirect_stream(sys.stderr, self.stderr)
- if self.pidfile is not None:
- self.pidfile.__enter__()
- self._is_open = True
- register_atexit_function(self.close)
- def __enter__(self):
- """ Context manager entry point. """
- self.open()
- return self
- def close(self):
- """ Exit the daemon process context.
- :Return: ``None``
- Close the daemon context. This performs the following steps:
- * If this instance's `is_open` property is false, return
- immediately. This makes it safe to call `close` multiple times
- on an instance.
- * If the `pidfile` attribute is not ``None``, exit its context
- manager.
- * Mark this instance as closed (for the purpose of future `open`
- and `close` calls).
- """
- if not self.is_open:
- return
- if self.pidfile is not None:
- self.pidfile.__exit__()
- self._is_open = False
- def __exit__(self, exc_type, exc_value, traceback):
- """ Context manager exit point. """
- self.close()
- def terminate(self, signal_number, stack_frame):
- """ Signal handler for end-process signals.
- :Return: ``None``
- Signal handler for the ``signal.SIGTERM`` signal. Performs the
- following step:
- * Raise a ``SystemExit`` exception explaining the signal.
- """
- exception = SystemExit(
- "Terminating on signal %(signal_number)r"
- % vars())
- raise exception
- def _get_exclude_file_descriptors(self):
- """ Return the set of file descriptors to exclude closing.
- Returns a set containing the file descriptors for the
- items in `files_preserve`, and also each of `stdin`,
- `stdout`, and `stderr`:
- * If the item is ``None``, it is omitted from the return
- set.
- * If the item has a ``fileno()`` method, that method's
- return value is in the return set.
- * Otherwise, the item is in the return set verbatim.
- """
- files_preserve = self.files_preserve
- if files_preserve is None:
- files_preserve = []
- files_preserve.extend(
- item for item in [self.stdin, self.stdout, self.stderr]
- if hasattr(item, 'fileno'))
- exclude_descriptors = set()
- for item in files_preserve:
- if item is None:
- continue
- if hasattr(item, 'fileno'):
- exclude_descriptors.add(item.fileno())
- else:
- exclude_descriptors.add(item)
- return exclude_descriptors
- def _make_signal_handler(self, target):
- """ Make the signal handler for a specified target object.
- If `target` is ``None``, returns ``signal.SIG_IGN``. If
- `target` is a string, returns the attribute of this
- instance named by that string. Otherwise, returns `target`
- itself.
- """
- if target is None:
- result = signal.SIG_IGN
- elif isinstance(target, basestring):
- name = target
- result = getattr(self, name)
- else:
- result = target
- return result
- def _make_signal_handler_map(self):
- """ Make the map from signals to handlers for this instance.
- Constructs a map from signal numbers to handlers for this
- context instance, suitable for passing to
- `set_signal_handlers`.
- """
- signal_handler_map = dict(
- (signal_number, self._make_signal_handler(target))
- for (signal_number, target) in self.signal_map.items())
- return signal_handler_map
- def change_working_directory(directory):
- """ Change the working directory of this process.
- """
- try:
- os.chdir(directory)
- except Exception, exc:
- error = DaemonOSEnvironmentError(
- "Unable to change working directory (%(exc)s)"
- % vars())
- raise error
- def change_root_directory(directory):
- """ Change the root directory of this process.
- Sets the current working directory, then the process root
- directory, to the specified `directory`. Requires appropriate
- OS privileges for this process.
- """
- try:
- os.chdir(directory)
- os.chroot(directory)
- except Exception, exc:
- error = DaemonOSEnvironmentError(
- "Unable to change root directory (%(exc)s)"
- % vars())
- raise error
- def change_file_creation_mask(mask):
- """ Change the file creation mask for this process.
- """
- try:
- os.umask(mask)
- except Exception, exc:
- error = DaemonOSEnvironmentError(
- "Unable to change file creation mask (%(exc)s)"
- % vars())
- raise error
- def change_process_owner(uid, gid):
- """ Change the owning UID and GID of this process.
- Sets the GID then the UID of the process (in that order, to
- avoid permission errors) to the specified `gid` and `uid`
- values. Requires appropriate OS privileges for this process.
- """
- try:
- os.setgid(gid)
- os.setuid(uid)
- except Exception, exc:
- error = DaemonOSEnvironmentError(
- "Unable to change file creation mask (%(exc)s)"
- % vars())
- raise error
- def prevent_core_dump():
- """ Prevent this process from generating a core dump.
- Sets the soft and hard limits for core dump size to zero. On
- Unix, this prevents the process from creating core dump
- altogether.
- """
- core_resource = resource.RLIMIT_CORE
- try:
- # Ensure the resource limit exists on this platform, by requesting
- # its current value
- core_limit_prev = resource.getrlimit(core_resource)
- except ValueError, exc:
- error = DaemonOSEnvironmentError(
- "System does not support RLIMIT_CORE resource limit (%(exc)s)"
- % vars())
- raise error
- # Set hard and soft limits to zero, i.e. no core dump at all
- core_limit = (0, 0)
- resource.setrlimit(core_resource, core_limit)
- def detach_process_context():
- """ Detach the process context from parent and session.
- Detach from the parent process and session group, allowing the
- parent to exit while this process continues running.
- Reference: “Advanced Programming in the Unix Environment”,
- section 13.3, by W. Richard Stevens, published 1993 by
- Addison-Wesley.
-
- """
- def fork_then_exit_parent(error_message):
- """ Fork a child process, then exit the parent process.
- If the fork fails, raise a ``DaemonProcessDetachError``
- with ``error_message``.
- """
- try:
- pid = os.fork()
- if pid > 0:
- os._exit(0)
- except OSError, exc:
- exc_errno = exc.errno
- exc_strerror = exc.strerror
- error = DaemonProcessDetachError(
- "%(error_message)s: [%(exc_errno)d] %(exc_strerror)s" % vars())
- raise error
- fork_then_exit_parent(error_message="Failed first fork")
- os.setsid()
- fork_then_exit_parent(error_message="Failed second fork")
- def is_process_started_by_init():
- """ Determine if the current process is started by `init`.
- The `init` process has the process ID of 1; if that is our
- parent process ID, return ``True``, otherwise ``False``.
-
- """
- result = False
- init_pid = 1
- if os.getppid() == init_pid:
- result = True
- return result
- def is_socket(fd):
- """ Determine if the file descriptor is a socket.
- Return ``False`` if querying the socket type of `fd` raises an
- error; otherwise return ``True``.
- """
- result = False
- file_socket = socket.fromfd(fd, socket.AF_INET, socket.SOCK_RAW)
- try:
- socket_type = file_socket.getsockopt(
- socket.SOL_SOCKET, socket.SO_TYPE)
- except socket.error, exc:
- exc_errno = exc.args[0]
- if exc_errno == errno.ENOTSOCK:
- # Socket operation on non-socket
- pass
- else:
- # Some other socket error
- result = True
- else:
- # No error getting socket type
- result = True
- return result
- def is_process_started_by_superserver():
- """ Determine if the current process is started by the superserver.
- The internet superserver creates a network socket, and
- attaches it to the standard streams of the child process. If
- that is the case for this process, return ``True``, otherwise
- ``False``.
-
- """
- result = False
- stdin_fd = sys.__stdin__.fileno()
- if is_socket(stdin_fd):
- result = True
- return result
- def is_detach_process_context_required():
- """ Determine whether detaching process context is required.
- Return ``True`` if the process environment indicates the
- process is already detached:
- * Process was started by `init`; or
- * Process was started by `inetd`.
- """
- result = True
- if is_process_started_by_init() or is_process_started_by_superserver():
- result = False
- return result
- def close_file_descriptor_if_open(fd):
- """ Close a file descriptor if already open.
- Close the file descriptor `fd`, suppressing an error in the
- case the file was not open.
- """
- try:
- os.close(fd)
- except OSError, exc:
- if exc.errno == errno.EBADF:
- # File descriptor was not open
- pass
- else:
- error = DaemonOSEnvironmentError(
- "Failed to close file descriptor %(fd)d"
- " (%(exc)s)"
- % vars())
- raise error
- MAXFD = 2048
- def get_maximum_file_descriptors():
- """ Return the maximum number of open file descriptors for this process.
- Return the process hard resource limit of maximum number of
- open file descriptors. If the limit is “infinity”, a default
- value of ``MAXFD`` is returned.
- """
- limits = resource.getrlimit(resource.RLIMIT_NOFILE)
- result = limits[1]
- if result == resource.RLIM_INFINITY:
- result = MAXFD
- return result
- def close_all_open_files(exclude=set()):
- """ Close all open file descriptors.
- Closes every file descriptor (if open) of this process. If
- specified, `exclude` is a set of file descriptors to *not*
- close.
- """
- maxfd = get_maximum_file_descriptors()
- for fd in reversed(range(maxfd)):
- if fd not in exclude:
- close_file_descriptor_if_open(fd)
- def redirect_stream(system_stream, target_stream):
- """ Redirect a system stream to a specified file.
- `system_stream` is a standard system stream such as
- ``sys.stdout``. `target_stream` is an open file object that
- should replace the corresponding system stream object.
- If `target_stream` is ``None``, defaults to opening the
- operating system's null device and using its file descriptor.
- """
- if target_stream is None:
- target_fd = os.open(os.devnull, os.O_RDWR)
- else:
- target_fd = target_stream.fileno()
- os.dup2(target_fd, system_stream.fileno())
- def make_default_signal_map():
- """ Make the default signal map for this system.
- The signals available differ by system. The map will not
- contain any signals not defined on the running system.
- """
- name_map = {
- 'SIGTSTP': None,
- 'SIGTTIN': None,
- 'SIGTTOU': None,
- 'SIGTERM': 'terminate',
- }
- signal_map = dict(
- (getattr(signal, name), target)
- for (name, target) in name_map.items()
- if hasattr(signal, name))
- return signal_map
- def set_signal_handlers(signal_handler_map):
- """ Set the signal handlers as specified.
- The `signal_handler_map` argument is a map from signal number
- to signal handler. See the `signal` module for details.
- """
- for (signal_number, handler) in signal_handler_map.items():
- signal.signal(signal_number, handler)
- def register_atexit_function(func):
- """ Register a function for processing at program exit.
- The function `func` is registered for a call with no arguments
- at program exit.
- """
- atexit.register(func)
|