"""
Starting or restarting of services and daemons
==============================================

Services are defined as system daemons and are typically launched using system
init or rc scripts. This service state uses whichever service module is loaded
on the minion with the virtualname of ``service``. Services can be defined as
either running or dead.

If you need to know if your init system is supported, see the list of supported
:mod:`service modules <salt.modules.service.py>` for your desired init system
(systemd, sysvinit, launchctl, etc.).

Note that Salt's service execution module, and therefore this service state,
uses OS grains to ascertain which service module should be loaded and used to
execute service functions. As existing distributions change init systems or
new distributions are created, OS detection can sometimes be incomplete.
If your service states are running into trouble with init system detection,
please see the :ref:`Overriding Virtual Module Providers <module-provider-override>`
section of Salt's module documentation to work around possible errors.

For services managed by systemd, the systemd_service module includes a built-in
feature to reload the daemon when unit files are changed or extended. This
feature is used automatically by the service state and the systemd_service
module when running on a systemd minion, so there is no need to set up your own
methods of reloading the daemon. If you need to manually reload the daemon for
some reason, you can use the :func:`systemd_service.systemctl_reload <salt.modules.systemd_service.systemctl_reload>` function provided by Salt.

.. note::
    The current status of a service is determined by the return code of the init/rc
    script status command. A status return code of 0 it is considered running.  Any
    other return code is considered dead.

.. code-block:: yaml

    httpd:
      service.running: []

The service can also be set to start at runtime via the enable option:

.. code-block:: yaml

    openvpn:
      service.running:
        - enable: True

By default if a service is triggered to refresh due to a watch statement the
service is restarted. If the desired behavior is to reload the service, then
set the reload value to True:

.. code-block:: yaml

    redis:
      service.running:
        - enable: True
        - reload: True
        - watch:
          - pkg: redis

.. note::

    More details regarding ``watch`` can be found in the
    :ref:`Requisites <requisites>` documentation.

"""

import logging
import time

import salt.utils.data
import salt.utils.platform
from salt.exceptions import CommandExecutionError
from salt.utils.args import get_function_argspec as _argspec
from salt.utils.systemd import booted

SYSTEMD_ONLY = ("no_block", "unmask", "unmask_runtime")

log = logging.getLogger(__name__)

__virtualname__ = "service"


def __virtual__():
    """
    Only make these states available if a service provider has been detected or
    assigned for this minion
    """
    if "service.start" in __salt__:
        return __virtualname__
    else:
        return (
            False,
            "No service execution module loaded: "
            "check support for service management on {} "
            "".format(__grains__.get("osfinger", __grains__["os"])),
        )


# Double-asterisk deliberately not used here
def _get_systemd_only(func, kwargs):
    if not hasattr(_get_systemd_only, "HAS_SYSTEMD"):
        setattr(_get_systemd_only, "HAS_SYSTEMD", booted())

    ret = {}
    warnings = []
    valid_args = _argspec(func).args
    for systemd_arg in SYSTEMD_ONLY:
        if systemd_arg in kwargs and systemd_arg in valid_args:
            if _get_systemd_only.HAS_SYSTEMD:
                ret[systemd_arg] = kwargs[systemd_arg]
            else:
                warnings.append(
                    "The '{}' argument is not supported by this platform".format(
                        systemd_arg
                    )
                )
    return ret, warnings


def _add_warnings(ret, warnings):
    current_warnings = ret.setdefault("warnings", [])
    current_warnings.extend([x for x in warnings if x not in current_warnings])


def _enabled_used_error(ret):
    """
    Warn of potential typo.
    """
    ret["result"] = False
    ret["comment"] = (
        'Service {} uses non-existent option "enabled".  '
        'Perhaps "enable" option was intended?'.format(ret["name"])
    )
    return ret


