meerschaum 2.3.0.dev3__py3-none-any.whl → 2.3.0rc2__py3-none-any.whl

meerschaum/jobs/__init__.py

@@ -0,0 +1,388 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim:fenc=utf-8
+
+"""
+Higher-level utilities for managing `meerschaum.utils.daemon.Daemon`.
+"""
+
+import pathlib
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import Dict, Optional, List, Callable, Any, SuccessTuple
+
+from meerschaum.jobs._Job import Job, StopMonitoringLogs
+from meerschaum.jobs._Executor import Executor
+
+__all__ = (
+    'Job',
+    'get_jobs',
+    'get_filtered_jobs',
+    'get_restart_jobs',
+    'get_running_jobs',
+    'get_stopped_jobs',
+    'get_paused_jobs',
+    'get_restart_jobs',
+    'Executor',
+    'make_executor',
+    'check_restart_jobs',
+    'start_check_jobs_thread',
+    'stop_check_jobs_thread',
+)
+
+executor_types: List[str] = ['api', 'local']
+
+
+def get_jobs(
+    executor_keys: Optional[str] = None,
+    include_hidden: bool = False,
+    combine_local_and_systemd: bool = True,
+    debug: bool = False,
+) -> Dict[str, Job]:
+    """
+    Return a dictionary of the existing jobs.
+
+    Parameters
+    ----------
+    executor_keys: Optional[str], default None
+        If provided, return remote jobs on the given API instance.
+        Otherwise return local jobs.
+
+    include_hidden: bool, default False
+        If `True`, include jobs with the `hidden` attribute.
+
+    Returns
+    -------
+    A dictionary mapping job names to jobs.
+    """
+    from meerschaum.connectors.parse import parse_executor_keys
+    include_local_and_system = (
+        combine_local_and_systemd
+        and str(executor_keys).split(':', maxsplit=1)[0] in ('None', 'local', 'systemd')
+        and get_executor_keys_from_context() == 'systemd'
+    )
+
+    def _get_local_jobs():
+        from meerschaum.utils.daemon import get_daemons
+        daemons = get_daemons()
+        jobs = {
+            daemon.daemon_id: Job(name=daemon.daemon_id, executor_keys='local')
+            for daemon in daemons
+        }
+        return {
+            name: job
+            for name, job in jobs.items()
+            if include_hidden or not job.hidden
+        }
+
+    def _get_systemd_jobs():
+        conn = mrsm.get_connector('systemd')
+        jobs = conn.get_jobs(debug=debug)
+        return {
+            name: job
+            for name, job in jobs.items()
+            if include_hidden or not job.hidden
+        }
+
+    if include_local_and_system:
+        local_jobs = _get_local_jobs()
+        systemd_jobs = _get_systemd_jobs()
+        shared_jobs = set(local_jobs) & set(systemd_jobs)
+        if shared_jobs:
+            from meerschaum.utils.misc import items_str
+            from meerschaum.utils.warnings import warn
+            warn(
+                "Job"
+                + ('s' if len(shared_jobs) != 1 else '')
+                + f" {items_str(list(shared_jobs))} "
+                + "exist"
+                + ('s' if len(shared_jobs) == 1 else '')
+                + " in both `local` and `systemd`.",
+                stack=False,
+            )
+        return {**local_jobs, **systemd_jobs}
+
+    try:
+        _ = parse_executor_keys(executor_keys, construct=False)
+        conn = parse_executor_keys(executor_keys)
+        jobs = conn.get_jobs(debug=debug)
+        return {
+            name: job
+            for name, job in jobs.items()
+            if include_hidden or not job.hidden
+        }
+    except Exception:
+        return {}
+
+
+def get_filtered_jobs(
+    executor_keys: Optional[str] = None,
+    filter_list: Optional[List[str]] = None,
+    include_hidden: bool = False,
+    warn: bool = False,
+    debug: bool = False,
+) -> Dict[str, Job]:
+    """
+    Return a list of jobs filtered by the user.
+    """
+    from meerschaum.utils.warnings import warn as _warn
+    jobs = get_jobs(executor_keys, include_hidden=True, debug=debug)
+    if not filter_list:
+        return {
+            name: job
+            for name, job in jobs.items()
+            if include_hidden or not job.hidden
+        }
+
+    jobs_to_return = {}
+    for name in filter_list:
+        job = jobs.get(name, None)
+        if job is None:
+            if warn:
+                _warn(
+                    f"Job '{name}' does not exist.",
+                    stack=False,
+                )
+            continue
+        jobs_to_return[name] = job
+
+    return jobs_to_return
+
+
+def get_restart_jobs(
+    executor_keys: Optional[str] = None,
+    jobs: Optional[Dict[str, Job]] = None,
+    include_hidden: bool = False,
+    debug: bool = False,
+) -> Dict[str, Job]:
+    """
+    Return jobs which were created with `--restart` or `--loop`.
+    """
+    if jobs is None:
+        jobs = get_jobs(executor_keys, include_hidden=include_hidden, debug=debug)
+
+    return {
+        name: job
+        for name, job in jobs.items()
+        if job.restart
+    }
+
+
+def get_running_jobs(
+    executor_keys: Optional[str] = None,
+    jobs: Optional[Dict[str, Job]] = None,
+    include_hidden: bool = False,
+    debug: bool = False,
+) -> Dict[str, Job]:
+    """
+    Return a dictionary of running jobs.
+    """
+    if jobs is None:
+        jobs = get_jobs(executor_keys, include_hidden=include_hidden, debug=debug)
+
+    return {
+        name: job
+        for name, job in jobs.items()
+        if job.status == 'running'
+    }
+
+
+def get_paused_jobs(
+    executor_keys: Optional[str] = None,
+    jobs: Optional[Dict[str, Job]] = None,
+    include_hidden: bool = False,
+    debug: bool = False,
+) -> Dict[str, Job]:
+    """
+    Return a dictionary of paused jobs.
+    """
+    if jobs is None:
+        jobs = get_jobs(executor_keys, include_hidden=include_hidden, debug=debug)
+
+    return {
+        name: job
+        for name, job in jobs.items()
+        if job.status == 'paused'
+    }
+
+
+def get_stopped_jobs(
+    executor_keys: Optional[str] = None,
+    jobs: Optional[Dict[str, Job]] = None,
+    include_hidden: bool = False,
+    debug: bool = False,
+) -> Dict[str, Job]:
+    """
+    Return a dictionary of stopped jobs.
+    """
+    if jobs is None:
+        jobs = get_jobs(executor_keys, include_hidden=include_hidden, debug=debug)
+
+    return {
+        name: job
+        for name, job in jobs.items()
+        if job.status == 'stopped'
+    }
+
+
+def make_executor(cls):
+    """
+    Register a class as an `Executor`.
+    """
+    import re
+    from meerschaum.connectors import make_connector
+    suffix_regex = r'executor$'
+    typ = re.sub(suffix_regex, '', cls.__name__.lower())
+    if typ not in executor_types:
+        executor_types.append(typ)
+    return make_connector(cls, _is_executor=True)
+
+
+def check_restart_jobs(
+    executor_keys: Optional[str] = 'local',
+    jobs: Optional[Dict[str, Job]] = None,
+    include_hidden: bool = True,
+    silent: bool = False,
+    debug: bool = False,
+) -> SuccessTuple:
+    """
+    Restart any stopped jobs which were created with `--restart`.
+
+    Parameters
+    ----------
+    executor_keys: Optional[str], default None
+        If provided, check jobs on the given remote API instance.
+        Otherwise check local jobs.
+
+    include_hidden: bool, default True
+        If `True`, include hidden jobs in the check.
+
+    silent: bool, default False
+        If `True`, do not print the restart success message.
+    """
+    from meerschaum.utils.misc import items_str
+
+    if jobs is None:
+        jobs = get_jobs(
+            executor_keys,
+            include_hidden=include_hidden,
+            debug=debug,
+        )
+
+    if not jobs:
+        return True, "No jobs to restart."
+
+    results = {}
+    for name, job in jobs.items():
+        check_success, check_msg = job.check_restart()
+        results[job.name] = (check_success, check_msg)
+        if not silent:
+            mrsm.pprint((check_success, check_msg))
+
+    success_names = [name for name, (check_success, check_msg) in results.items() if check_success]
+    fail_names = [name for name, (check_success, check_msg) in results.items() if not check_success]
+    success = len(success_names) == len(jobs)
+    msg = (
+        (
+            "Successfully restarted job"
+            + ('s' if len(success_names) != 1 else '')
+            + ' ' + items_str(success_names) + '.'
+        )
+        if success
+        else (
+            "Failed to restart job"
+            + ('s' if len(success_names) != 1 else '')
+            + ' ' + items_str(fail_names) + '.'
+        )
+    )
+    return success, msg
+
+
+def _check_restart_jobs_against_lock(*args, **kwargs):
+    from meerschaum.config.paths import CHECK_JOBS_LOCK_PATH
+    fasteners = mrsm.attempt_import('fasteners')
+    lock = fasteners.InterProcessLock(CHECK_JOBS_LOCK_PATH)
+    with lock:
+        check_restart_jobs(*args, **kwargs)
+
+
+_check_loop_stop_thread = None
+def start_check_jobs_thread():
+    """
+    Start a thread to regularly monitor jobs.
+    """
+    import atexit
+    from functools import partial
+    from meerschaum.utils.threading import RepeatTimer
+    from meerschaum.config.static import STATIC_CONFIG
+
+    global _check_loop_stop_thread
+    sleep_seconds = STATIC_CONFIG['jobs']['check_restart_seconds']
+
+    _check_loop_stop_thread = RepeatTimer(
+        sleep_seconds,
+        partial(
+            _check_restart_jobs_against_lock,
+            silent=True,
+        )
+    )
+    _check_loop_stop_thread.daemon = True
+    atexit.register(stop_check_jobs_thread)
+
+    _check_loop_stop_thread.start()
+    return _check_loop_stop_thread
+
+
+def stop_check_jobs_thread():
+    """
+    Stop the job monitoring thread.
+    """
+    from meerschaum.config.paths import CHECK_JOBS_LOCK_PATH
+    from meerschaum.utils.warnings import warn
+    if _check_loop_stop_thread is None:
+        return
+
+    _check_loop_stop_thread.cancel()
+
+    try:
+        if CHECK_JOBS_LOCK_PATH.exists():
+            CHECK_JOBS_LOCK_PATH.unlink()
+    except Exception as e:
+        warn(f"Failed to remove check jobs lock file:\n{e}")
+
+
+_context_keys = None
+def get_executor_keys_from_context() -> str:
+    """
+    If we are running on the host with the default root, default to `'systemd'`.
+    Otherwise return `'local'`.
+    """
+    global _context_keys
+
+    if _context_keys is not None:
+        return _context_keys
+
+    from meerschaum.config.paths import ROOT_DIR_PATH, DEFAULT_ROOT_DIR_PATH
+    from meerschaum.utils.misc import is_systemd_available
+
+    _context_keys = (
+        'systemd'
+        if is_systemd_available() and ROOT_DIR_PATH == DEFAULT_ROOT_DIR_PATH
+        else 'local'
+    )
+    return _context_keys
+
+
+def _install_healthcheck_job() -> SuccessTuple:
+    """
+    Install the systemd job which checks local jobs.
+    """
+    if get_executor_keys_from_context() != 'systemd':
+        return False, "Not running systemd."
+
+    job = Job(
+        '.local_healthcheck',
+        ['restart', 'jobs', '-e', 'local', '--loop'],
+        executor_keys='systemd',
+    )
+    return job.start()

