ansible-systemd/plugins/modules/target.py

#!/usr/bin/python3
import pathlib
from typing import List, Union

try:
    from ansible_collections.sebastian.systemd.plugins.module_utils.generic import SYSTEMD_SERVICE_CONFIG, Types, systemdbool
    from ansible_collections.sebastian.systemd.plugins.module_utils.module import SystemdReloadMixin, SystemdUnitModule, installable
except ImportError:
    from plugins.module_utils.generic import SYSTEMD_SERVICE_CONFIG, Types, systemdbool
    from plugins.module_utils.module import SystemdReloadMixin, SystemdUnitModule, installable

__module_name__ = "TargetModule"


@installable
class TargetModule(SystemdUnitModule, SystemdReloadMixin):
    """Creates Target units"""

    name = "target"
    module_spec = dict(
        argument_spec=dict(
            description=Types.str(help="description of the target"),
            name=Types.str(required=True, help="name of the target"),
            allow_isolate=Types.bool(
                default=False,
                help="allows admins to restrict the system to only start units that are wanted by this unit and subsequent units",
            ),
        ),
    )

    def prepare(self):
        self.unitfile = (SYSTEMD_SERVICE_CONFIG / self.get("name")).with_suffix(".target")
        self.__unit = None

    def header(self) -> str:
        section = super().header()
        section += "AllowIsolate={}\n".format(systemdbool(self.get("allow_isolate", False)))
        return section

    def unit(self) -> str:
        if self.__unit is None:
            self.__unit = "\n".join(
                (
                    self.header(),
                    self.install(),
                )
            )
        return self.__unit


DOCUMENTATION = """---
description:
- Creates Target units
module: target
options:
  after:
    default: []
    description:
    - list of units that this unit wants to be started after this unit
    elements: str
    required: false
    type: list
  allow_isolate:
    default: false
    description:
    - allows admins to restrict the system to only start units that are wanted by
      this unit and subsequent units
    required: false
    type: bool
  before:
    default: []
    description:
    - list of units that this unit needs to be started before this unit.
    elements: str
    required: false
    type: list
  description:
    description:
    - description of the target
    required: false
    type: str
  documentation:
    default: []
    description:
    - Paths where documentation can be found
    elements: str
    required: false
    type: list
  name:
    description:
    - name of the target
    required: true
    type: str
  partof:
    default: []
    description:
    - list of units that this unit is part of.
    - If the restart this unit does it too, but if this restarts it does not affect
      the other units.
    elements: str
    required: false
    type: list
  required_by:
    default: []
    description:
    - systemd units that require this mount
    elements: str
    required: false
    type: list
  requires:
    default: []
    description:
    - list of units that this unit requires. If it fails or can't be started this
      unit fails. without before/after this is started at the same time
    elements: str
    required: false
    type: list
  wanted_by:
    default: []
    description:
    - systemd units that want the mount, but not explicitly require it. Commonly used
      for target if not service explicitly require it.
    elements: str
    required: false
    type: list
  wants:
    default: []
    description:
    - list of units that this unit wants. If it fails or can't be started it does
      not affect this unit
    elements: str
    required: false
    type: list
short_description: Creates Target units
"""

if __name__ == "__main__":
    TargetModule()()