meerschaum 2.2.7__py3-none-any.whl → 2.3.0__py3-none-any.whl

meerschaum/actions/start.py

@@ -7,12 +7,12 @@ Start subsystems (API server, logging daemon, etc.).
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import SuccessTuple, Optional, List, Any
+from meerschaum.utils.typing import SuccessTuple, Optional, List, Any, Union
 
 def start(
-        action: Optional[List[str]] = None,
-        **kw: Any,
-    ) -> SuccessTuple:
+    action: Optional[List[str]] = None,
+    **kw: Any,
+) -> SuccessTuple:
     """
     Start subsystems (API server, background job, etc.).
     """
@@ -23,21 +23,29 @@ def start(
         'gui': _start_gui,
         'webterm': _start_webterm,
         'connectors': _start_connectors,
+        'pipeline': _start_pipeline,
     }
     return choose_subaction(action, options, **kw)
 
 
 def _complete_start(
-        action: Optional[List[str]] = None,
-        **kw: Any
-    ) -> List[str]:
+    action: Optional[List[str]] = None,
+    **kw: Any
+) -> List[str]:
     """
     Override the default Meerschaum `complete_` function.
     """
+    from meerschaum.actions.delete import _complete_delete_jobs
+    from functools import partial
 
     if action is None:
         action = []
 
+    _complete_start_jobs = partial(
+        _complete_delete_jobs,
+        _get_job_method=['stopped', 'paused'],
+    )
+
     options = {
         'job': _complete_start_jobs,
         'jobs': _complete_start_jobs,
@@ -75,11 +83,15 @@ def _start_api(action: Optional[List[str]] = None, **kw):
     from meerschaum.actions import actions
     return actions['api'](action=['start'], **kw)
 
+
 def _start_jobs(
-        action: Optional[List[str]] = None,
-        name: Optional[str] = None,
-        **kw
-    ) -> SuccessTuple:
+    action: Optional[List[str]] = None,
+    name: Optional[str] = None,
+    sysargs: Optional[List[str]] = None,
+    executor_keys: Optional[str] = None,
+    debug: bool = False,
+    **kw
+) -> SuccessTuple:
     """
     Run a Meerschaum action as a background job.
     
@@ -109,23 +121,24 @@ def _start_jobs(
                 Start the job 'happy_seal' but via the `--name` flag.
                 This only applies when no text follows the words 'start job'.
     """
-    import textwrap
     from meerschaum.utils.warnings import warn, info
-    from meerschaum.utils.daemon import (
-        daemon_action, Daemon, get_daemon_ids, get_daemons, get_filtered_daemons,
-        get_stopped_daemons, get_running_daemons, get_paused_daemons,
-    )
     from meerschaum.utils.daemon._names import get_new_daemon_name
-    from meerschaum._internal.arguments._parse_arguments import parse_arguments
+    from meerschaum.jobs import (
+        Job,
+        get_filtered_jobs,
+        get_stopped_jobs,
+        get_running_jobs,
+        get_paused_jobs,
+        _install_healthcheck_job,
+    )
     from meerschaum.actions import actions
     from meerschaum.utils.prompt import yes_no
     from meerschaum.utils.formatting import print_tuple
-    from meerschaum.utils.formatting._jobs import pprint_job, pprint_jobs
-    from meerschaum.utils.formatting._shell import clear_screen
+    from meerschaum.utils.formatting._jobs import pprint_jobs
     from meerschaum.utils.misc import items_str
 
     names = []
-    daemon_ids = get_daemon_ids()
+    jobs = get_filtered_jobs(executor_keys, action, debug=debug)
 
     new_job = len(list(action)) > 0
     _potential_jobs = {'known': [], 'unknown': []}
@@ -134,7 +147,7 @@ def _start_jobs(
         for a in action:
             _potential_jobs[(
                 'known'
-                if a in daemon_ids
+                if a in jobs
                 else 'unknown'
             )].append(a)
 
@@ -158,7 +171,7 @@ def _start_jobs(
                         + items_str(_potential_jobs['unknown'])
                         + " will be ignored."
                     ),
-                    stack = False
+                    stack=False
                 )
 
         ### Determine the `names` list.