def _enable(name, started, result=True, **kwargs):
    """
    Enable the service
    """
    ret = {}

    # is service available?
    try:
        if not _available(name, ret):
            return ret
    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret

    # Set default expected result
    ret["result"] = result

    # Check to see if this minion supports enable
    if "service.enable" not in __salt__ or "service.enabled" not in __salt__:
        if started is True:
            ret["comment"] = (
                "Enable is not available on this minion, service {} started".format(
                    name
                )
            )
        elif started is None:
            ret["comment"] = (
                "Enable is not available on this minion,"
                " service {} is in the desired state".format(name)
            )
        else:
            ret["comment"] = (
                "Enable is not available on this minion, service {} is dead".format(
                    name
                )
            )
        return ret

    # Service can be enabled
    before_toggle_enable_status = __salt__["service.enabled"](name, **kwargs)
    if before_toggle_enable_status:
        # Service is enabled
        if started is True:
            ret["comment"] = "Service {} is already enabled, and is running".format(
                name
            )
        elif started is None:
            # always be sure in this case to reset the changes dict
            ret["changes"] = {}
            ret["comment"] = (
                "Service {} is already enabled, and is in the desired state".format(
                    name
                )
            )
        else:
            ret["comment"] = f"Service {name} is already enabled, and is dead"
        return ret

    # Service needs to be enabled
    if __opts__["test"]:
        ret["result"] = None
        ret["comment"] = f"Service {name} set to be enabled"
        return ret

    try:
        if __salt__["service.enable"](name, **kwargs):
            # Service has been enabled
            ret["changes"] = {}
            after_toggle_enable_status = __salt__["service.enabled"](name, **kwargs)
            # on upstart, certain services like apparmor will always return
            # False, even if correctly activated
            # do not trigger a change
            if before_toggle_enable_status != after_toggle_enable_status:
                ret["changes"][name] = True
            if started is True:
                ret["comment"] = "Service {} has been enabled, and is running".format(
                    name
                )
            elif started is None:
                ret["comment"] = (
                    "Service {} has been enabled, and is in the desired state".format(
                        name
                    )
                )
            else:
                ret["comment"] = f"Service {name} has been enabled, and is dead"
            return ret
    except CommandExecutionError as exc:
        enable_error = exc.strerror
    else:
        enable_error = False

    # Service failed to be enabled
    ret["result"] = False
    if started is True:
        ret["comment"] = (
            "Failed when setting service {} to start at boot,"
            " but the service is running".format(name)
        )
    elif started is None:
        ret["comment"] = (
            "Failed when setting service {} to start at boot,"
            " but the service was already running".format(name)
        )
    else:
        ret["comment"] = (
            "Failed when setting service {} to start at boot, and the service is dead".format(
                name
            )
        )

    if enable_error:
        ret["comment"] += f". Additional information follows:\n\n{enable_error}"

    return ret


def _disable(name, started, result=True, **kwargs):
    """
    Disable the service
    """
    ret = {}

    # is service available?
    try:
        if not _available(name, ret):
            ret["result"] = True
            return ret
    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret

    # Set default expected result
    ret["result"] = result

    # is enable/disable available?
    if "service.disable" not in __salt__ or "service.disabled" not in __salt__:
        if started is True:
            ret["comment"] = (
                "Disable is not available on this minion, service {} started".format(
                    name
                )
            )
        elif started is None:
            ret["comment"] = (
                "Disable is not available on this minion,"
                " service {} is in the desired state".format(name)
            )
        else:
            ret["comment"] = (
                "Disable is not available on this minion, service {} is dead".format(
                    name
                )
            )
        return ret

    # Service can be disabled
    if salt.utils.platform.is_windows():
        # service.disabled in Windows returns True for services that are set to
        # Manual start, so we need to check specifically for Disabled
        before_toggle_disable_status = __salt__["service.info"](name)["StartType"] in [
            "Disabled"
        ]
    else:
        before_toggle_disable_status = __salt__["service.disabled"](name)
    if before_toggle_disable_status:
        # Service is disabled
        if started is True:
            ret["comment"] = "Service {} is already disabled, and is running".format(
                name
            )
        elif started is None:
            # always be sure in this case to reset the changes dict
            ret["changes"] = {}
            ret["comment"] = (
                "Service {} is already disabled, and is in the desired state".format(
                    name
                )
            )
        else:
            ret["comment"] = f"Service {name} is already disabled, and is dead"
        return ret

    # Service needs to be disabled
    if __opts__["test"]:
        ret["result"] = None
        ret["comment"] = f"Service {name} set to be disabled"
        return ret

    if __salt__["service.disable"](name, **kwargs):
        # Service has been disabled
        ret["changes"] = {}
        after_toggle_disable_status = __salt__["service.disabled"](name)
        # on upstart, certain services like apparmor will always return
        # False, even if correctly activated
        # do not trigger a change
        if before_toggle_disable_status != after_toggle_disable_status:
            ret["changes"][name] = True
        if started is True:
            ret["comment"] = f"Service {name} has been disabled, and is running"
        elif started is None:
            ret["comment"] = (
                f"Service {name} has been disabled, and is in the desired state"
            )
        else:
            ret["comment"] = f"Service {name} has been disabled, and is dead"
        return ret

    # Service failed to be disabled
    ret["result"] = False
    if started is True:
        ret["comment"] = (
            "Failed when setting service {} to not start at boot, and is running".format(
                name
            )
        )
    elif started is None:
        ret["comment"] = (
            "Failed when setting service {} to not start"
            " at boot, but the service was already running".format(name)
        )
    else:
        ret["comment"] = (
            "Failed when setting service {} to not start"
            " at boot, and the service is dead".format(name)
        )
    return ret


