daemonizer-py 1.5.1__py3-none-any.whl

daemonizer/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI sub-module"""

daemonizer/cli/commands.py

@@ -0,0 +1,287 @@
+"""CLI commands"""
+
+import glob
+import signal
+from pathlib import Path
+from typing import List, Tuple
+
+import click
+
+from daemonizer.cli.daemon_loader import find_daemon_classes, load_module_from_script
+from daemonizer.cli.processor import _cli_parse_daemons, _stop_pid
+from daemonizer.constants import APP_NAME, APP_VERSION
+from daemonizer.core.daemons.flags import RESTART, START, STATUS, STOP
+from daemonizer.files import PID_FILES_DIR
+from daemonizer.utils.logs import get_logger
+from daemonizer.utils.process import is_active_process
+
+logger = get_logger(__name__)
+
+
+# Entry point
+@click.group()
+def cli() -> None:
+    """
+    CLI entry point
+    """
+    pass
+
+
+# Command: $ daemonizer version
+@cli.command()
+def version() -> None:
+    """
+    Version info
+    """
+    click.echo(f"{APP_NAME} v{APP_VERSION}")
+
+
+# Command: $ daemonizer start
+@cli.command()
+@click.argument(
+    "script",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    required=True,
+)
+@click.argument("daemons", type=click.STRING, required=False, nargs=-1)
+@click.option(
+    "--strict/--no-strict",
+    "-s",
+    type=click.BOOL,
+    is_flag=True,
+    required=False,
+    default=True,
+)
+def start(script: str, daemons: Tuple[str, ...], strict: bool) -> None:
+    """
+    Start daemons (CLI target)
+    """
+    _cli_parse_daemons(script, list(daemons), START, strict)
+
+
+# Command: $ daemonizer stop
+@cli.command()
+@click.argument(
+    "script",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    required=True,
+)
+@click.argument("daemons", type=click.STRING, required=False, nargs=-1)
+@click.option(
+    "--strict/--no-strict",
+    "-s",
+    type=click.BOOL,
+    is_flag=True,
+    required=False,
+    default=True,
+)
+def stop(script: str, daemons: Tuple[str, ...], strict: bool) -> None:
+    """
+    Stop daemons (CLI target)
+    """
+    _cli_parse_daemons(script, list(daemons), STOP, strict)
+
+
+# Command: $ daemonizer restart
+@cli.command()
+@click.argument(
+    "script",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    required=True,
+)
+@click.argument("daemons", type=click.STRING, required=False, nargs=-1)
+@click.option(
+    "--strict/--no-strict",
+    "-s",
+    type=click.BOOL,
+    is_flag=True,
+    required=False,
+    default=True,
+)
+def restart(script: str, daemons: Tuple[str, ...], strict: bool) -> None:
+    """
+    Restart daemons (CLI target)
+    """
+    _cli_parse_daemons(script, list(daemons), RESTART, strict)
+
+
+# Command: $ daemonizer status
+@cli.command()
+@click.argument(
+    "script",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    required=True,
+)
+@click.argument("daemons", type=click.STRING, required=False, nargs=-1)
+@click.option(
+    "--strict/--no-strict",
+    "-s",
+    type=click.BOOL,
+    is_flag=True,
+    required=False,
+    default=True,
+)
+def status(script: str, daemons: Tuple[str, ...], strict: bool) -> None:
+    """
+    Restart daemons (CLI target)
+    """
+    _cli_parse_daemons(script, list(daemons), STATUS, strict)
+
+
+# Command: $ daemonizer scan
+@cli.command()
+@click.argument(
+    "script",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    required=True,
+)
+@click.option(
+    "--strict/--no-strict",
+    "-s",
+    type=click.BOOL,
+    is_flag=True,
+    required=False,
+    default=True,
+)
+def scan(script: str, strict: bool) -> None:
+    """
+    Scan daemons (CLI target)
+    """
+    click.echo(f"Scan | Script: {script} - Strict: {strict}")
+
+    module = load_module_from_script(script_path=script)
+
+    daemon_classes = find_daemon_classes(module=module, strict=strict)
+    click.echo(f"Found {len(daemon_classes)} daemon classes")
+    for i, daemon_class in enumerate(daemon_classes):
+        click.echo(
+            f"{i + 1} \t {daemon_class.__name__} - (module: {daemon_class.__module__})"
+        )
+
+
+# Command: $ daemonizer stop-pid
+@cli.command()
+@click.argument("pids", type=click.INT, required=False, nargs=-1)
+@click.option(
+    "--signal",
+    "-g",
+    type=click.INT,
+    is_flag=False,
+    required=False,
+    default=signal.SIGTERM,
+)
+def stop_pid(pids: Tuple[int, ...], signal: int) -> None:
+    """
+    Stop daemons via PID input.
+    This command is recommended if you already have the daemon's PID.
+    On signal reception, daemon will kill stop itself, clean the on-disk PID file and stop the process.
+    :param pids: PIDs
+    :type pids: Tuple[int, ...]
+    :param signal: Signal to be used
+    :type signal: int
+    """
+    click.echo("Stop pids: " + str(pids))
+
+    for pid in pids:
+        if pid <= 0:
+            click.echo("PID must be strictly greater than 0")
+            return None
+
+    # TODO: check on signal input
+
+    for pid in pids:
+        _stop_pid(pid=pid, sig=signal)
+    return None
+
+
+# Command: $ daemonizer stop-name
+@cli.command()
+@click.argument("names", type=click.STRING, required=False, nargs=-1)
+@click.option(
+    "--signal",
+    "-g",
+    type=click.INT,
+    is_flag=False,
+    required=False,
+    default=signal.SIGTERM,
+)
+def stop_name(names: Tuple[str, ...], signal: int) -> None:
+    """
+    Stop daemons via daemon's name input.
+    This command is recommended if you already have the daemon names.
+    """
+    click.echo("Stop daemon names: " + str(names))
+
+    for daemon_name in names:
+        pid: int = -1
+
+        # Cleaning daemon name
+        if daemon_name.endswith(".pid"):
+            daemon_name = daemon_name.replace(".pid", "")
+
+        # Getting daemon name
+        p = PID_FILES_DIR / Path(daemon_name + ".pid")
+
+        if p.exists():
+            with open(p.absolute(), "r") as f:
+                pid = int(f.readline().strip())
+                _stop_pid(pid=pid, sig=signal)
+        else:
+            click.echo(f"PID file for this daemon's name: {daemon_name} does not exist")
+
+
+# Command: $ daemonizer ls
+@cli.command()
+def ls() -> None:
+    """
+    Listing all daemons currently found
+    """
+    pattern = PID_FILES_DIR / "*.pid"
+    found_daemons: List[str] = sorted(glob.glob(pattern.__str__()))
+
+    for i, daemon in enumerate(found_daemons):
+        pidfile: Path = Path(daemon).absolute()
+
+        daemon_name: str = pidfile.stem
+
+        with open(pidfile.absolute(), "r") as f:
+            pid = int(f.readline().strip())
+
+        is_active_daemon: bool = is_active_process(pid_=pid)
+        click.echo(
+            f"({i + 1}) {daemon_name} | PID := {pid} | Active?: {is_active_daemon}"
+        )
+
+
+# Command: $ daemonizer pidfiles
+@cli.command()
+def pidfiles() -> None:
+    """
+    Get pid files folder. This can be used to `cd $(daemonizer pidfiles)`
+    """
+    click.echo(PID_FILES_DIR.__str__())

daemonizer/cli/daemon_loader.py

@@ -0,0 +1,148 @@
+"""Core logic to:
+(1) scan external Python scripts requested by CLI users when interacting with daemons,
+(2) collect all classes inheriting from Daemon or UNIXDaemon base classes
+(3) Instantiate one object per class found to start these daemons when CLI users request it
+"""
+
+import importlib.util
+import inspect
+from _frozen_importlib import ModuleSpec
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Dict, List, Type
+
+from daemonizer.core.daemons.base import Daemon
+from daemonizer.core.daemons.unix import UNIXDaemon
+from daemonizer.utils.logs import get_logger
+
+logger = get_logger(__name__)
+
+
+def load_module_from_script(script_path: Path | str | None = None) -> ModuleType | None:
+    """
+    Function to load a specific module from a given input Python script.
+    This function is using **importlib** (docs: https://docs.python.org/3/library/importlib.html)
+    and **pathlib** (docs: https://docs.python.org/3/library/pathlib.html).
+    :param script_path: Input script path
+    :type script_path: Path | str | None
+    :return: Module object imported via importlib.util if successful, None otherwise
+    :rtype: ModuleType | None
+    """
+
+    if script_path is None:
+        return None
+
+    if isinstance(script_path, str):
+        script_path = Path(script_path)
+
+    # Making the path absolute, resolving all symlinks
+    path: Path = script_path.resolve()
+
+    # Checking extension (.py)
+    extension: str = "".join(path.suffixes)
+    if extension not in [".py", ".pyi"]:
+        logger.error(f"Script extension {extension} not supported")
+        return None
+
+    # Module name (final path component, without its suffix)
+    module_name = path.stem
+
+    logger.info(f"Loading module {module_name} from script {path.absolute()}")
+
+    # A factory function for creating a ModuleSpec instance based on the path to a file
+    # ModuleSpec := A specification for a module’s import-system-related state
+    spec: ModuleSpec | None = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None:
+        logger.error("Module spec import failed (importlib)")
+        return None
+
+    # Create a new module based on spec
+    module: ModuleType | None = importlib.util.module_from_spec(spec)
+
+    if module is None:
+        logger.error("Module creation from spec failed (importlib)")
+        return None
+
+    # spec.loader (:= an object that loads a module)
+    if spec.loader is None:
+        logger.error("Module creation from spec failed (importlib)")
+        return None
+
+    # Loading module in current context
+    # (executes the module in its own namespace when a module is imported or reloaded)
+    spec.loader.exec_module(module=module)
+    return module
+
+
+def find_daemon_classes(
+    module: ModuleType | None = None, strict: bool = True
+) -> List[Type]:
+    """
+    Function to scan input module and collect + return a list of specific daemon classes.
+    Module scan is performed using the **inspect** module (docs: https://docs.python.org/3/library/inspect.html)
+    :param module: Input module
+    :type module: ModuleType | None
+    :param strict: Return only (True) the classes from the script itself (not those imported to the script from other sub-modules/dependencies)
+    :type strict: bool
+    :return: List of daemon classes
+    :rtype: List[Type]
+    """
+
+    daemons: List[Type] = []
+    if module is None or not isinstance(module, ModuleType):
+        logger.error("Input module is invalid")
+        return daemons
+
+    # Checking all module members (docs: https://docs.python.org/3/library/inspect.html#inspect.getmembers)
+    for e, cls in inspect.getmembers(module, inspect.isclass):
+        # Skipping UNIXDaemon itself (not relevant)
+        if cls is UNIXDaemon or cls is Daemon:
+            continue
+
+        # TODO: Handle c-tor arguments (inspect.signature)
+        if issubclass(cls, UNIXDaemon):  # mro check otherwise
+            if strict:
+                # Handling case where we only want daemons from the script itself (not from its dependencies)
+                if cls.__module__ != module.__name__:
+                    continue
+            # print(f"Sig: {inspect.signature(cls).parameters["name"].annotation}")
+            daemons.append(cls)
+
+    return daemons
+
+
+def get_daemon_instances(
+    daemons: List[Type] | None = None,
+    only_includes: Dict[str, str] | None = None,
+    script_path: Path | None = None,
+) -> List[Any]:
+    """
+    Function to get daemon instances from daemon classes
+    :param daemons: Input daemon classes
+    :type daemons: List[Type] | None
+    :param only_includes: Dict of daemon classes (and daemon names) to be included only if found in the module (by func fun: `find_daemon_classes`)
+    :type only_includes: List[str] | None
+    :param script_path: Input script path (used to get a default daemon name in case a given daemon class (from CLI input) does not have a respective daemon name
+    :type script_path: Path | None
+    :return: List of daemon objects (1 y input daemon class)
+    :rtype: List[Any]
+    """
+
+    daemon_instances: List[Any] = []
+    if daemons is None:
+        logger.error("Input daemon classes are invalid")
+        return daemon_instances
+
+    if script_path is None:
+        logger.error("Input script path is invalid")
+        return daemon_instances
+
+    for daemon in daemons:
+        daemon_name: str = script_path.stem + daemon.__name__ + "_daemon"
+        if only_includes:
+            if daemon.__name__ not in only_includes.keys():
+                continue
+            # TODO: Handle constructor with daemon name
+            daemon_name = only_includes.get(daemon.__name__, "")
+        daemon_instances.append(daemon(name=daemon_name))
+    return daemon_instances

daemonizer/cli/processor.py

@@ -0,0 +1,212 @@
+"""Submodule to initialize and manage the bridge between CLI inputs and operations on daemons"""
+
+import os
+import signal
+from pathlib import Path
+from typing import Callable, Dict, List
+
+import click
+
+from daemonizer.cli.daemon_loader import (
+    find_daemon_classes,
+    get_daemon_instances,
+    load_module_from_script,
+)
+from daemonizer.core.daemons.flags import (
+    DEFAULT_FLAG,
+    FLAGS,
+    RESTART,
+    START,
+    STATUS,
+    STOP,
+)
+from daemonizer.core.handlers.ctx_manager import DaemonHandler
+from daemonizer.utils.logs import get_logger
+
+logger = get_logger(__name__)
+
+
+def _cli_parse_daemons(
+    script: str | Path | None = None,
+    exclusive_daemon_classes_names: List[str] | None = None,
+    flag_operation: int = DEFAULT_FLAG,
+    strict: bool = True,
+) -> None:
+    """
+    This function will parse the CLI request including:
+    - input script path
+    - specific daemons to run or everything found
+    - operation to apply on these daemons
+    :param script: Input script path
+    :type script: str | Path | None
+    :param exclusive_daemon_classes_names: Dict of specific daemon classes (and names for daemons to be named) to be run (against the logic scanned from the module). If nothing is specified, all daemons from the module must be considered.
+    :type exclusive_daemon_classes_names: List[str] | None
+    :param flag_operation: Flag of the operation to perform on considered daemons
+    :type flag_operation: int
+    :param strict: True if only daemons from current modules should be considered, False otherwise (all daemons including from dependencies)
+    :type strict: bool
+    :return: Nothing
+    :rtype: None
+    """
+
+    if script is None:
+        return None
+
+    if isinstance(script, str):
+        script = Path(script)
+
+    # Checking if we have clean daemons CLI input before proceeding
+    if not _checking_cli_input_daemons(exclusive_daemon_classes_names):
+        return None
+
+    if isinstance(exclusive_daemon_classes_names, tuple):
+        exclusive_daemon_classes_names = list(exclusive_daemon_classes_names)
+
+    assert isinstance(exclusive_daemon_classes_names, list), "Daemons must be a list"
+
+    exclusive_daemon_classes: List[str] = [
+        exclusive_daemon_classes_names[k]
+        for k in range(len(exclusive_daemon_classes_names))
+        if k % 2 == 0
+    ]
+    exclusive_daemon_names: List[str] = [
+        exclusive_daemon_classes_names[k]
+        for k in range(len(exclusive_daemon_classes_names))
+        if k % 2 == 1
+    ]
+    d_exclusive_daemon_classes_names: Dict[str, str] = dict(
+        zip(exclusive_daemon_classes, exclusive_daemon_names)
+    )
+
+    # Loading module
+    module = load_module_from_script(script_path=script)
+
+    # Finding daemon classes in module
+    found_daemon_classes = find_daemon_classes(module=module, strict=strict)
+    click.echo(f"Classes: {found_daemon_classes}")
+
+    # Getting daemon instances
+    daemon_instances = get_daemon_instances(
+        daemons=found_daemon_classes,
+        only_includes=d_exclusive_daemon_classes_names,
+        script_path=script,
+    )
+    click.echo(f"Instances: {daemon_instances}")
+
+    # Getting correct operation from input flag
+    func_name: str = _get_op_func_from_flag2(flag_operation=flag_operation)
+
+    # TODO: Adding context handler here instead of _get_op_func_from_flag
+    with DaemonHandler() as h:
+        for daemon_instance in daemon_instances:
+            getattr(h, func_name)(daemon_instance)
+        # func(h)()
+    # For each daemon instances, execute the given function
+    # for daemon_instance in daemon_instances:
+    # getattr(daemon_instance, func)()
+    # daemon_instance.func()
+    #    func(
+    #        daemon_instance
+    #    )  # clean form as we have a lambda func whose unique parameter is the daemon instance itself
+    return None
+
+
+def _get_op_func_from_flag(flag_operation: int) -> Callable:
+    """
+    (Not used as we are using the `DaemonHandler` context manager)
+    This function will return a function that will run the specified operation,
+    translated from the input flag operation. This is somehow a *mapping* function
+    :param flag_operation: Valid input flag operation
+    :type flag_operation: int
+    :return: Lambda function that will run the specified operation once called with a valid `Daemon` instance
+    :rtype: Callable
+    """
+    if flag_operation not in FLAGS:
+        return lambda _: None
+
+    if flag_operation == START:
+        return lambda x: x.start()
+    elif flag_operation == STOP:
+        return lambda x: x.stop()
+    elif flag_operation == STATUS:
+        return lambda x: x.status()
+    elif flag_operation == RESTART:
+        return lambda x: x.restart()
+    else:
+        return lambda x: None
+
+
+def _get_op_func_from_flag2(flag_operation: int) -> str:
+    """
+    (Not used as we are using the `DaemonHandler` context manager)
+    This function will return a function that will run the specified operation,
+    translated from the input flag operation. This is somehow a *mapping* function
+    :param flag_operation: Valid input flag operation
+    :type flag_operation: int
+    :return: Function name that will run the specified operation once called with a valid `Daemon` instance
+    :rtype: str
+    """
+    if flag_operation not in FLAGS:
+        return ""
+
+    if flag_operation == START:
+        return "start"
+    elif flag_operation == STOP:
+        return "stop"
+    elif flag_operation == STATUS:
+        return "status"
+    elif flag_operation == RESTART:
+        return "restart"
+    else:
+        return ""
+
+
+def _checking_cli_input_daemons(cli_input_daemons: List[str] | None = None) -> bool:
+    """
+    Function to check daemons from CLI input
+    Daemons to be considered for given
+    :param cli_input_daemons: Daemons classes + names from input CLI entry
+    :type cli_input_daemons: List[str] | None
+    :return: True if CLI entry is valid, False otherwise
+    :rtype: bool
+    """
+
+    if cli_input_daemons is None:
+        return False
+    if len(cli_input_daemons) != 0:
+        if len(cli_input_daemons) % 2 != 0:
+            click.echo(
+                "You must follow pattern: DaemonClass1, DaemonName1, DaemonClass2, DaemonName2, ..., DaemonClassN, DaemonNameN"
+            )
+            return False
+    else:
+        click.echo("You must add the list of daemon classes and names")
+        return False
+    return True
+
+
+def _stop_pid(pid: int | None = None, sig: int = signal.SIGTERM) -> bool:
+    """
+    Function to stop a given process for the specified PID, by sending the input sig (POSIX signal)
+    :param pid: PID of the process to stop
+    :type pid: int | None
+    :param sig: Signal to send to daemon
+    :type sig: int
+    :return: True if process was stopped, False otherwise
+    :rtype: bool
+    """
+
+    if pid is None:
+        logger.error("PID must be provided")
+        return False
+    if not isinstance(pid, int):
+        logger.error("PID must be a valid integer")
+        return False
+
+    try:
+        # Sending custom signal to process whose PID is matching
+        os.kill(pid, sig)
+        return True
+    except Exception as exc_:
+        logger.error(f"Failed to kill daemon for PID {pid}. Error: {exc_}")
+    return False

daemonizer/constants.py

@@ -0,0 +1,34 @@
+"""List of defined constants to be used in the project"""
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import List, Tuple
+
+APP_NAME: str = "daemonizer"
+
+PKG_NAME: str = f"{APP_NAME}-py"
+
+# Version dynamically updated via Makefile targets
+APP_VERSION: str = version(PKG_NAME)
+APP_VERSION_TUPLE: Tuple[int, ...] = tuple(map(int, APP_VERSION.split(".")))
+
+try:
+    __version__: str = version(PKG_NAME)
+except PackageNotFoundError:
+    __version__ = "unknown"  # "0.0.0"
+
+
+# UNIX system names
+UNIX_SYSTEM_NAMES: List[str] = [
+    "Linux",
+    "Darwin",
+    "FreeBSD",
+    "NetBSD",
+    "OpenBSD",
+    "SunOS",
+    "AIX",
+]
+
+DEFAULT_PID_FILENAME_LENGTH: int = 5
+
+# Start method to be used when creating child processes from `multiprocessing` module
+MULTIPROC_START_METHOD: str = "fork"

daemonizer/core/__init__.py

@@ -0,0 +1 @@
+"""Core logic"""

daemonizer/core/daemons/__init__.py

@@ -0,0 +1 @@
+"""Module to define and implement core logic for daemons"""