meerschaum/plugins/__init__.py

@@ -37,12 +37,12 @@ __pdoc__ = {
 }
 
 def make_action(
-        function: Callable[[Any], Any],
-        shell: bool = False,
-        activate: bool = True,
-        deactivate: bool = True,
-        debug: bool = False
-    ) -> Callable[[Any], Any]:
+    function: Callable[[Any], Any],
+    shell: bool = False,
+    activate: bool = True,
+    deactivate: bool = True,
+    debug: bool = False
+) -> Callable[[Any], Any]:
     """
     Make a function a Meerschaum action. Useful for plugins that are adding multiple actions.
     

meerschaum/utils/daemon/Daemon.py

@@ -294,6 +294,7 @@ class Daemon:
             with self._daemon_context:
                 sys.stdin = self.stdin_file
                 os.environ[STATIC_CONFIG['environment']['daemon_id']] = self.daemon_id
+                os.environ['PYTHONUNBUFFERED'] = '1'
                 self.rotating_log.refresh_files(start_interception=True)
                 result = None
                 try:
@@ -596,6 +597,9 @@ class Daemon:
         if action not in ('quit', 'kill', 'pause'):
             return False, f"Unsupported action '{action}'."
 
+        if not self.stop_path.parent.exists():
+            self.stop_path.parent.mkdir(parents=True, exist_ok=True)
+
         with open(self.stop_path, 'w+', encoding='utf-8') as f:
             json.dump(
                 {
@@ -810,6 +814,9 @@ class Daemon:
         """
         Return the stdin file path.
         """
+        if '_blocking_stdin_file_path' in self.__dict__:
+            return self._blocking_stdin_file_path
+
         return self.path / 'input.stdin.block'
 
     @property

meerschaum/utils/daemon/RotatingFile.py

@@ -38,7 +38,7 @@ class RotatingFile(io.IOBase):
         max_file_size: Optional[int] = None,
         redirect_streams: bool = False,
         write_timestamps: bool = False,
-        timestamp_format: str = '%Y-%m-%d %H:%M',
+        timestamp_format: Optional[str] = None,
     ):
         """
         Create a file-like object which manages other files.