def _offline():
    return "service.offline" in __salt__ and __salt__["service.offline"]()


def _available(name, ret):
    """
    Check if the service is available
    """
    avail = False
    if "service.available" in __salt__:
        avail = __salt__["service.available"](name)
    elif "service.get_all" in __salt__:
        avail = name in __salt__["service.get_all"]()
    if not avail:
        ret["result"] = False
        ret["comment"] = f"The named service {name} is not available"
    return avail


def running(name, enable=None, sig=None, init_delay=None, **kwargs):
    """
    Ensure that the service is running

    name
        The name of the init or rc script used to manage the service

    enable
        Set the service to be enabled at boot time, ``True`` sets the service
        to be enabled, ``False`` sets the named service to be disabled. The
        default is ``None``, which does not enable or disable anything.

    sig
        The string to search for when looking for the service process with
        ``ps``. The lookup uses an unanchored substring match against the
        process command line, so embedded shell metacharacters (``()``,
        ``|``, ``&``, ``;``, ``$``, backticks, quotes, etc.) are matched
        literally. Prefer a substring of the actual executable name (for
        example ``twistd``) over a full command line containing special
        characters.

    init_delay
        Some services may not be truly available for a short period after their
        startup script indicates to the system that they are. Provide an
        'init_delay' to specify that this state should wait an additional given
        number of seconds after a service has started before returning. Useful
        for requisite states wherein a dependent state might assume a service
        has started but is not yet fully initialized.

    no_block : False
        **For systemd minions only.** Starts the service using ``--no-block``.

        .. versionadded:: 2017.7.0

    timeout
        **For Windows minions only.**

        The time in seconds to wait for the service to start before returning.
        Default is the default for :py:func:`win_service.start
        <salt.modules.win_service.start>`.

        .. versionadded:: 2017.7.9,2018.3.4

    unmask : False
        **For systemd minions only.** Set to ``True`` to remove an indefinite
        mask before attempting to start the service.

        .. versionadded:: 2017.7.0
            In previous releases, Salt would simply unmask a service before
            making any changes. This behavior is no longer the default.

    unmask_runtime : False
        **For systemd minions only.** Set to ``True`` to remove a runtime mask
        before attempting to start the service.

        .. versionadded:: 2017.7.0
            In previous releases, Salt would simply unmask a service before
            making any changes. This behavior is no longer the default.

    wait : 3
        **For systemd minions only.** Passed through when using
        :py:func:`service.status <salt.modules.systemd_service.status>` to
        determine whether the service is running or not.

        .. versionadded:: 2019.2.3

    reload : False
        Honored when this state is the target of a ``watch`` requisite. When
        ``True`` the service is reloaded (``systemctl reload``) rather than
        restarted on watch-triggered refresh. The argument is consumed by
        :py:func:`mod_watch <salt.states.service.mod_watch>`; passing
        ``reload`` outside of a ``watch`` context has no effect.

    full_restart : False
        Honored when this state is the target of a ``watch`` requisite. When
        ``True`` the service is fully restarted (``service.full_restart``)
        rather than restarted on watch-triggered refresh.

    .. note::

        On systemd minions, a change to a ``.service`` unit file does **not**
        automatically trigger ``systemctl daemon-reload`` unless that unit
        file is detected and managed by ``systemd_service`` itself. When a
        ``file.managed`` state installs or modifies a unit file, you should
        either run :py:func:`module.run <salt.states.module.run>` with
        ``service.systemctl_reload`` (or call
        :py:func:`systemd_service.systemctl_reload
        <salt.modules.systemd_service.systemctl_reload>` from a Jinja
        template) before restarting the service, or arrange the requisites
        so that the daemon-reload happens first.

    .. note::
        ``watch`` can be used with service.running to restart a service when
         another state changes ( example: a file.managed state that creates the
         service's config file ). More details regarding ``watch`` can be found
         in the :ref:`Requisites <requisites>` documentation.
    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    # used to let execution modules know which service state is being run.
    __context__["service.state"] = "running"

    # Check for common error: using enabled option instead of enable
    if "enabled" in kwargs:
        return _enabled_used_error(ret)

    # Convert enable to boolean in case user passed a string value
    if isinstance(enable, str):
        enable = salt.utils.data.is_true(enable)

    if _offline():
        ret["result"] = True
        ret["comment"] = "Running in OFFLINE mode. Nothing to do"
        return ret

    # Check if the service is available
    try:
        if not _available(name, ret):
            if __opts__.get("test"):
                ret["result"] = None
                ret["comment"] = (
                    "Service {} not present; if created in this state run, "
                    "it would have been started".format(name)
                )
            return ret
    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret

    status_kwargs, warnings = _get_systemd_only(__salt__["service.status"], kwargs)
    if warnings:
        _add_warnings(ret, warnings)

    # lot of custom init script won't or mis implement the status
    # command, so it is just an indicator but can not be fully trusted
    before_toggle_status = __salt__["service.status"](name, sig, **status_kwargs)
    if "service.enabled" in __salt__:
        before_toggle_enable_status = __salt__["service.enabled"](name)
    else:
        before_toggle_enable_status = True

    unmask_ret = {"comment": ""}
    if kwargs.get("unmask", False):
        unmask_ret = unmasked(name, kwargs.get("unmask_runtime", False))

    # See if the service is already running
    if before_toggle_status:
        ret["comment"] = "\n".join(
            [
                _f
                for _f in [
                    f"The service {name} is already running",
                    unmask_ret["comment"],
                ]
                if _f
            ]
        )
        if enable is True and not before_toggle_enable_status:
            ret.update(_enable(name, None, **kwargs))
        elif enable is False and before_toggle_enable_status:
            ret.update(_disable(name, None, **kwargs))
        return ret

    # Run the tests
    if __opts__["test"]:
        ret["result"] = None
        ret["comment"] = "\n".join(
            [
                _f
                for _f in [
                    f"Service {name} is set to start",
                    unmask_ret["comment"],
                ]
                if _f
            ]
        )
        return ret

    # Conditionally add systemd-specific args to call to service.start
    start_kwargs, warnings = _get_systemd_only(__salt__["service.start"], kwargs)
    if warnings:
        _add_warnings(ret, warnings)

    if salt.utils.platform.is_windows() and kwargs.get("timeout", False):
        start_kwargs.update({"timeout": kwargs.get("timeout")})

    # macOS and Windows services cant be started if they are disabled. So we need
    # to enable them prior to starting otherwise we will always fail.
    macos = salt.utils.platform.is_darwin()
    windows = salt.utils.platform.is_windows()
    if (macos or windows) and not before_toggle_enable_status:
        # fail if enable isn't set.
        if not enable:
            ret["comment"] = (
                "The service {} is disabled but enable is not True. Set "
                "enable to True to successfully start the service.".format(name)
            )
            ret["result"] = False
            return ret
        ret.update(_enable(name, None, **kwargs))
        # we've already enabled we don't need to enable again later.
        enable = None

    try:
        func_ret = __salt__["service.start"](name, **start_kwargs)
    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret

    if not func_ret:
        ret["result"] = False
        ret["comment"] = f"Service {name} failed to start"
        if enable is True:
            ret.update(_enable(name, False, result=False, **kwargs))
        elif enable is False:
            ret.update(_disable(name, False, result=False, **kwargs))
        return ret

    if init_delay:
        time.sleep(init_delay)

    # only force a change state if we have explicitly detected them
    after_toggle_status = __salt__["service.status"](name, sig, **status_kwargs)
    if "service.enabled" in __salt__:
        after_toggle_enable_status = __salt__["service.enabled"](name)
    else:
        after_toggle_enable_status = True
    if (
        (before_toggle_enable_status != after_toggle_enable_status)
        or (before_toggle_status != after_toggle_status)
    ) and not ret.get("changes", {}):
        ret["changes"][name] = after_toggle_status

    if after_toggle_status:
        ret["comment"] = f"Started service {name}"
    else:
        ret["comment"] = f"Service {name} failed to start"
        ret["result"] = False

    if enable is True:
        ret.update(
            _enable(name, after_toggle_status, result=after_toggle_status, **kwargs)
        )
    elif enable is False:
        ret.update(
            _disable(name, after_toggle_status, result=after_toggle_status, **kwargs)
        )

    if init_delay:
        ret["comment"] = "{}\nDelayed return for {} seconds".format(
            ret["comment"], init_delay
        )

    if kwargs.get("unmask", False):
        ret["comment"] = "\n".join([ret["comment"], unmask_ret["comment"]])

    return ret


def dead(name, enable=None, sig=None, init_delay=None, **kwargs):
    """
    Ensure that the named service is dead by stopping the service if it is running

    name
        The name of the init or rc script used to manage the service

    enable
        Set the service to be enabled at boot time, ``True`` sets the service
        to be enabled, ``False`` sets the named service to be disabled. The
        default is ``None``, which does not enable or disable anything.

    sig
        The string to search for when looking for the service process with
        ``ps``. The lookup uses an unanchored substring match against the
        process command line, so embedded shell metacharacters (``()``,
        ``|``, ``&``, ``;``, ``$``, backticks, quotes, etc.) are matched
        literally. Prefer a substring of the actual executable name.

    init_delay
        Add a sleep command (in seconds) before the check to make sure service
        is killed.

        .. versionadded:: 2017.7.0

    no_block : False
        **For systemd minions only.** Stops the service using ``--no-block``.

        .. versionadded:: 2017.7.0

    timeout
        **For Windows minions only.**

        The time in seconds to wait for the service to stop before returning.
        Default is the default for :py:func:`win_service.stop
        <salt.modules.win_service.stop>`.

        .. versionadded:: 2017.7.9,2018.3.4

    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    # used to let execution modules know which service state is being run.
    __context__["service.state"] = "dead"

    # Check for common error: using enabled option instead of enable
    if "enabled" in kwargs:
        return _enabled_used_error(ret)

    # Convert enable to boolean in case user passed a string value
    if isinstance(enable, str):
        enable = salt.utils.data.is_true(enable)

    if _offline():
        ret["result"] = True
        ret["comment"] = "Running in OFFLINE mode. Nothing to do"
        return ret

    # Check if the service is available
    try:
        if not _available(name, ret):
            if __opts__.get("test"):
                ret["result"] = None
                ret["comment"] = (
                    "Service {} not present; if created in this state run, "
                    "it would have been stopped".format(name)
                )
            else:
                # A non-available service is OK here, don't let the state fail
                # because of it.
                ret["result"] = True
            return ret
    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret

    status_kwargs, warnings = _get_systemd_only(__salt__["service.status"], kwargs)
    if warnings:
        _add_warnings(ret, warnings)

    # lot of custom init script won't or mis implement the status
    # command, so it is just an indicator but can not be fully trusted
    before_toggle_status = __salt__["service.status"](name, sig, **status_kwargs)
    if "service.enabled" in __salt__:
        if salt.utils.platform.is_windows():
            # service.enabled in Windows returns True for services that are set
            # to Auto start, but services set to Manual can also be disabled
            before_toggle_enable_status = __salt__["service.info"](name)[
                "StartType"
            ] in ["Auto", "Manual"]
        else:
            before_toggle_enable_status = __salt__["service.enabled"](name)
    else:
        before_toggle_enable_status = True

    # See if the service is already dead
    if not before_toggle_status:
        ret["comment"] = f"The service {name} is already dead"
        if enable is True and not before_toggle_enable_status:
            ret.update(_enable(name, None, **kwargs))
        elif enable is False and before_toggle_enable_status:
            ret.update(_disable(name, None, **kwargs))
        return ret

    # Run the tests
    if __opts__["test"]:
        ret["result"] = None
        ret["comment"] = f"Service {name} is set to be killed"
        return ret

    # Conditionally add systemd-specific args to call to service.start
    stop_kwargs, warnings = _get_systemd_only(__salt__["service.stop"], kwargs)
    if warnings:
        _add_warnings(ret, warnings)

    if salt.utils.platform.is_windows() and kwargs.get("timeout", False):
        stop_kwargs.update({"timeout": kwargs.get("timeout")})

    func_ret = __salt__["service.stop"](name, **stop_kwargs)
    if not func_ret:
        ret["result"] = False
        ret["comment"] = f"Service {name} failed to die"
        if enable is True:
            ret.update(_enable(name, True, result=False, **kwargs))
        elif enable is False:
            ret.update(_disable(name, True, result=False, **kwargs))
        return ret

    if init_delay:
        time.sleep(init_delay)

    # only force a change state if we have explicitly detected them
    after_toggle_status = __salt__["service.status"](name, **status_kwargs)
    if "service.enabled" in __salt__:
        after_toggle_enable_status = __salt__["service.enabled"](name)
    else:
        after_toggle_enable_status = True
    if (
        (before_toggle_enable_status != after_toggle_enable_status)
        or (before_toggle_status != after_toggle_status)
    ) and not ret.get("changes", {}):
        ret["changes"][name] = after_toggle_status

    # be sure to stop, in case we mis detected in the check
    if after_toggle_status:
        ret["result"] = False
        ret["comment"] = f"Service {name} failed to die"
    else:
        ret["comment"] = f"Service {name} was killed"

    if enable is True:
        ret.update(
            _enable(name, after_toggle_status, result=not after_toggle_status, **kwargs)
        )
    elif enable is False:
        ret.update(
            _disable(
                name, after_toggle_status, result=not after_toggle_status, **kwargs
            )
        )

    return ret


