meerschaum 3.4.4.dev1__tar.gz → 3.4.5.dev1__tar.gz

{meerschaum-3.4.4.dev1/meerschaum.egg-info → meerschaum-3.4.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meerschaum
-Version: 3.4.4.dev1
+Version: 3.4.5.dev1
 Summary: Sync Time-Series Pipes with Meerschaum
 Author-email: Bennett Meares <bennett.meares@gmail.com>
 Maintainer-email: Bennett Meares <bennett.meares@gmail.com>

{meerschaum-3.4.4.dev1 → meerschaum-3.4.5.dev1}/meerschaum/config/_version.py

@@ -2,4 +2,4 @@
 Specify the Meerschaum release version.
 """
 
-__version__ = "3.4.4.dev1"
+__version__ = "3.4.5.dev1"

{meerschaum-3.4.4.dev1 → meerschaum-3.4.5.dev1}/meerschaum/config/environment.py

@@ -12,10 +12,18 @@ import json
 import contextlib
 import copy
 import pathlib
+import threading
 
 from meerschaum.utils.typing import List, Union, Dict, Any, Optional
 from meerschaum._internal.static import STATIC_CONFIG
 
+### Serialize the process-global swap of `os.environ` and `meerschaum.config.paths`
+### globals performed by `replace_env`. A daemon process runs several threads
+### concurrently (the job target plus the `check-jobs` `RepeatTimer`), so two
+### overlapping `replace_env` calls could otherwise leave these globals in a torn
+### state.
+_replace_env_lock = threading.RLock()
+
 
 def apply_environment_patches(env: Optional[Dict[str, Any]] = None) -> None:
     """
@@ -222,57 +230,73 @@ def replace_env(env: Union[Dict[str, Any], None]):
     old_venvs_dir_path = paths.VIRTENV_RESOURCES_PATH
     old_config_dir_path = paths.CONFIG_DIR_PATH
 
-    os.environ.update(env)
-
     root_dir_env_var = STATIC_CONFIG['environment']['root']
     plugins_dir_env_var = STATIC_CONFIG['environment']['plugins']
     config_dir_env_var = STATIC_CONFIG['environment']['config_dir']
     venvs_dir_env_var = STATIC_CONFIG['environment']['venvs']
 
     replaced_root = False
-    if root_dir_env_var in env:
-        root_dir_path = pathlib.Path(env[root_dir_env_var])
-        paths.set_root(root_dir_path)
-        replaced_root = True
-
     replaced_plugins = False
-    if plugins_dir_env_var in env:
-        plugins_dir_paths = env[plugins_dir_env_var]
-        paths.set_plugins_dir_paths(plugins_dir_paths)
-        replaced_plugins = True
-
     replaced_venvs = False
-    if venvs_dir_env_var in env:
-        venv_dir_path = pathlib.Path(env[venvs_dir_env_var])
-        paths.set_venvs_dir_path(venv_dir_path)
-        replaced_venvs = True
-
     replaced_config_dir = False
-    if config_dir_env_var in env:
-        config_dir_path = pathlib.Path(env[config_dir_env_var])
-        paths.set_config_dir_path(config_dir_path)
-        replaced_config_dir = True
 
-    apply_environment_patches(env)
-    apply_environment_uris(env)
+    ### Hold the lock only while swapping the process-global state, not across the
+    ### `yield` (which runs arbitrary user code and could deadlock or serialize the
+    ### whole daemon).
+    with _replace_env_lock:
+        os.environ.update(env)
 
-    try:
-        yield
-    finally:
-        os.environ.clear()
-        os.environ.update(old_environ)
+        if root_dir_env_var in env:
+            root_dir_path = pathlib.Path(env[root_dir_env_var])
+            paths.set_root(root_dir_path)
+            replaced_root = True
 
-        if replaced_root:
-            paths.set_root(old_root_dir_path)
+        if plugins_dir_env_var in env:
+            plugins_dir_paths = env[plugins_dir_env_var]
+            paths.set_plugins_dir_paths(plugins_dir_paths)
+            replaced_plugins = True
 
-        if replaced_plugins:
-            paths.set_plugins_dir_paths(old_plugins_dir_paths)
+        if venvs_dir_env_var in env:
+            venv_dir_path = pathlib.Path(env[venvs_dir_env_var])
+            paths.set_venvs_dir_path(venv_dir_path)
+            replaced_venvs = True
 
-        if replaced_venvs:
-            paths.set_venvs_dir_path(old_venvs_dir_path)
+        if config_dir_env_var in env:
+            config_dir_path = pathlib.Path(env[config_dir_env_var])
+            paths.set_config_dir_path(config_dir_path)
+            replaced_config_dir = True
 
-        if replaced_config_dir:
-            paths.set_config_dir_path(old_config_dir_path)
+        apply_environment_patches(env)
+        apply_environment_uris(env)
 
-        _config().clear()
-        set_config(old_config)
+    try:
+        yield
+    finally:
+        with _replace_env_lock:
+            ### Restore `os.environ` by diffing, NOT `clear()` + `update()`.
+            ### `clear()` blanks the entire environment for a window during which a
+            ### concurrent thread (e.g. a daemon's `sync_plugins_symlinks`) sees
+            ### `MRSM_PLUGINS_DIR` as absent and falls back to the host plugins dir,
+            ### so it never creates a project's plugin symlinks (the `plugin:<name>`
+            ### job then fails to import). Keys present in `old_environ` are never
+            ### removed, so vars like `MRSM_PLUGINS_DIR` never momentarily vanish.
+            for key in [k for k in os.environ if k not in old_environ]:
+                del os.environ[key]
+            for key, val in old_environ.items():
+                if os.environ.get(key) != val:
+                    os.environ[key] = val
+
+            if replaced_root:
+                paths.set_root(old_root_dir_path)
+
+            if replaced_plugins:
+                paths.set_plugins_dir_paths(old_plugins_dir_paths)
+
+            if replaced_venvs:
+                paths.set_venvs_dir_path(old_venvs_dir_path)
+
+            if replaced_config_dir:
+                paths.set_config_dir_path(old_config_dir_path)
+
+            _config().clear()
+            set_config(old_config)

{meerschaum-3.4.4.dev1 → meerschaum-3.4.5.dev1}/meerschaum/plugins/__init__.py

@@ -465,6 +465,20 @@ def sync_plugins_symlinks(debug: bool = False, warn: bool = True) -> None:
                     continue
                 if real_path in injected_symlinked_paths.values():
                     continue
+                ### Only reap a symlink whose target NO LONGER EXISTS (a genuinely stale
+                ### plugin). A symlink whose target still exists is a valid plugin from
+                ### another configured plugins directory and must not be removed here:
+                ### `PLUGINS_DIR_PATHS` is process-global and can transiently fall back to
+                ### the host default when `MRSM_PLUGINS_DIR` is momentarily absent from the
+                ### environment (e.g. a daemon thread or a `replace_env` context). Removing
+                ### valid cross-dir symlinks in that window deletes a project's plugin
+                ### links from the shared per-root `.internal/plugins`, so a
+                ### `plugin:<name>`-backed background job then fails to import its plugin.
+                try:
+                    if real_path.exists():
+                        continue
+                except Exception:
+                    pass
                 try:
                     plugin_symlink_path.unlink()
                 except Exception:
@@ -802,7 +816,9 @@ def unload_plugins(
     Unload the specified plugins from memory.
     """
     global _loaded_plugins, _synced_symlinks
+    import os
     import sys
+    import pathlib
     import meerschaum.config.paths as paths
     from meerschaum.connectors import unload_plugin_connectors
     if debug:
@@ -871,14 +887,38 @@ def unload_plugins(
             file_symlink_path = paths.PLUGINS_RESOURCES_PATH / f"{plugin_name}.py"
             file_symlink_injected_path = paths.PLUGINS_INJECTED_RESOURCES_PATH / f"{plugin_name}.py"
 
+            ### Only remove a symlink whose target NO LONGER EXISTS (a genuinely stale
+            ### plugin). The per-root `.internal/plugins` directory is SHARED by every
+            ### process operating on that root — including a `plugin:<name>`-backed
+            ### background job that may have been started moments earlier (e.g. by
+            ### `mrsm compose start jobs`, which loads project plugins, starts the job
+            ### daemon, then unloads). Removing a still-valid plugin symlink here deletes
+            ### it out from under that daemon, so its plugin import fails with
+            ### "Plugin '<name>' cannot be found". In-memory unloading (popping
+            ### `sys.modules` above) is process-local and is all that unloading needs;
+            ### the symlink lifecycle is owned by `sync_plugins_symlinks`.
+            def _target_exists(symlink_path):
+                try:
+                    return pathlib.Path(os.path.realpath(symlink_path)).exists()
+                except Exception:
+                    return False
+
             try:
-                if dir_symlink_path.exists() and not dir_symlink_injected_path.exists():
+                if (
+                    dir_symlink_path.exists()
+                    and not dir_symlink_injected_path.exists()
+                    and not _target_exists(dir_symlink_path)
+                ):
                     dir_symlink_path.unlink()
             except Exception:
                 pass
 
             try:
-                if file_symlink_path.exists() and not file_symlink_injected_path.exists():
+                if (
+                    file_symlink_path.exists()
+                    and not file_symlink_injected_path.exists()
+                    and not _target_exists(file_symlink_path)
+                ):
                     file_symlink_path.unlink()
             except Exception:
                 pass

{meerschaum-3.4.4.dev1 → meerschaum-3.4.5.dev1}/meerschaum/utils/daemon/Daemon.py

@@ -349,13 +349,6 @@ class Daemon:
 
                     self.properties['result'] = None
                     self._capture_process_timestamp('began')
-                    try:
-                        import meerschaum.plugins as _plugins
-                        _plugins._synced_symlinks = 0
-                        _plugins.sync_plugins_symlinks(warn=False)
-                    except Exception:
-                        pass
-
                     result = self.target(*self.target_args, **self.target_kw)
                     self.properties['result'] = result
                 except (BrokenPipeError, KeyboardInterrupt, SystemExit):
@@ -530,19 +523,41 @@ class Daemon:
         -------
         A SuccessTuple indicating success.
         """
+        ### A lost PID file means a detached/orphaned daemon — possibly SEVERAL processes
+        ### sharing this daemon_id (e.g. accumulated across crashed restarts). Reap them
+        ### ALL by daemon_id rather than reporting a false "stopped" and stranding them
+        ### (which forces a manual `pkill meerschaum` or hunting the daemon_id in htop).
+        if not self.pid_path.exists():
+            reaped = self._kill_detached_processes(timeout)
+            self._write_stop_file('kill')
+            self.stdin_file.close()
+            self._remove_blocking_stdin_file()
+            return True, (
+                (f"Reaped {reaped} detached process" + ('es' if reaped != 1 else '') + '.')
+                if reaped
+                else "Process has already stopped."
+            )
+
         if self.status != 'paused':
             success, msg = self._send_signal(signal.SIGTERM, timeout=timeout)
             if success:
+                ### Sweep any sibling/detached processes left over for this daemon_id.
+                self._kill_detached_processes(timeout)
                 self._write_stop_file('kill')
                 self.stdin_file.close()
                 self._remove_blocking_stdin_file()
                 return success, msg
 
         if self.status == 'stopped':
+            reaped = self._kill_detached_processes(timeout)
             self._write_stop_file('kill')
             self.stdin_file.close()
             self._remove_blocking_stdin_file()
-            return True, "Process has already stopped."
+            return True, (
+                (f"Reaped {reaped} detached process" + ('es' if reaped != 1 else '') + '.')
+                if reaped
+                else "Process has already stopped."
+            )
 
         psutil = attempt_import('psutil')
         process = self.process
@@ -575,6 +590,20 @@ class Daemon:
         if self.status == 'paused':
             return self.kill(timeout)
 
+        ### A lost PID file means a detached/orphaned daemon (possibly several processes);
+        ### the normal signal path can't see them, so reap them all by daemon_id instead
+        ### of returning a false "not running".
+        if not self.pid_path.exists():
+            reaped = self._kill_detached_processes(timeout)
+            self._write_stop_file('quit')
+            self.stdin_file.close()
+            self._remove_blocking_stdin_file()
+            return True, (
+                (f"Reaped {reaped} detached process" + ('es' if reaped != 1 else '') + '.')
+                if reaped
+                else "Process is not running."
+            )
+
         signal_success, signal_msg = self._send_signal(signal.SIGINT, timeout=timeout)
         if signal_success:
             self._write_stop_file('quit')
@@ -846,6 +875,68 @@ class Daemon:
             + ('s' if timeout != 1 else '') + '.'
         )
 
+    def _find_detached_pids(self) -> List[int]:
+        """
+        Return the PIDs of any processes whose command line references this daemon_id.
+
+        A daemon is launched via `venv_exec` with `Daemon(daemon_id='<id>')` embedded in
+        the executed code, so the daemon_id stays visible in the process's command line.
+        When the PID file is lost (e.g. the launcher exited without cleanup, leaving an
+        orphaned/detached daemon), this is the only reliable way to find the process —
+        otherwise stopping the job reports a false "already stopped" and the user must
+        resort to `pkill meerschaum` or hunting the daemon_id in `htop`.
+        """
+        psutil = attempt_import('psutil')
+        marker = f"daemon_id='{self.daemon_id}'"
+        my_pid = os.getpid()
+        pids = []
+        for proc in psutil.process_iter(['pid', 'cmdline']):
+            try:
+                if proc.info['pid'] == my_pid:
+                    continue
+                cmdline = proc.info.get('cmdline') or []
+                if any(marker in (part or '') for part in cmdline):
+                    pids.append(int(proc.info['pid']))
+            except Exception:
+                continue
+        return pids
+
+    def _kill_detached_processes(self, timeout: Union[int, float, None] = None) -> int:
+        """
+        SIGTERM then SIGKILL any detached processes referencing this daemon_id.
+
+        Fallback for when the PID file is gone but the daemon (or its threads) are still
+        alive. Returns the number of processes that were targeted.
+        """
+        psutil = attempt_import('psutil')
+        pids = self._find_detached_pids()
+        if not pids:
+            return 0
+
+        procs = []
+        for pid in pids:
+            try:
+                procs.append(psutil.Process(pid))
+            except Exception:
+                continue
+        for proc in procs:
+            try:
+                proc.terminate()
+            except Exception:
+                pass
+
+        timeout = self.get_timeout_seconds(timeout)
+        try:
+            _, alive = psutil.wait_procs(procs, timeout=(timeout or 8))
+        except Exception:
+            alive = procs
+        for proc in alive:
+            try:
+                proc.kill()
+            except Exception:
+                pass
+        return len(procs)
+
     def mkdir_if_not_exists(self, allow_dirty_run: bool = False):
         """Create the Daemon's directory.
         If `allow_dirty_run` is `False` and the directory already exists,
@@ -1139,7 +1230,13 @@ class Daemon:
         Returns `None` if the PID file does not exist.
         """
         if not self.pid_path.exists():
-            return None
+            ### The PID file can be lost while a detached daemon keeps running (e.g. the
+            ### launcher exited without cleanup). Recover the PID by finding the process
+            ### whose command line embeds this daemon_id, so `status`/`stop`/`kill` see the
+            ### live process instead of reporting a false "stopped" (which would strand the
+            ### orphan, forcing a manual `pkill meerschaum`).
+            detached_pids = self._find_detached_pids()
+            return detached_pids[0] if detached_pids else None
         try:
             with open(self.pid_path, 'r', encoding='utf-8') as f:
                 text = f.read()

{meerschaum-3.4.4.dev1 → meerschaum-3.4.5.dev1}/meerschaum/utils/packages/__init__.py

@@ -1853,7 +1853,7 @@ def package_venv(package: 'ModuleType') -> Union[str, None]:
     Inspect a package and return the virtual environment in which it presides.
     """
     import os
-    import meerschaum.confing.paths as paths
+    import meerschaum.config.paths as paths
     if str(paths.VIRTENV_RESOURCES_PATH) not in package.__file__:
         return None
     return package.__file__.split(str(paths.VIRTENV_RESOURCES_PATH))[1].split(os.path.sep)[1]

{meerschaum-3.4.4.dev1 → meerschaum-3.4.5.dev1/meerschaum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meerschaum
-Version: 3.4.4.dev1
+Version: 3.4.5.dev1
 Summary: Sync Time-Series Pipes with Meerschaum
 Author-email: Bennett Meares <bennett.meares@gmail.com>
 Maintainer-email: Bennett Meares <bennett.meares@gmail.com>