@@ -64,14 +64,17 @@ class RotatingFile(io.IOBase):
         write_timestamps: bool, default False
             If `True`, prepend the current UTC timestamp to each line of the file.
 
-        timestamp_format: str, default '%Y-%m-%d %H:%M'
+        timestamp_format: str, default None
             If `write_timestamps` is `True`, use this format for the timestamps.
+            Defaults to `'%Y-%m-%d %H:%M'`.
         """
         self.file_path = pathlib.Path(file_path)
         if num_files_to_keep is None:
             num_files_to_keep = get_config('jobs', 'logs', 'num_files_to_keep')
         if max_file_size is None:
             max_file_size = get_config('jobs', 'logs', 'max_file_size')
+        if timestamp_format is None:
+            timestamp_format = get_config('jobs', 'logs', 'timestamps', 'format')
         if num_files_to_keep < 2:
             raise ValueError("At least 2 files must be kept.")
         if max_file_size < 1:

meerschaum/utils/daemon/StdinFile.py

@@ -13,7 +13,7 @@ import os
 import selectors
 import traceback
 
-from meerschaum.utils.typing import Optional
+from meerschaum.utils.typing import Optional, Union
 from meerschaum.utils.warnings import warn
 
 
@@ -23,9 +23,12 @@ class StdinFile(io.TextIOBase):
     """
     def __init__(
         self,
-        file_path: pathlib.Path,
+        file_path: Union[pathlib.Path, str],
         lock_file_path: Optional[pathlib.Path] = None,
     ):
