# -*- coding: utf-8 -*-
# flake8: noqa
# The MIT License (MIT)
#
# Copyright (c) 2014 Stephan Schultchen
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
"""Implementation of PEP 3143 DaemonContext"""
__author__ = 'schlitzer'


import errno
import os
import resource
import signal
import socket
import sys



class DaemonError(Exception):
    """ Exception raised by DaemonContext"""
    pass


class DaemonContext(object):
    """ Implementation of PEP 3143 DaemonContext class

    This class should be instantiated only once in every program that
    has to become a Unix Daemon. Typically you should call its open method
    after you have done everything that may require root privileges.
    For example opening port <= 1024.

    Each option can be passed as a keyword argument to the constructor, but
    can also be changed by assigning a new value to the corresponding attribute
    on the instance.

    Altering attributes after open() is called, will have no effect.
    In future versions, trying to do so, will may raise a DaemonError.

    :param chroot_directory:
        Full path to the directory that should be set as effective root
        directory. If None, the root directory is not changed.
    :type chroot_directory: str

    :param working_directory:
        Full Path to the working directory to which to change to.
        If chroot_directory is not None, and working_directory is not
        starting with chroot_directory, working directory is prefixed
        with chroot_directory.
    :type working_directory: str.

    :param umask:
        File access creation mask for this daemon after start
    :type umask: int.

    :param uid:
        Effective user id after daemon start.
    :type uid: int.

    :param gid:
        Effective group id after daemon start.
    :type gid: int.

    :param prevent_core:
        Prevent core file generation.
    :type prevent_core: bool.

    :param detach_process:
        If True, do the double fork magic. If the process was started
        by inet or an init like program, you may don´t need to detach.
        If not set, we try to figure out if forking is needed.
    :type detach_process: bool.

    :param files_preserve:
        List of integers, or objects with a fileno method, that
        represent files that should not be closed while daemonizing.
    :type files_preserve: list

    :param pidfile:
        Instance that implements a pidfile, while daemonizing its
        acquire method will be called.
    :type pidfile: Instance of Class that implements a pidfile behaviour

    :param stdin:
        Redirect stdin to this file, if None, redirect to /dev/null.
    :type stdin: file object.

    :param stdout:
        Redirect stdout to this file, if None, redirect to /dev/null.
    :type stdout: file object.

    :param stderr:
        Redirect stderr to this file, if None, redirect to /dev/null.
    :type stderr: file object.

    :param signal_map:
        Mapping from operating system signal to callback actions.
    :type signal_map: instance of dict
    """
    def __init__(
            self, chroot_directory=None, working_directory='/',
            umask=0, uid=None, gid=None, prevent_core=True,
            detach_process=None, files_preserve=None, pidfile=None,
            stdin=None, stdout=None, stderr=None, signal_map=None):
        """ Initialize a new Instance

        """
        self._is_open = False
        self._working_directory = None
        self.chroot_directory = chroot_directory
        self.umask = umask
        self.uid = uid if uid else os.getuid()
        self.gid = gid if gid else os.getgid()
        if detach_process is None:
            self.detach_process = detach_required()
        else:
            self.detach_process = detach_process
        self.signal_map = signal_map if signal_map else default_signal_map()
        self.files_preserve = files_preserve
        self.pidfile = pidfile
        self.prevent_core = prevent_core
        self.stdin = stdin
        self.stdout = stdout
        self.stderr = stderr
        self.working_directory = working_directory

    def __enter__(self):
        """ Context Handler, wrapping self.open()

        :return: self
        """
        self.open()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """ Context Handler, wrapping self.close()

        :return: None
        """
        self.close()

    def _get_signal_handler(self, handler):
        """ get the callback function for handler

        If the handler is None, returns signal.SIG_IGN.
        If the handler is a string, return the matching attribute of this
        instance if possible.
        Else return the handler itself.

        :param handler:
        :type handler: str, None, function
        :return: function
        """
        if not handler:
            result = signal.SIG_IGN
        elif isinstance(handler, str):
            result = getattr(self, handler)
        else:
            result = handler
        return result

    @property
    def _files_preserve(self):
        """ create a set of protected files

        create a set of files, based on self.files_preserve and
        self.stdin, self,stdout and self.stderr, that should not get
        closed while daemonizing.

        :return: set
        """
        result = set()
        files = [] if not self.files_preserve else self.files_preserve
        files.extend([self.stdin, self.stdout, self.stderr])
        for item in files:
            if hasattr(item, 'fileno'):
                result.add(item.fileno())
            if isinstance(item, int):
                result.add(item)
        return result

    @property
    def _signal_handler_map(self):
        """ Create the signal handler map

        create a dictionary with signal:handler mapping based on
        self.signal_map

        :return: dict
        """
        result = {}
        for signum, handler in self.signal_map.items():
            result[signum] = self._get_signal_handler(handler)
        return result

    @property
    def working_directory(self):
        """ The working_directory property

        :return: str
        """
        if self.chroot_directory and not \
                self._working_directory.startswith(self.chroot_directory):
            return self.chroot_directory + self._working_directory
        else:
            return self._working_directory

    @working_directory.setter
    def working_directory(self, value):
        """ Set working directory

        New value is ignored if already daemonized.

        :param value: str
        :return:
        """
        self._working_directory = value

    @property
    def is_open(self):
        """ True when this instances open method was called

        :return: bool
        """
        return self._is_open

    def close(self):
        """ Dummy function"""
        pass

    def open(self):
        """ Daemonize this process

        Do everything that is needed to become a Unix daemon.

        :return: None
        :raise: DaemonError
        """
        if self.is_open:
            return
        try:
            os.chdir(self.working_directory)
            if self.chroot_directory:
                os.chroot(self.chroot_directory)
            os.setgid(self.gid)
            os.setuid(self.uid)
            os.umask(self.umask)
        except OSError as err:
            raise DaemonError('Setting up Environment failed: {0}'
                              .format(err))

        if self.prevent_core:
            try:
                resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
            except Exception as err:
                raise DaemonError('Could not disable core files: {0}'
                                  .format(err))

        if self.detach_process:
            try:
                if os.fork() > 0:
                    os._exit(0)
            except OSError as err:
                raise DaemonError('First fork failed: {0}'.format(err))
            os.setsid()
            try:
                if os.fork() > 0:
                    os._exit(0)
            except OSError as err:
                raise DaemonError('Second fork failed: {0}'.format(err))

        for (signal_number, handler) in self._signal_handler_map.items():
            signal.signal(signal_number, handler)

        close_filenos(self._files_preserve)

        redirect_stream(sys.stdin, self.stdin)
        redirect_stream(sys.stdout, self.stdout)
        redirect_stream(sys.stderr, self.stderr)

        if self.pidfile:
            self.pidfile.acquire()

        self._is_open = True

    def terminate(self, signal_number, stack_frame):
        """ Terminate this process

        Simply terminate this process by raising SystemExit.
        This method is called if signal.SIGTERM was received.

        Check carefully if this really is what you want!

        Most likely it is not!

        You should implement a function/method that is able to cleanly
        shutdown you daemon. Like gracefully terminating child processes,
        threads. or closing files.

        You can create a custom handler by overriding this method, ot
        setting a custom handler via the signal_map. It is also possible
        to set the signal handlers directly via signal.signal().

        :return: None
        :raise: SystemExit
        """
        raise SystemExit('Terminating on signal {0}'.format(signal_number))


