python-dmon 0.2.4__py3-none-any.whl → 0.3.1__py3-none-any.whl

dmon/cli.py

@@ -1,11 +1,20 @@
 import argparse
+import os
+from pathlib import Path
 import shlex
-import sys
 
 from colorama import just_fix_windows_console
 
-from .config import check_name_in_config, get_task_config
-from .control import execute, list_processes, restart, start, stop, status
+from .config import check_name_in_config, get_task_config, load_config
+from .control import (
+    execute,
+    get_meta_paths,
+    list_processes,
+    restart,
+    start,
+    stop,
+    status,
+)
 from .constants import (
     DEFAULT_META_DIR,
     DEFAULT_RUN_NAME,
@@ -50,7 +59,7 @@ def main():
     sp_start.add_argument(
         "task",
         help="Configured task name (default: the only task if there's just one)",
-        nargs="?",
+        nargs="*",
     )
     sp_start.add_argument(
         "--meta-file",
@@ -60,20 +69,26 @@ def main():
         "--log-file",
         help=f"Path to log file (default: task configured or {LOG_PATH_TEMPLATE})",
     )
+    sp_start.add_argument("--all", action="store_true", help="Start all processes")
 
     # stop subcommand
     sp_stop = subparsers.add_parser(
         "stop",
-        help="Stop a background process",
-        description="Stop a background process given name or meta file",
+        help="Stop background process(es)",
+        description="Stop background process(es) given name or meta file",
         # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     sp_stop.add_argument(
         "task",
         help="Configured task name (default: the only task if there's just one)",
-        nargs="?",
+        nargs="*",
     )
     sp_stop.add_argument("--meta-file", help="Path to meta file")
+    sp_stop.add_argument(
+        "--all",
+        action="store_true",
+        help=f"Stop all processes in meta dir ({DEFAULT_META_DIR})",
+    )
 
     # restart subcommand
     sp_restart = subparsers.add_parser(
@@ -85,7 +100,7 @@ def main():
     sp_restart.add_argument(
         "task",
         help="Configured task name (default: the only task if there's just one)",
-        nargs="?",
+        nargs="*",
     )
     sp_restart.add_argument(
         "--meta-file",
@@ -95,23 +110,30 @@ def main():
         "--log-file",
         help=f"Path to log file (default: task configured or {LOG_PATH_TEMPLATE})",
     )
+    sp_restart.add_argument("--all", action="store_true", help="Restart all processes")
 
     # status subcommand
     sp_status = subparsers.add_parser(
         "status",
-        help="Check process status",
-        description="Check status of a background process given name or meta file",
+        help="Check status of background process(es)",
+        description="Check status of background process(es) given name or meta file",
         # formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     sp_status.add_argument(
         "task",
         help="Configured task name (default: the only task if there's just one)",
-        nargs="?",
+        nargs="*",
     )
     sp_status.add_argument(
         "--meta-file",
         help=f"Path to meta file (default: {META_PATH_TEMPLATE})",
     )
+    sp_status.add_argument(
+        "-a",
+        "--all",
+        action="store_true",
+        help=f"Check status of all processes in meta dir ({DEFAULT_META_DIR})",
+    )
 
     # list subcommand
     sp_list = subparsers.add_parser(
@@ -171,9 +193,9 @@ def main():
     )
     sp_run.add_argument(
         "command_list",
-        metavar="command",
-        nargs=argparse.ONE_OR_MORE,
-        help="Command (with args) to run",
+        metavar="COMMAND",
+        nargs=argparse.REMAINDER,
+        help="Command and arguments to run; '--' is an optional separator",
     )
 
     sp_exec = subparsers.add_parser(
@@ -190,7 +212,9 @@ def main():
     # add custom config file option
     for sp in [sp_start, sp_stop, sp_restart, sp_status, sp_exec]:
         sp.add_argument(
+            "-c",
             "--config",
+            metavar="PATH",
             help="Path to config file or the directory containing it (default: search from current directory upwards)",
         )
 
@@ -199,50 +223,98 @@ def main():
     if args.command in ["start", "restart"]:
         sp = sp_start if args.command == "start" else sp_restart
         try:
-            task, task_cfg = get_task_config(args.task, args.config)
+            tasks, task_cfgs, cfg_path = get_task_config(
+                args.task, args.config, args.all
+            )
+            os.chdir(cfg_path.parent)
         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(task=task)
-        )
-        task_cfg.log_path = (
-            args.log_file or task_cfg.log_path or LOG_PATH_TEMPLATE.format(task=task)
-        )
-        task_cfg.rotate_log_path = (
-            task_cfg.rotate_log_path or ROTATE_LOG_PATH_TEMPLATE.format(task=task)
-        )
+        # check if meta_file or log_file path is provided;
+        # if so, only one task should be specified
+        if args.meta_file or args.log_file:
+            if len(tasks) == 1:
+                task_cfgs[0].meta_path = args.meta_file or task_cfgs[0].meta_path
+                task_cfgs[0].log_path = args.log_file or task_cfgs[0].log_path
+            else:
+                sp.error(
+                    f"'--meta-file' and '--log-file' can only be specified when {args.command}ing a single task"
+                )
+        # fill in default values if not provided
+        for task, task_cfg in zip(tasks, task_cfgs):
+            task_cfg.meta_path = task_cfg.meta_path or META_PATH_TEMPLATE.format(
+                task=task
+            )
+            task_cfg.log_path = task_cfg.log_path or LOG_PATH_TEMPLATE.format(task=task)
+            task_cfg.rotate_log_path = (
+                task_cfg.rotate_log_path or ROTATE_LOG_PATH_TEMPLATE.format(task=task)
+            )
         if args.command == "start":
-            sys.exit(start(task_cfg))
+            sp.exit(start(task_cfgs))
         else:
-            sys.exit(restart(task_cfg))
+            sp.exit(restart(task_cfgs))
     elif args.command == "exec":
         try:
-            task, task_cfg = get_task_config(args.task, args.config)
+            _, task_cfgs, cfg_path = get_task_config(args.task, args.config)
+            os.chdir(cfg_path.parent)
         except Exception as e:
             sp_exec.error(str(e))
-        sys.exit(execute(task_cfg))
+        sp_exec.exit(execute(task_cfgs[0]))
     elif args.command in ["stop", "status"]:
         sp = sp_stop if args.command == "stop" else sp_status
+        meta_paths = []
+
+        tasks = args.task
+        if args.task:
+            try:
+                tasks, _, cfg_path = get_task_config(args.task, args.config)
+                os.chdir(cfg_path.parent)
+            except Exception as e:
+                sp.error(str(e))
+        elif args.config:
+            try:
+                _, cfg_path = load_config(args.config)
+                os.chdir(cfg_path.parent)
+            except Exception as e:
+                sp.error(str(e))
+
+        # Collect meta paths from --all
+        if args.all:
+            meta_paths.extend(get_meta_paths(DEFAULT_META_DIR))
+
+        # Collect meta paths from --meta-file
         if args.meta_file:
-            meta_path = args.meta_file
-        else:
-            if args.task:
-                task = args.task
-            else:
-                try:
-                    task, _ = get_task_config(args.task, args.config)
-                except Exception as e:
-                    sp.error(str(e))
-            meta_path = META_PATH_TEMPLATE.format(task=task)
+            meta_paths.append(args.meta_file)
+
+        # Collect meta paths from task names
+        if len(tasks) > 0:
+            meta_paths.extend([META_PATH_TEMPLATE.format(task=task) for task in tasks])
+
+        # If no meta paths collected, use default task
+        if len(meta_paths) == 0:
+            try:
+                tasks, _, cfg_path = get_task_config(args.task, args.config)
+                os.chdir(cfg_path.parent)
+            except Exception as e:
+                sp.error(str(e))
+            meta_paths.extend([META_PATH_TEMPLATE.format(task=task) for task in tasks])
+
+        # Remove duplicates
+        unique_meta_paths = sorted(set(Path(p).resolve() for p in meta_paths))
+
         if args.command == "stop":
-            sys.exit(stop(meta_path))
+            sp.exit(stop(unique_meta_paths))
         else:
-            sys.exit(status(meta_path))
+            sp.exit(status(unique_meta_paths))
     elif args.command == "list":
         dir = args.dir or DEFAULT_META_DIR
-        sys.exit(list_processes(dir, args.full))
+        sp_list.exit(list_processes(dir, args.full))
     elif args.command == "run":
+        command_list = args.command_list
+        if command_list and command_list[0] == "--":
+            command_list = command_list[1:]
+        if not command_list:
+            sp_run.error("Please provide a command to run.")
         if not args.name:
             sp_run.error("Please provide a non-empty name for the task.")
         elif check_name_in_config(args.name):
@@ -252,7 +324,7 @@ def main():
 
         task_cfg = DmonTaskConfig(
             task=args.name,
-            cmd=shlex.join(args.command_list) if args.shell else args.command_list,
+            cmd=shlex.join(command_list) if args.shell else command_list,
             cwd=args.cwd,
             meta_path=args.meta_file or META_PATH_TEMPLATE.format(task=args.name),
             log_path=args.log_file or LOG_PATH_TEMPLATE.format(task=args.name),
@@ -260,10 +332,10 @@ def main():
             rotate_log_path=args.rotate_log_path
             or ROTATE_LOG_PATH_TEMPLATE.format(task=args.name),
         )
-        sys.exit(start(task_cfg))
+        sp_run.exit(start([task_cfg]))
     else:
         parser.print_help()
-        sys.exit(1)
+        parser.exit(1)
 
 
 if __name__ == "__main__":

dmon/config.py

@@ -1,6 +1,6 @@
 import sys
 from pathlib import Path
-from typing import Dict, Optional, cast
+from typing import Dict, List, Optional, Sequence, Tuple, Union, cast
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -64,6 +64,10 @@ def load_config(cfg_path: Optional[str] = None):
         cfg = cfg.get("tool", {}).get("dmon", {})
     else:
         raise ValueError("Config file must be YAML (.yaml/.yml) or TOML (.toml)")
+    if cfg is None:
+        cfg = {}
+    if not isinstance(cfg, dict):
+        raise TypeError(f"Config in '{path}' must be a table")
     return cfg, path
 
 
@@ -121,12 +125,23 @@ def validate_task(task, name: str) -> DmonTaskConfig:
             ret.log_rotate = task["log_rotate"]
 
         if "log_max_size" in task:
-            if not isinstance(task["log_max_size"], (int, float)) or task["log_max_size"] <= 0:
+            if (
+                not isinstance(task["log_max_size"], (int, float))
+                or task["log_max_size"] <= 0
+            ):
                 raise TypeError(
                     f"Task '{name}' 'log_max_size' field must be a positive number"
                 )
             ret.log_max_size = task["log_max_size"]
 
+        if "log_backup_count" in task:
+            value = task["log_backup_count"]
+            if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+                raise TypeError(
+                    f"Task '{name}' 'log_backup_count' field must be a positive integer"
+                )
+            ret.log_backup_count = value
+
         if "rotate_log_path" in task:
             if not isinstance(task["rotate_log_path"], str):
                 raise TypeError(
@@ -144,6 +159,14 @@ def validate_task(task, name: str) -> DmonTaskConfig:
                 )
             ret.rotate_log_max_size = task["rotate_log_max_size"]
 
+        if "rotate_log_backup_count" in task:
+            value = task["rotate_log_backup_count"]
+            if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+                raise TypeError(
+                    f"Task '{name}' 'rotate_log_backup_count' field must be a positive integer"
+                )
+            ret.rotate_log_backup_count = value
+
         if "meta_path" in task:
             if not isinstance(task["meta_path"], str):
                 raise TypeError(f"Task '{name}' 'meta_path' field must be a string")
@@ -155,11 +178,14 @@ def validate_task(task, name: str) -> DmonTaskConfig:
     return ret
 
 
-def get_task_config(name: Optional[str], cfg_path: Optional[str]):
+def get_task_config(
+    names: Union[Sequence[str], str, None], cfg_path: Optional[str], all: bool = False
+) -> Tuple[Sequence[str], List[DmonTaskConfig], Path]:
     """
-    Get the validated task configuration for the given task name.
-    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.
+    Get the validated task configurations for the given task names.
+    If 'all' is True, return all tasks.
+    If no name specified, and there is only one task, return that task; otherwise, raise ValueError.
+    If any task is not found, or required fields are missing, raise TypeError or ValueError.
 
     The config is loaded from the given path, or searched for dmon.yaml or pyproject.toml.
     """
@@ -169,23 +195,37 @@ def get_task_config(name: Optional[str], cfg_path: Optional[str]):
     if not isinstance(tasks, dict):
         raise TypeError("'tasks' must be a table")
 
-    name = name or cfg.get("default_task", None)
-
-    if not name:
-        if len(tasks) == 0:
-            raise ValueError(f"No task found in {path}")
-        elif len(tasks) == 1:
-            name = next(iter(tasks))
+    if all:
+        names = list(tasks.keys())
+    elif isinstance(names, str):
+        names = [names]
+    elif names is None or len(names) == 0:
+        default_task_name = cfg.get("default_task", None)
+        if default_task_name:
+            if not isinstance(default_task_name, str):
+                raise TypeError("'default_task' must be a string")
+            names = [default_task_name]
         else:
-            raise ValueError(f"Multiple tasks found in {path}; please specify one.")
-    else:
+            if len(tasks) == 0:
+                raise ValueError(f"No task found in {path}")
+            elif len(tasks) == 1:
+                name = next(iter(tasks))
+                assert isinstance(name, str)
+                names = [name]
+            else:
+                raise ValueError(f"Multiple tasks found in {path}; please specify one.")
+
+    ret_names = []
+    ret_tasks = []
+    for name in names:
         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
+        task = validate_task(tasks[name], name)
+        ret_names.append(name)
+        ret_tasks.append(task)
+    return ret_names, ret_tasks, path
 
 
 def check_name_in_config(name: str) -> bool:
@@ -193,7 +233,10 @@ 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()
+    try:
+        cfg, _ = load_config()
+    except FileNotFoundError:
+        return False
     tasks = cfg.get("tasks", {})
 
     if not isinstance(tasks, dict):