def enabled(name, **kwargs):
    """
    Ensure that the service is enabled on boot, only use this state if you
    don't want to manage the running process, remember that if you want to
    enable a running service to use the enable: True option for the running
    or dead function.

    name
        The name of the init or rc script used to manage the service
    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    # used to let execution modules know which service state is being run.
    __context__["service.state"] = "enabled"

    ret.update(_enable(name, None, **kwargs))
    if (
        __opts__.get("test")
        and ret.get("comment") == f"The named service {name} is not available"
    ):
        ret["result"] = None
        ret["comment"] = (
            "Service {} not present; if created in this state run, "
            "it would have been enabled".format(name)
        )
    return ret


def disabled(name, **kwargs):
    """
    Ensure that the service is disabled on boot, only use this state if you
    don't want to manage the running process, remember that if you want to
    disable a service to use the enable: False option for the running or dead
    function.

    name
        The name of the init or rc script used to manage the service
    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    # used to let execution modules know which service state is being run.
    __context__["service.state"] = "disabled"

    ret.update(_disable(name, None, **kwargs))
    return ret


def masked(name, runtime=False):
    """
    .. versionadded:: 2017.7.0

    .. note::
        This state is only available on minions which use systemd_.

    Ensures that the named service is masked (i.e. prevented from being
    started).

    .. note::
        If the service is currently enabled, it should be disabled first
        using :py:func:`service.disabled <salt.states.service.disabled>`
        before masking. Attempting to mask an enabled service may result
        in a systemd error.

    name
        Name of the service to mask

    runtime : False
        By default, this state will manage an indefinite mask for the named
        service. Set this argument to ``True`` to runtime mask the service.

    .. note::
        It is possible for a service to have both indefinite and runtime masks
        set for it. Therefore, this state will manage a runtime or indefinite
        mask independently of each other. This means that if the service is
        already indefinitely masked, running this state with ``runtime`` set to
        ``True`` will _not_ remove the indefinite mask before setting a runtime
        mask. In these cases, if it is desirable to ensure that the service is
        runtime masked and not indefinitely masked, pair this state with a
        :py:func:`service.unmasked <salt.states.service.unmasked>` state, like
        so:

        .. code-block:: yaml

            mask_runtime_foo:
              service.masked:
                - name: foo
                - runtime: True

            unmask_indefinite_foo:
              service.unmasked:
                - name: foo
                - runtime: False

    .. _systemd: https://freedesktop.org/wiki/Software/systemd/

    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    if "service.masked" not in __salt__:
        ret["comment"] = "Service masking not available on this minion"
        ret["result"] = False
        return ret

    mask_type = "runtime masked" if runtime else "masked"
    expected_changes = {mask_type: {"old": False, "new": True}}

    try:
        if __salt__["service.masked"](name, runtime):
            ret["comment"] = "Service {} is already {}".format(
                name,
                mask_type,
            )
            return ret

        if __opts__["test"]:
            ret["result"] = None
            ret["changes"] = expected_changes
            ret["comment"] = f"Service {name} would be {mask_type}"
            return ret

        __salt__["service.mask"](name, runtime)

        if __salt__["service.masked"](name, runtime):
            ret["changes"] = expected_changes
            ret["comment"] = f"Service {name} was {mask_type}"
        else:
            ret["comment"] = f"Failed to mask service {name}"
        return ret

    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret


def unmasked(name, runtime=False):
    """
    .. versionadded:: 2017.7.0

    .. note::
        This state is only available on minions which use systemd_.

    Ensures that the named service is unmasked

    name
        Name of the service to unmask

    runtime : False
        By default, this state will manage an indefinite mask for the named
        service. Set this argument to ``True`` to ensure that the service is
        runtime masked.

    .. note::
        It is possible for a service to have both indefinite and runtime masks
        set for it. Therefore, this state will manage a runtime or indefinite
        mask independently of each other. This means that if the service is
        indefinitely masked, running this state with ``runtime`` set to
        ``True`` will _not_ remove the indefinite mask.

    .. _systemd: https://freedesktop.org/wiki/Software/systemd/

    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    if "service.masked" not in __salt__:
        ret["comment"] = "Service masking not available on this minion"
        ret["result"] = False
        return ret

    mask_type = "runtime masked" if runtime else "masked"
    action = "runtime unmasked" if runtime else "unmasked"
    expected_changes = {mask_type: {"old": True, "new": False}}

    try:
        if not __salt__["service.masked"](name, runtime):
            ret["comment"] = f"Service {name} was already {action}"
            return ret

        if __opts__["test"]:
            ret["result"] = None
            ret["changes"] = expected_changes
            ret["comment"] = f"Service {name} would be {action}"
            return ret

        __salt__["service.unmask"](name, runtime)

        if not __salt__["service.masked"](name, runtime):
            ret["changes"] = expected_changes
            ret["comment"] = f"Service {name} was {action}"
        else:
            ret["comment"] = f"Failed to unmask service {name}"
        return ret

    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret


