From 65cb1720c80515d1254b8d9e435a9d2c9880fd44 Mon Sep 17 00:00:00 2001 From: Sebastian Tobie Date: Fri, 21 Apr 2023 18:00:50 +0200 Subject: [PATCH] added an rudimentary systemd service module --- plugins/modules/system_service.py | 212 ++++++++++++++++++++++++++++++ 1 file changed, 212 insertions(+) create mode 100644 plugins/modules/system_service.py diff --git a/plugins/modules/system_service.py b/plugins/modules/system_service.py new file mode 100644 index 0000000..4ff2f6d --- /dev/null +++ b/plugins/modules/system_service.py @@ -0,0 +1,212 @@ +#!/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 + from ansible_collections.sebastian.systemd.plugins.module_utils.module import SystemdUnitModule +except ImportError: + from plugins.module_utils.generic import SYSTEMD_SERVICE_CONFIG, Types + from plugins.module_utils.module import SystemdUnitModule, installable + + +@installable +class Module(SystemdUnitModule): + """Creates System Services units""" + + name = "system_service" + module_spec = dict( + argument_spec=dict( + name=Types.str(required=True), + user=Types.str(), + group=Types.str(), + type=Types.str( + choices=("simple", "exec", "forking", "oneshot", "dbus", "notify", "notify-reload", "idle"), + default="simple", + help="Type of the systemd service.\n" + "simple and exec start long running services that run in the same process over the whole time, exec is waiting until the process was started completly.\n" + "forking does some things in the foreground, starts an background process and then exits to leave the work to the background process.\n" + "oneshot processes are started by systemd, do their work and then exit, similar to cronjobs.\n" + "dbus services will be considered started up once they aquire the specified dbus bus" + "notify and notify-reload notify systemd about the start up via sd_notify. notify-reload needs also inform systemd on reloads and when it is ready again after an reload.\n" + "idle is similar to simple, but it can delay the start up by a few seconds.", + ), + pre=Types.list(str, help="command or list of commands that are started before the main command(Types.str)"), + start=Types.list( + str, + True, + help="command or list of commands that are started as main programm. Multiple commands are only allowed in a oneshot command", + ), + post=Types.list(str, help="Command or list of commands that are started after the main command(s) stopped without problems."), + ), + ) + + def prepare(self): + self.unitfile = (SYSTEMD_SERVICE_CONFIG / self.get("name")).with_stem(".service") + if self.get("type", "simple") != "oneshot" and len(self.get("start")) > 1: + self.module.fail_json("only oneshot services are allowed to have multiple start commands", **self.result) + + def service(self): + section = "[Service]\n" + if self.get("type"): + section += "Type=".format(self.get("type")) + if self.get("pre", False): + for cmd in self.get("pre"): + section += "ExecStartPre={}".format(cmd) + if self.get("start", False): + for cmd in self.get("start"): + section += "ExecStart={}".format(cmd) + if self.get("post", False): + for cmd in self.get("post"): + section += "ExecStartPost={}".format(cmd) + if self.get("user", False): + section += "User={}".format(self.get("user")) + if self.get("group", False): + section += "Group={}".format(self.get("group")) + return section + + def unit(self) -> str: + if self.__unit is None: + self.__unit = "\n".join( + ( + self.header(), + self.service(), + self.install(), + ) + ) + return self.__unit + + +DOCUMENTATION = """--- +description: +- Creates System Services units +module: system_service +options: + after: + default: [] + description: + - list of units that this unit wants to be started after this unit + elements: str + required: false + type: list + before: + default: [] + description: + - list of units that this unit needs to be started before this unit. + elements: str + required: false + type: list + description: + description: + - An description for programs that access systemd + required: false + type: str + documentation: + default: [] + description: + - Paths where documentation can be found + elements: str + required: false + type: list + group: + required: false + type: str + name: + 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 + post: + default: [] + description: + - Command or list of commands that are started after the main command(s) stopped + without problems. + elements: str + required: false + type: list + pre: + default: [] + description: + - command or list of commands that are started before the main command(Types.str) + 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 + start: + description: + - command or list of commands that are started as main programm. Multiple commands + are only allowed in a oneshot command + elements: str + required: true + type: list + type: + choices: + - simple + - exec + - forking + - oneshot + - dbus + - notify + - notify-reload + - idle + default: simple + description: + - Type of the systemd service. + - simple and exec start long running services that run in the same process over + the whole time, exec is waiting until the process was started completly. + - forking does some things in the foreground, starts an background process and + then exits to leave the work to the background process. + - oneshot processes are started by systemd, do their work and then exit, similar + to cronjobs. + - dbus services will be considered started up once they aquire the specified dbus + busnotify and notify-reload notify systemd about the start up via sd_notify. + notify-reload needs also inform systemd on reloads and when it is ready again + after an reload. + - idle is similar to simple, but it can delay the start up by a few seconds. + required: false + type: str + user: + required: false + type: str + 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 System Services units +""" + +if __name__ == "__main__": + Module()()