@@ -182,88 +195,83 @@ def _start_jobs(
 
     ### No action or --name was provided. Ask to start all stopped jobs.
     else:
-        _running_daemons = get_running_daemons()
-        _paused_daemons = get_paused_daemons()
-        _stopped_daemons = get_stopped_daemons()
-        if not _stopped_daemons and not _paused_daemons:
-            if not _running_daemons:
-                return False, "No jobs to start."
+        running_jobs = get_running_jobs(executor_keys, jobs, debug=debug)
+        paused_jobs = get_paused_jobs(executor_keys, jobs, debug=debug)
+        stopped_jobs = get_stopped_jobs(executor_keys, jobs, debug=debug)
+
+        if not stopped_jobs and not paused_jobs:
+            if not running_jobs:
+                return False, "No jobs to start"
             return True, "All jobs are running."
 
-        names = [d.daemon_id for d in _stopped_daemons + _paused_daemons]
+        names = [
+            name
+            for name in list(stopped_jobs) + list(paused_jobs)
+        ]
 
     def _run_new_job(name: Optional[str] = None):
-        kw['action'] = action
         name = name or get_new_daemon_name()
-        kw['name'] = name
-        _action_success_tuple = daemon_action(daemon_id=name, **kw)
-        return _action_success_tuple, name
-
-    def _run_existing_job(name: Optional[str] = None):
-        daemon = Daemon(daemon_id=name)
-        if daemon.process is not None:
-            if daemon.status == 'paused':
-                return daemon.resume(), daemon.daemon_id
-            return (True, f"Job '{name}' is already running."), daemon.daemon_id
-
-        if not daemon.path.exists():
-            if not kw.get('nopretty', False):
-                warn(f"There isn't a job with the name '{name}'.", stack=False)
-                print(
-                    f"You can start a new job named '{name}' with `start job "
-                    + "{options}" + f" --name {name}`"
-                )
-            return (False, f"Job '{name}' does not exist."), daemon.daemon_id
+        job = Job(name, sysargs, executor_keys=executor_keys)
+        return job.start(debug=debug), name
 
-        return daemon.run(allow_dirty_run=True), daemon.daemon_id
+    def _run_existing_job(name: str):
+        job = Job(name, executor_keys=executor_keys)
+        return job.start(debug=debug), name
 
     if not names:
         return False, "No jobs to start."
 
     ### Get user permission to clear logs.
-    _filtered_daemons = get_filtered_daemons(names)
-    if not kw.get('force', False) and _filtered_daemons:
-        _filtered_running_daemons = get_running_daemons(_filtered_daemons)
-        _skipped_daemons = []
-        if _filtered_running_daemons:
-            pprint_jobs(_filtered_running_daemons)
+    _filtered_jobs = get_filtered_jobs(executor_keys, names, debug=debug)
+    if not kw.get('force', False) and _filtered_jobs:
+        _filtered_running_jobs = get_running_jobs(executor_keys, _filtered_jobs, debug=debug)
+        _skipped_jobs = []
+        if _filtered_running_jobs:
+            pprint_jobs(_filtered_running_jobs)
             if yes_no(
                 "Do you want to first stop these jobs?",
-                default = 'n',
-                yes = kw.get('yes', False),
-                noask = kw.get('noask', False)
+                default='n',
+                yes=kw.get('yes', False),
+                noask=kw.get('noask', False)
             ):
                 stop_success_tuple = actions['stop'](
-                    action = ['jobs'] + [d.daemon_id for d in _filtered_running_daemons],
-                    force = True,
+                    action=['jobs'] + [_name for _name in _filtered_running_jobs],
+                    force=True,
+                    executor_keys=executor_keys,
+                    debug=debug,
                 )
                 if not stop_success_tuple[0]:
                     warn(
-                        "Failed to stop job" + ("s" if len(_filtered_running_daemons) != 1 else '')
-                        + items_str([d.daemon_id for d in _filtered_running_daemons])
-                        + ".",
-                        stack = False
+                        (
+                            "Failed to stop job"
+                            + ("s" if len(_filtered_running_jobs) != 1 else '')
+                            + items_str([_name for _name in _filtered_running_jobs])
+                            + "."
+                        ),
+                        stack=False
                     )
-                    for d in _filtered_running_daemons:
-                        names.remove(d.daemon_id)
-                        _filtered_daemons.remove(d)
+                    for _name in _filtered_running_jobs:
+                        names.remove(_name)
+                        _filtered_jobs.pop(_name)
             else:
                 info(
                     "Skipping already running job"
-                    + ("s" if len(_filtered_running_daemons) != 1 else '') + ' '
-                    + items_str([d.daemon_id for d in _filtered_running_daemons]) + '.'
+                    + ("s" if len(_filtered_running_jobs) != 1 else '')
+                    + ' '
+                    + items_str([_name for _name in _filtered_running_jobs])
+                    + '.'
                 )
-                for d in _filtered_running_daemons:
-                    names.remove(d.daemon_id)
-                    _filtered_daemons.remove(d)
-                    _skipped_daemons.append(d)
+                for _name in _filtered_running_jobs:
+                    names.remove(_name)
+                    _filtered_jobs.pop(_name)
+                    _skipped_jobs.append(_name)
 
-        if not _filtered_daemons:
-            return len(_skipped_daemons) > 0, "No jobs to start."
+        if not _filtered_jobs:
+            return len(_skipped_jobs) > 0, "No jobs to start."
 
-        pprint_jobs(_filtered_daemons, nopretty=kw.get('nopretty', False))
+        pprint_jobs(_filtered_jobs, nopretty=kw.get('nopretty', False))
         info(
-            f"Starting the job"
+            "Starting the job"
             + ("s" if len(names) != 1 else "")
             + " " + items_str(names)
             + "..."
@@ -278,7 +286,11 @@ def _start_jobs(
         )
         if not kw.get('nopretty', False):
             print_tuple(success_tuple)
-        _successes.append(_name) if success_tuple[0] else _failures.append(_name)
+
+        if success_tuple[0]:
+            _successes.append(_name)
+        else:
+            _failures.append(_name)
 
     msg = (
         (("Successfully started job" + ("s" if len(_successes) != 1 else '')
@@ -287,29 +299,9 @@ def _start_jobs(
         + ("Failed to start job" + ("s" if len(_failures) != 1 else '')
             + f" {items_str(_failures)}." if _failures else '')
     )
+    _install_healthcheck_job()
     return len(_failures) == 0, msg
 
-def _complete_start_jobs(
-        action: Optional[List[str]] = None,
-        line: str = '',
-        **kw
-    ) -> List[str]:
-    from meerschaum.utils.daemon import get_daemon_ids
-    daemon_ids = get_daemon_ids()
-    if not action:
-        return daemon_ids
-    possibilities = []
-    _line_end = line.split(' ')[-1]
-    for daemon_id in daemon_ids:
-        if daemon_id in action:
-            continue
-        if _line_end == '':
-            possibilities.append(daemon_id)
-            continue
-        if daemon_id.startswith(action[-1]):
-            possibilities.append(daemon_id)
-    return possibilities
-
 
 def _start_gui(
         action: Optional[List[str]] = None,
@@ -546,6 +538,75 @@ def _complete_start_connectors(**kw) -> List[str]:
     return _complete_show_connectors(**kw)
 
 
+def _start_pipeline(
+    action: Optional[List[str]] = None,
+    sub_args: Optional[List[str]] = None,
+    loop: bool = False,
+    min_seconds: Union[float, int, None] = 1.0,
+    params: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> SuccessTuple:
+    """
+    Run a series of Meerschaum commands as a single action.
+
+    Add `:` to the end of chained arguments to apply additional flags to the pipeline.
+
+    Examples
+    --------
+
+    `sync pipes -i sql:local + sync pipes -i sql:main :: -s 'daily'`
+
+    `show version + show arguments :: --loop`
+
+    """
+    import time
+    from meerschaum._internal.entry import entry
+    from meerschaum.utils.warnings import info, warn
+    from meerschaum.utils.misc import is_int
+
+    do_n_times = (
+        int(action[0].lstrip('x'))
+        if action and is_int(action[0].lstrip('x'))
+        else 1
+    )
+
+    if not sub_args:
+        return False, "Nothing to do."
+
+    if min_seconds is None:
+        min_seconds = 1.0
+
+    ran_n_times = 0
+    success, msg = False, "Did not run pipeline."
+    def run_loop():
+        nonlocal ran_n_times, success, msg
+        while True:
+            success, msg = entry(sub_args, _patch_args=params)
+            ran_n_times += 1
+
+            if not loop and do_n_times == 1:
+                break
+
+            if min_seconds != 0 and ran_n_times != do_n_times:
+                info(f"Sleeping for {min_seconds} seconds...")
+                time.sleep(min_seconds)
+
+            if loop:
+                continue
+
+            if ran_n_times >= do_n_times:
+                break
+
+    try:
+        run_loop()
+    except KeyboardInterrupt:
+        warn("Cancelled pipeline.", stack=False)
+
+    if do_n_times != 1:
+        info(f"Ran pipeline {ran_n_times} time" + ('s' if ran_n_times != 1 else '') + '.')
+    return success, msg
+
+
 ### NOTE: This must be the final statement of the module.
 ###       Any subactions added below these lines will not
 ###       be added to the `help` docstring.

meerschaum/actions/stop.py

@@ -27,13 +27,20 @@ def _complete_stop(
     """
     Override the default Meerschaum `complete_` function.
     """
-    from meerschaum.actions.start import _complete_start_jobs
+    from meerschaum.actions.delete import _complete_delete_jobs
+    from functools import partial
+
     if action is None:
         action = []
 
+    _complete_stop_jobs = partial(
+        _complete_delete_jobs,
+        _get_job_method=('running', 'paused', 'restart'),
+    )
+
     options = {
-        'job' : _complete_start_jobs,
-        'jobs' : _complete_start_jobs,
+        'job' : _complete_stop_jobs,
+        'jobs' : _complete_stop_jobs,
     }
 
     if (
@@ -50,11 +57,13 @@ def _complete_stop(
 
 def _stop_jobs(
     action: Optional[List[str]] = None,
+    executor_keys: Optional[str] = None,
     timeout_seconds: Optional[int] = None,
     noask: bool = False,
     force: bool = False,
     yes: bool = False,
     nopretty: bool = False,
+    debug: bool = False,
     **kw
 ) -> SuccessTuple:
     """
@@ -62,66 +71,93 @@ def _stop_jobs(
     
     To see running processes, run `show jobs`.
     """
+    from meerschaum.jobs import (
+        get_filtered_jobs,
+        get_running_jobs,
+        get_paused_jobs,
+        get_stopped_jobs,
+        get_restart_jobs,
+    )
     from meerschaum.utils.formatting._jobs import pprint_jobs
     from meerschaum.utils.daemon import (
         get_filtered_daemons, get_running_daemons, get_stopped_daemons, get_paused_daemons,
     )
     from meerschaum.utils.warnings import warn
     from meerschaum.utils.prompt import yes_no
-    daemons = get_filtered_daemons(action, warn=(not nopretty))
-    _running_daemons = get_running_daemons(daemons)
-    _paused_daemons = get_paused_daemons(daemons)
-    _stopped_daemons = get_stopped_daemons(daemons)
-    if action and _stopped_daemons and not nopretty:
+
+    jobs = get_filtered_jobs(executor_keys, action, warn=(not nopretty))
+    running_jobs = get_running_jobs(executor_keys, jobs)
+    paused_jobs = get_paused_jobs(executor_keys, jobs)
+    restart_jobs = get_restart_jobs(executor_keys, jobs)
+    stopped_jobs = {
+        name: job
+        for name, job in get_stopped_jobs(executor_keys, jobs).items()
+        if name not in restart_jobs
+    }
+
+    jobs_to_stop = {
+        **running_jobs,
+        **paused_jobs,
+        **restart_jobs,
+    }
+
+    if action and stopped_jobs and not nopretty:
         warn(
-            f"Skipping stopped job" + ("s" if len(_stopped_daemons) > 1 else '') + " '" +
-                ("', '".join(d.daemon_id for d in _stopped_daemons)) + "'.",
-            stack = False
+            "Skipping stopped job"
+            + ("s" if len(stopped_jobs) != 1 else '')
+            + " '"
+            + ("', '".join(name for name in stopped_jobs)) + "'.",
+            stack=False,
         )
 
-    daemons_to_stop = _running_daemons + _paused_daemons
-    if not daemons_to_stop:
-        return False, "No running or paused jobs to stop."
+    if not jobs_to_stop:
+        return False, "No running, paused or restarting jobs to stop."
 
     if not action:
         if not force:
-            pprint_jobs(daemons_to_stop)
+            pprint_jobs(jobs_to_stop)
             if not yes_no(
                 "Stop the above jobs?",
                 noask=noask, yes=yes, default='n'
             ):
                 return False, "No jobs were stopped."
 
-    _quit_daemons, _kill_daemons = [], []
-    for d in daemons_to_stop:
-        quit_success, quit_msg = d.quit(timeout=timeout_seconds)
-        if quit_success:
-            _quit_daemons.append(d)
-            continue
-        else:
-            warn(
-                f"Failed to gracefully quit job '{d.daemon_id}', attempting to terminate:\n   "
-                + f"{quit_msg}",
-                stack = False,
-            )
-
-        kill_success, kill_msg = d.kill(timeout=timeout_seconds)
-        if kill_success:
-            _kill_daemons.append(d)
-            continue
-        if not nopretty:
-            warn(f"Failed to kill job '{d.daemon_id}' (PID {d.pid}):\n{kill_msg}", stack=False)
+    job_success_tuples = {}
+    for name, job in jobs_to_stop.items():
+        stop_success, stop_msg = job.stop(
+            timeout_seconds=timeout_seconds,
+            debug=debug,
+        )
+        job_success_tuples[name] = (stop_success, stop_msg)
 
+    num_success = sum(
+        (
+            1
+            for name, (stop_success, stop_msg) in job_success_tuples.items()
+            if stop_success
+        )
+    )
+    num_fail = sum(
+        (
+            1
+            for name, (stop_success, stop_msg) in job_success_tuples.items()
+            if not stop_success
+        )
+    )
+    success = num_success > 0
     msg = (
-        (("Stopped job" + ("s" if len(_quit_daemons) != 1 else '') +
-            " '" + "', '".join([d.daemon_id for d in _quit_daemons]) + "'.")
-            if _quit_daemons else '')
-        + (("\n" if _quit_daemons else "")
-           + ("Killed job" + ("s" if len(_kill_daemons) != 1 else '') +
-            " '" + "', '".join([d.daemon_id for d in _kill_daemons]) + "'.")
-            if _kill_daemons else '')
+        f"Stopped {num_success} job"
+        + ('s' if num_success != 1 else '')
+        + '.'
     )
-    return (len(_quit_daemons + _kill_daemons) > 0), msg
+    if num_fail > 0:
+        msg += (
+            f"\nFailed to stop {num_fail} job"
+            + ('s' if num_fail != 1 else '')
+            + '.'
+        )
+
+    return success, msg
 
 
 ### NOTE: This must be the final statement of the module.

meerschaum/api/_events.py

@@ -19,14 +19,24 @@ from meerschaum.utils.debug import dprint
 from meerschaum.connectors.poll import retry_connect
 from meerschaum.utils.warnings import warn
 from meerschaum._internal.term.tools import is_webterm_running
+from meerschaum.jobs import (
+    start_check_jobs_thread,
+    stop_check_jobs_thread,
+    get_executor_keys_from_context,
+)
+
+_check_jobs_thread = None
 
 @app.on_event("startup")
 async def startup():
-    conn = get_api_connector()
+    """
+    Connect to the instance database and begin monitoring jobs.
+    """
     try:
         if not no_dash:
             from meerschaum.api.dash.webterm import start_webterm
             start_webterm()
+
         connected = retry_connect(
             get_api_connector(),
             workers = get_uvicorn_config().get('workers', None),
@@ -36,18 +46,32 @@ async def startup():
         import traceback
         traceback.print_exc()
         connected = False
+
     if not connected:
         await shutdown()
         os._exit(1)
 
+    if get_executor_keys_from_context() == 'local':
+        start_check_jobs_thread()
+
 
 @app.on_event("shutdown")
 async def shutdown():
+    """
+    Close the database connection and stop monitoring jobs.
+    """
     if debug:
         dprint("Closing connection...")
     if get_api_connector().type == 'sql':
         get_api_connector().engine.dispose()
 
+    if get_executor_keys_from_context() == 'local':
+        stop_check_jobs_thread()
+
+    from meerschaum.api.routes._actions import _temp_jobs
+    for name, job in _temp_jobs.items():
+        job.delete()
+
     ### Terminate any running jobs left over.
     if 'meerschaum.api.dash' in sys.modules:
         from meerschaum.api.dash.actions import running_jobs, stop_action

meerschaum/api/_oauth2.py

@@ -30,6 +30,7 @@ class CustomOAuth2PasswordRequestForm:
         self.client_id = client_id
         self.client_secret = client_secret
 
+
 LoginManager = fastapi_login.LoginManager
 def generate_secret_key() -> str:
     """
@@ -46,5 +47,6 @@ def generate_secret_key() -> str:
 
     return secret_key.encode('utf-8')
 
+
 SECRET = generate_secret_key()
 manager = LoginManager(SECRET, token_url=endpoints['login'])

meerschaum/api/_websockets.py

@@ -23,8 +23,8 @@ sessions = {}
 @app.websocket('/dash/ws')
 @app.websocket(_websocket_endpoint)
 async def websocket_endpoint(
-        websocket: fastapi.WebSocket,
-    ):
+    websocket: fastapi.WebSocket,
+):
     """
     Communicate with the Web Interface over a websocket.
     """