def mod_watch(
    name,
    sfun=None,
    sig=None,
    reload=False,
    full_restart=False,
    init_delay=None,
    force=False,
    **kwargs,
):
    """
    The service watcher, called to invoke the watch command.
    When called, it will restart or reload the named service.

    .. note::
        This state exists to support special handling of the ``watch``
        :ref:`requisite <requisites>`. It should not be called directly.

        Parameters for this function should be set by the watching service
        (e.g. ``service.running``).

    name
        The name of the service to control.

    sfun
        The original function which triggered the mod_watch call
        (`service.running`, for example).

    sig
        The string to search for when looking for the service process with ps.

    reload
        When set, reload the service instead of restarting it
        (e.g. ``service nginx reload``).

    full_restart
        Perform a full stop/start of a service by passing ``--full-restart``.
        This option is ignored if ``reload`` is set and is supported by only a few
        :py:func:`service modules <salt.modules.service>`.

    force
        Use service.force_reload instead of reload (needs reload to be set to True).

    init_delay
        Add a sleep command (in seconds) before the service is restarted/reloaded.
    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}
    past_participle = None

    status_kwargs, warnings = _get_systemd_only(__salt__["service.status"], kwargs)
    if warnings:
        _add_warnings(ret, warnings)

    if sfun == "dead":
        verb = "stop"
        past_participle = verb + "ped"
        if __salt__["service.status"](name, sig, **status_kwargs):
            func = __salt__["service.stop"]
        else:
            ret["result"] = True
            ret["comment"] = f"Service is already {past_participle}"
            return ret
    elif sfun == "running":
        if __salt__["service.status"](name, sig, **status_kwargs):
            if "service.reload" in __salt__ and reload:
                if "service.force_reload" in __salt__ and force:
                    func = __salt__["service.force_reload"]
                    verb = "forcefully reload"
                else:
                    func = __salt__["service.reload"]
                    verb = "reload"
            elif "service.full_restart" in __salt__ and full_restart:
                func = __salt__["service.full_restart"]
                verb = "fully restart"
            else:
                func = __salt__["service.restart"]
                verb = "restart"
        else:
            func = __salt__["service.start"]
            verb = "start"
        if not past_participle:
            past_participle = verb + "ed"
    else:
        ret["comment"] = f"Unable to trigger watch for service.{sfun}"
        ret["result"] = False
        return ret

    if __opts__["test"]:
        ret["result"] = None
        ret["comment"] = f"Service is set to be {past_participle}"
        return ret

    if verb == "start" and "service.stop" in __salt__:
        # stop service before start
        __salt__["service.stop"](name)

    func_kwargs, warnings = _get_systemd_only(func, kwargs)
    if warnings:
        _add_warnings(ret, warnings)

    try:
        result = func(name, **func_kwargs)
    except CommandExecutionError as exc:
        ret["result"] = False
        ret["comment"] = exc.strerror
        return ret

    if init_delay:
        time.sleep(init_delay)

    ret["changes"] = {name: result}
    ret["result"] = result
    ret["comment"] = (
        f"Service {past_participle}" if result else f"Failed to {verb} the service"
    )
    return ret


def mod_beacon(name, **kwargs):
    """
    Create a beacon to monitor a service based on a beacon state argument.

    .. note::
        This state exists to support special handling of the ``beacon``
        state argument for supported state functions. It should not be called directly.
    """
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

    sfun = kwargs.pop("sfun", None)
    supported_funcs = ["running", "dead"]

    if sfun in supported_funcs:
        if kwargs.get("beacon"):
            beacon_module = "service"

            data = {}
            _beacon_data = kwargs.get("beacon_data", {})

            data["onchangeonly"] = _beacon_data.get("onchangeonly", True)
            data["delay"] = _beacon_data.get("delay", 0)
            data["emitatstartup"] = _beacon_data.get("emitatstartup", False)
            data["uncleanshutdown"] = _beacon_data.get("emitatstartup", None)

            beacon_name = f"beacon_{beacon_module}_{name}"

            beacon_kwargs = {
                "name": beacon_name,
                "services": {name: data},
                "interval": _beacon_data.get("interval", 60),
                "beacon_module": beacon_module,
            }

            ret = __states__["beacon.present"](**beacon_kwargs)
            return ret
        else:
            return {
                "name": name,
                "changes": {},
                "comment": "Not adding beacon.",
                "result": True,
            }
    else:
        return {
            "name": name,
            "changes": {},
            "comment": "service.{} does not work with the beacon state function".format(
                sfun
            ),
            "result": False,
        }