+        if isinstance(file_path, str):
+            file_path = pathlib.Path(file_path)
+
         self.file_path = file_path
         self.blocking_file_path = (
             lock_file_path
@@ -108,3 +111,10 @@ class StdinFile(io.TextIOBase):
 
     def is_open(self):
         return self._file_handler is not None
+
+
+    def __str__(self) -> str:
+        return f"StdinFile('{self.file_path}')"
+
+    def __repr__(self) -> str:
+        return str(self)

meerschaum/utils/daemon/__init__.py

@@ -10,9 +10,11 @@ from __future__ import annotations
 import os, pathlib, shutil, json, datetime, threading, shlex
 from meerschaum.utils.typing import SuccessTuple, List, Optional, Callable, Any, Dict
 from meerschaum.config._paths import DAEMON_RESOURCES_PATH
+from meerschaum.utils.daemon.StdinFile import StdinFile
 from meerschaum.utils.daemon.Daemon import Daemon
 from meerschaum.utils.daemon.RotatingFile import RotatingFile
 from meerschaum.utils.daemon.FileDescriptorInterceptor import FileDescriptorInterceptor
+from meerschaum.utils.daemon._names import get_new_daemon_name
 
 
 def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:

meerschaum/utils/formatting/_jobs.py

@@ -12,12 +12,13 @@ from datetime import datetime, timezone
 
 import meerschaum as mrsm
 from meerschaum.utils.typing import List, Optional, Any, is_success_tuple, Dict
-from meerschaum.utils.jobs import (
+from meerschaum.jobs import (
     Job,
     get_jobs,
     get_running_jobs,
     get_stopped_jobs,
     get_paused_jobs,
+    get_executor_keys_from_context,
 )
 from meerschaum.config import get_config
 
@@ -28,11 +29,17 @@ def pprint_jobs(
 ):
     """Pretty-print a list of Daemons."""
     from meerschaum.utils.formatting import make_header
+    from meerschaum.utils.misc import items_str
     
     running_jobs = get_running_jobs(jobs=jobs)
     paused_jobs = get_paused_jobs(jobs=jobs)
     stopped_jobs = get_stopped_jobs(jobs=jobs)
-    executor_keys = (list(jobs.values())[0].executor_keys if jobs else None) or 'local'
+    executor_keys_list = list(set(
+        [
+            job.executor_keys.replace('systemd:main', 'systemd')
+            for job in jobs.values()
+        ]
+    )) if jobs else [get_executor_keys_from_context()]
 
     def _nopretty_print():
         from meerschaum.utils.misc import print_options
@@ -62,12 +69,20 @@ def pprint_jobs(
             'rich.table', 'rich.text', 'rich.box', 'rich.json', 'rich.panel', 'rich.console',
         )
         table = rich_table.Table(
-            title=rich_text.Text(f"\nJobs on Executor '{executor_keys}'"),
+            title=rich_text.Text(
+                f"\nJobs on Executor"
+                + ('s' if len(executor_keys_list) != 1 else '')
+                + f" {items_str(executor_keys_list)}"
+            ),
             box=(rich_box.ROUNDED if UNICODE else rich_box.ASCII),
             show_lines=True,
             show_header=ANSI,
         )
         table.add_column("Name", justify='right', style=('magenta' if ANSI else ''))
+        table.add_column(
+            "Executor",
+            style=(get_config('shell', 'ansi', 'executor', 'rich', 'style') if ANSI else ''),
+        )
         table.add_column("Command")
         table.add_column("Status")
 
@@ -97,43 +112,55 @@ def pprint_jobs(
 
 
         for name, job in running_jobs.items():
-            if job.hidden:
-                continue
+            status_group = [
+                (
+                    rich_text.Text(job.status, style=('green' if ANSI else ''))
+                    if not job.is_blocking_on_stdin()
+                    else rich_text.Text('waiting for input', style=('yellow' if ANSI else ''))
+                ),
+            ] + ([rich_text.Text(f"PID: {pid}")] if (pid := job.pid) else [])
 
-            status_text = (
-                rich_text.Text(job.status, style=('green' if ANSI else ''))
-                if not job.is_blocking_on_stdin()
-                else rich_text.Text('waiting for input', style=('yellow' if ANSI else ''))
-            )
+            if job.restart:
+                status_group.append(rich_text.Text('(restarts)'))
 
             table.add_row(
                 job.name,
+                job.executor_keys.replace('systemd:main', 'systemd'),
                 job.label,
-                rich_console.Group(status_text),
+                rich_console.Group(*status_group),
             )
 
         for name, job in paused_jobs.items():
-            if job.hidden:
-                continue
+            status_group = [
+                rich_text.Text(job.status, style=('yellow' if ANSI else '')),
+            ]
+            if job.restart:
+                status_group.append(rich_text.Text('(restarts)'))
+
             table.add_row(
                 job.name,
+                job.executor_keys.replace('systemd:main', 'systemd'),
                 job.label,
-                rich_console.Group(
-                    rich_text.Text(job.status, style=('yellow' if ANSI else '')),
-                ),
+                rich_console.Group(*status_group),
             )
 
         for name, job in stopped_jobs.items():
-            if job.hidden:
-                continue
+            status_group = [
+                rich_text.Text(job.status, style=('red' if ANSI else '')),
+            ]
+            if job.restart:
+                if job.stop_time is None:
+                    status_group.append(rich_text.Text('(restarts)'))
+                else:
+                    status_group.append(rich_text.Text('(start to resume restarts)'))
+
+            status_group.append(get_success_text(job))
 
             table.add_row(
                 job.name,
+                job.executor_keys.replace('systemd:main', 'systemd'),
                 job.label,
-                rich_console.Group(
-                    rich_text.Text(job.status, style=('red' if ANSI else '')),
-                    get_success_text(job)
-                ),
+                rich_console.Group(*status_group),
             )
         get_console().print(table)
 
@@ -146,9 +173,6 @@ def pprint_job(
     nopretty: bool = False,
 ):
     """Pretty-print a single `Job`."""
-    if job.hidden:
-        return
-
     from meerschaum.utils.warnings import info
     if not nopretty:
         info(f"Command for job '{job.name}':")

meerschaum/utils/misc.py

@@ -902,6 +902,7 @@ def get_connector_labels(
     *types: str,
     search_term: str = '',
     ignore_exact_match = True,
+    _additional_options: Optional[List[str]] = None,
 ) -> List[str]:
     """
     Read connector labels from the configuration dictionary.
@@ -941,12 +942,16 @@ def get_connector_labels(
             continue
         conns += [ f'{t}:{label}' for label in connectors.get(t, {}) if label != 'default' ]
 
+    if _additional_options:
+        conns += _additional_options
+
     possibilities = [
-        c for c in conns
-            if c.startswith(search_term)
-                and c != (
-                    search_term if ignore_exact_match else ''
-                )
+        c
+        for c in conns
+        if c.startswith(search_term)
+            and c != (
+                search_term if ignore_exact_match else ''
+            )
     ]
     return sorted(possibilities)
 
@@ -1218,6 +1223,19 @@ def is_bcp_available() -> bool:
     return has_bcp
 
 
+def is_systemd_available() -> bool:
+    """Check if running on systemd."""
+    import subprocess
+    try:
+        has_systemctl = subprocess.call(
+            ['systemctl', '-h'],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.STDOUT,
+        ) == 0
+    except Exception:
+        has_systemctl = False
+    return has_systemctl
+
 def get_last_n_lines(file_name: str, N: int):
     """
     https://thispointer.com/python-get-last-n-lines-of-a-text-file-like-tail-command/