def close_filenos(preserve):
    """ Close unprotected file descriptors

    Close all open file descriptors that are not in preserve.

    If ulimit -nofile is "unlimited", all is defined filenos <= 4096,
    else all is <= the output of resource.getrlimit().

    :param preserve: set with protected files
    :type preserve: set

    :return: None
    """
    maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
    if maxfd == resource.RLIM_INFINITY:
        maxfd = 4096
    for fileno in range(maxfd):
        if fileno not in preserve:
            try:
                os.close(fileno)
            except OSError as err:
                if not err.errno == errno.EBADF:
                    raise DaemonError(
                        'Failed to close file descriptor {0}: {1}'
                        .format(fileno, err))


def default_signal_map():
    """ Create the default signal map for this system.

    :return: dict
    """
    name_map = {
        'SIGTSTP': None,
        'SIGTTIN': None,
        'SIGTTOU': None,
        'SIGTERM': 'terminate'}
    signal_map = {}
    for name, target in name_map.items():
        if hasattr(signal, name):
            signal_map[getattr(signal, name)] = target
    return signal_map


def parent_is_init():
    """ Check if parent is Init

    Check if the parent process is init, or something else that
    owns PID 1.

    :return: bool
    """
    if os.getppid() == 1:
        return True
    return False


def parent_is_inet():
    """ Check if parent is inet

    Check if our parent seems ot be a superserver, aka inetd/xinetd.

    This is done by checking if sys.__stdin__ is a network socket.

    :return: bool
    """
    result = False
    sock = socket.fromfd(
        sys.__stdin__.fileno(),
        socket.AF_INET,
        socket.SOCK_RAW)
    try:
        sock.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)
        result = True
    except (OSError, socket.error) as err:
        if not err.args[0] == errno.ENOTSOCK:
            result = True
    return result


def detach_required():
    """ Check if detaching is required

    This is done by collecting the results of parent_is_inet and
    parent_is_init. If one of them is True, detaching, aka the daemonizing,
    aka the double fork magic, is not required, and can be skipped.

    :return: bool
    """
    if parent_is_inet() or parent_is_init():
        return False
    return True


def redirect_stream(system, target):
    """ Redirect Unix streams

    If None, redirect Stream to /dev/null, else redirect to target.

    :param system: ether sys.stdin, sys.stdout, or sys.stderr
    :type system: file object

    :param target: File like object, or None
    :type target: None, File Object

    :return: None
    :raise: DaemonError
    """
    if target is None:
        target_fd = os.open(os.devnull, os.O_RDWR)
    else:
        target_fd = target.fileno()
    try:
        os.dup2(target_fd, system.fileno())
    except OSError as err:
        raise DaemonError('Could not redirect {0} to {1}: {2}'
                          .format(system, target, err))
