python-dmon 0.2.0__py3-none-any.whl

dmon/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

dmon/cli.py

@@ -0,0 +1,232 @@
+import argparse
+import shlex
+import sys
+
+from colorama import just_fix_windows_console
+
+from .config import check_name_in_config, get_task_config
+from .control import list_processes, restart, start, stop, status
+from .constants import (
+    DEFAULT_META_DIR,
+    DEFAULT_RUN_NAME,
+    LOG_PATH_TEMPLATE,
+    META_PATH_TEMPLATE,
+    ROTATE_LOG_PATH_TEMPLATE,
+)
+from .types import DmonTaskConfig
+
+
+def main():
+    just_fix_windows_console()
+
+    parser = argparse.ArgumentParser(
+        prog="dmon",
+        description="Minimal cross-platform daemon manager",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # start subcommand
+    sp_start = subparsers.add_parser(
+        "start",
+        help="Start a configured task as a background process",
+        description="Start a configured task as a background process",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    sp_start.add_argument(
+        "name",
+        help="Configured task name (default: the only task if there's just one)",
+        nargs="?",
+    )
+    sp_start.add_argument(
+        "--meta-file",
+        help=f"Path to meta file (default: {META_PATH_TEMPLATE})",
+    )
+    sp_start.add_argument(
+        "--log-file",
+        help=f"Path to log file (default: task configured or {LOG_PATH_TEMPLATE})",
+    )
+
+    # stop subcommand
+    sp_stop = subparsers.add_parser(
+        "stop",
+        help="Stop a background process",
+        description="Stop a background process given name or meta file",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    sp_stop.add_argument(
+        "name",
+        help="Configured task name (default: the only task if there's just one)",
+        nargs="?",
+    )
+    sp_stop.add_argument("--meta-file", help="Path to meta file")
+
+    # restart subcommand
+    sp_restart = subparsers.add_parser(
+        "restart",
+        help="Restart a configured task as a background process",
+        description="Restart a configured task as a background process",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    sp_restart.add_argument(
+        "name",
+        help="Configured task name (default: the only task if there's just one)",
+        nargs="?",
+    )
+    sp_restart.add_argument(
+        "--meta-file",
+        help=f"Path to meta file (default: {META_PATH_TEMPLATE})",
+    )
+    sp_restart.add_argument(
+        "--log-file",
+        help=f"Path to log file (default: task configured or {LOG_PATH_TEMPLATE})",
+    )
+
+    # status subcommand
+    sp_status = subparsers.add_parser(
+        "status",
+        help="Check process status",
+        description="Check status of a background process given name or meta file",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    sp_status.add_argument(
+        "name",
+        help="Configured task name (default: the only task if there's just one)",
+        nargs="?",
+    )
+    sp_status.add_argument(
+        "--meta-file",
+        help=f"Path to meta file (default: {META_PATH_TEMPLATE})",
+    )
+
+    # list subcommand
+    sp_list = subparsers.add_parser(
+        "list",
+        help="List all processes and their status",
+        description="List all processes and their status managed by dmon in the given directory",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    sp_list.add_argument(
+        "dir",
+        help=f"Directory to look for meta files (default: {DEFAULT_META_DIR})",
+        nargs="?",
+    )
+    sp_list.add_argument(
+        "--full",
+        action="store_true",
+        help="Show full width without truncating column (default: False)",
+    )
+
+    # run subcommand
+    sp_run = subparsers.add_parser(
+        "run",
+        help="Run a custom task (not in config) as a background process",
+        description="Run a custom task (not in config) as a background process",
+        # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    sp_run.add_argument(
+        "--name",
+        "-n",
+        default=DEFAULT_RUN_NAME,
+        help=f"Name for this task (default: {DEFAULT_RUN_NAME})",
+    )
+    sp_run.add_argument(
+        "--cwd",
+        help="Working directory to run the command in (default: current directory)",
+        default="",
+    )
+    sp_run.add_argument(
+        "--shell", action="store_true", help="Run task in shell (default: False)"
+    )
+    sp_run.add_argument(
+        "--meta-file",
+        help=f"Path to meta file (default: {META_PATH_TEMPLATE})",
+    )
+    sp_run.add_argument(
+        "--log-file",
+        help=f"Path to log file (default: {LOG_PATH_TEMPLATE})",
+    )
+    sp_run.add_argument(
+        "--log-rotate",
+        action="store_true",
+        help="Whether to rotate log file (default: False)",
+    )
+    sp_run.add_argument(
+        "--rotate-log-path",
+        help=f"Path to rotation log file (default: {ROTATE_LOG_PATH_TEMPLATE})",
+    )
+    sp_run.add_argument(
+        "command_list",
+        metavar="command",
+        nargs=argparse.ONE_OR_MORE,
+        help="Command (with args) to run",
+    )
+
+    args = parser.parse_args()
+
+    if args.command in ["start", "restart"]:
+        sp = sp_start if args.command == "start" else sp_restart
+        try:
+            name, task_cfg = get_task_config(args.name)
+        except Exception as e:
+            sp.error(str(e))
+
+        task_cfg.meta_path = (
+            args.meta_file or task_cfg.meta_path or META_PATH_TEMPLATE.format(name=name)
+        )
+        task_cfg.log_path = (
+            args.log_file or task_cfg.log_path or LOG_PATH_TEMPLATE.format(name=name)
+        )
+        task_cfg.rotate_log_path = (
+            task_cfg.rotate_log_path or ROTATE_LOG_PATH_TEMPLATE.format(name=name)
+        )
+        if args.command == "start":
+            sys.exit(start(task_cfg))
+        else:
+            sys.exit(restart(task_cfg))
+    elif args.command in ["stop", "status"]:
+        sp = sp_stop if args.command == "stop" else sp_status
+        if args.meta_file:
+            meta_path = args.meta_file
+        else:
+            if args.name:
+                name = args.name
+            else:
+                try:
+                    name, _ = get_task_config(args.name)
+                except Exception as e:
+                    sp.error(str(e))
+            meta_path = META_PATH_TEMPLATE.format(name=name)
+        if args.command == "stop":
+            sys.exit(stop(meta_path))
+        else:
+            sys.exit(status(meta_path))
+    elif args.command == "list":
+        dir = args.dir or DEFAULT_META_DIR
+        sys.exit(list_processes(dir, args.full))
+    elif args.command == "run":
+        if not args.name:
+            sp_run.error("Please provide a non-empty name for the task.")
+        elif check_name_in_config(args.name):
+            sp_run.error(
+                f"Name '{args.name}' already exists in config. Please choose another name."
+            )
+
+        task_cfg = DmonTaskConfig(
+            name=args.name,
+            cmd=shlex.join(args.command_list) if args.shell else args.command_list,
+            cwd=args.cwd,
+            meta_path=args.meta_file or META_PATH_TEMPLATE.format(name=args.name),
+            log_path=args.log_file or LOG_PATH_TEMPLATE.format(name=args.name),
+            log_rotate=args.log_rotate,
+            rotate_log_path=args.rotate_log_path
+            or ROTATE_LOG_PATH_TEMPLATE.format(name=args.name),
+        )
+        sys.exit(start(task_cfg))
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

dmon/config.py

@@ -0,0 +1,195 @@
+import sys
+from pathlib import Path
+from typing import Dict, Optional, cast
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from .types import CmdType, DmonTaskConfig
+
+
+def find_pyproject_toml(start: Optional[Path] = None):
+    """
+    Search for pyproject.toml from the current directory (or specified directory) upwards.
+    Return a Path object if found.
+    """
+    start = start or Path.cwd()
+    current = start.resolve()
+
+    for parent in [current, *current.parents]:
+        candidate = parent / "pyproject.toml"
+        if candidate.is_file():
+            return candidate
+
+    # raise FileNotFoundError(f"No pyproject.toml found from {start} upwards.")
+
+
+def find_dmon_yaml(start: Optional[Path] = None):
+    """
+    Search for dmon.yaml / dmon.yml from the current directory (or specified directory) upwards.
+    Return a Path object if found.
+    """
+    start = start or Path.cwd()
+    current = start.resolve()
+
+    for parent in [current, *current.parents]:
+        for filename in ["dmon.yaml", "dmon.yml"]:
+            candidate = parent / filename
+            if candidate.is_file():
+                return candidate
+
+    # raise FileNotFoundError(f"No dmon.yaml or dmon.yml found from {start} upwards.")
+
+
+def load_config():
+    path = find_dmon_yaml()
+    if path:
+        import yaml
+
+        with path.open("r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+    else:
+        path = find_pyproject_toml()
+        if not path:
+            raise FileNotFoundError(
+                "No dmon.yaml or pyproject.toml found in current or any parent directory."
+            )
+
+        with path.open("rb") as f:
+            cfg = tomllib.load(f)
+        cfg = cfg.get("tool", {}).get("dmon", {})
+    return cfg, path
+
+
+def validate_cmd_type(cmd, name: str) -> CmdType:
+    if isinstance(cmd, str):
+        return cmd
+    elif isinstance(cmd, list):
+        if not all(isinstance(item, str) for item in cmd):
+            # check if it's a list of strings
+            raise TypeError(f"Task '{name}' list items must be strings")
+        return cmd
+    else:
+        raise TypeError(
+            f"Task '{name}' 'cmd' field must be a string, or list of strings; got {type(cmd)}"
+        )
+
+
+def validate_task(task, name: str) -> DmonTaskConfig:
+    ret = DmonTaskConfig(name=name)
+    if isinstance(task, str) or isinstance(task, list):
+        ret.cmd = validate_cmd_type(task, name)
+    elif isinstance(task, dict):
+        if "cmd" not in task:
+            raise TypeError(f"Task '{name}' must have a 'cmd' field")
+        ret.cmd = validate_cmd_type(task["cmd"], name)
+
+        if "cwd" in task:
+            if not isinstance(task["cwd"], str):
+                raise TypeError(f"Task '{name}' 'cwd' field must be a string")
+            ret.cwd = task["cwd"]
+
+        if "env" in task:
+            if not isinstance(task["env"], dict) or not all(
+                isinstance(k, str) and isinstance(v, str)
+                for k, v in task["env"].items()
+            ):
+                raise TypeError(
+                    f"Task '{name}' 'env' field must be a table of string to string"
+                )
+            ret.env = cast(Dict[str, str], task["env"])
+
+        if "override_env" in task:
+            if not isinstance(task["override_env"], bool):
+                raise TypeError(f"Task '{name}' 'override_env' field must be a boolean")
+            ret.override_env = task["override_env"]
+
+        if "log_path" in task:
+            if not isinstance(task["log_path"], str):
+                raise TypeError(f"Task '{name}' 'log_path' field must be a string")
+            ret.log_path = task["log_path"]
+
+        if "log_rotate" in task:
+            if not isinstance(task["log_rotate"], bool):
+                raise TypeError(f"Task '{name}' 'log_rotate' field must be a boolean")
+            ret.log_rotate = task["log_rotate"]
+
+        if "log_max_size" in task:
+            if not isinstance(task["log_max_size"], int) or task["log_max_size"] <= 0:
+                raise TypeError(
+                    f"Task '{name}' 'log_max_size' field must be a positive integer"
+                )
+            ret.log_max_size = task["log_max_size"]
+
+        if "rotate_log_path" in task:
+            if not isinstance(task["rotate_log_path"], str):
+                raise TypeError(
+                    f"Task '{name}' 'rotate_log_path' field must be a string"
+                )
+            ret.rotate_log_path = task["rotate_log_path"]
+
+        if "rotate_log_max_size" in task:
+            if (
+                not isinstance(task["rotate_log_max_size"], int)
+                or task["rotate_log_max_size"] <= 0
+            ):
+                raise TypeError(
+                    f"Task '{name}' 'rotate_log_max_size' field must be a positive integer"
+                )
+            ret.rotate_log_max_size = task["rotate_log_max_size"]
+
+        if "meta_path" in task:
+            if not isinstance(task["meta_path"], str):
+                raise TypeError(f"Task '{name}' 'meta_path' field must be a string")
+            ret.meta_path = task["meta_path"]
+    else:
+        raise TypeError(
+            f"Task '{name}' must be a string, list of strings, or a table; got {type(task)}"
+        )
+    return ret
+
+
+def get_task_config(name: Optional[str] = None):
+    """
+    Get the validated task configuration for the given task name from [tool.dmon.tasks] or dmon.yaml.
+
+    If name is None or empty, and there is only one task, return that task; otherwise, raise ValueError.
+    If the task is not found, or required fields are missing, raise TypeError or ValueError.
+    """
+    cfg, path = load_config()
+    tasks = cfg.get("tasks", {})
+
+    if not isinstance(tasks, dict):
+        raise TypeError("'tasks' must be a table")
+
+    if not name:
+        if len(tasks) == 0:
+            raise ValueError(f"No task found in {path}")
+        elif len(tasks) == 1:
+            name = next(iter(tasks))
+        else:
+            raise ValueError(f"Multiple tasks found in {path}; please specify one.")
+    else:
+        name = name.lower()
+        if name not in tasks:
+            raise ValueError(f"Task '{name}' not found in {path}")
+
+    assert isinstance(name, str)
+    task = validate_task(tasks[name], name)
+    return name, task
+
+
+def check_name_in_config(name: str) -> bool:
+    """
+    Check if the given task name exists in the tasks.
+    Return True if found, False otherwise.
+    """
+    cfg, _ = load_config()
+    tasks = cfg.get("tasks", {})
+
+    if not isinstance(tasks, dict):
+        return False
+
+    return name.lower() in tasks

dmon/constants.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+
+DEFAULT_META_DIR = Path(".dmon")
+DEFAULT_LOG_DIR = Path("logs")
+
+META_SUFFIX = ".meta.json"
+
+META_PATH_TEMPLATE = str(DEFAULT_META_DIR / ("{name}" + META_SUFFIX))
+LOG_PATH_TEMPLATE = str(DEFAULT_LOG_DIR / "{name}.log")
+ROTATE_LOG_PATH_TEMPLATE = str(DEFAULT_LOG_DIR / "{name}.rotate.log")
+
+
+DEFAULT_RUN_NAME = "default_run"