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

meerschaum/utils/daemon/Daemon.py

@@ -17,10 +17,17 @@ import time
 import traceback
 from functools import partial
 from datetime import datetime, timezone
-from meerschaum.utils.typing import Optional, Dict, Any, SuccessTuple, Callable, List, Union
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import (
+    Optional, Dict, Any, SuccessTuple, Callable, List, Union,
+    is_success_tuple,
+)
 from meerschaum.config import get_config
 from meerschaum.config.static import STATIC_CONFIG
-from meerschaum.config._paths import DAEMON_RESOURCES_PATH, LOGS_RESOURCES_PATH
+from meerschaum.config._paths import (
+    DAEMON_RESOURCES_PATH, LOGS_RESOURCES_PATH, DAEMON_ERROR_LOG_PATH,
+)
 from meerschaum.config._patch import apply_patch_to_config
 from meerschaum.utils.warnings import warn, error
 from meerschaum.utils.packages import attempt_import
@@ -30,6 +37,9 @@ from meerschaum.utils.daemon.RotatingFile import RotatingFile
 from meerschaum.utils.threading import RepeatTimer
 from meerschaum.__main__ import _close_pools
 
+_daemons = []
+_results = {}
+
 class Daemon:
     """
     Daemonize Python functions into background processes.
@@ -94,7 +104,7 @@ class Daemon:
                 )
         if 'target' not in self.__dict__:
             if target is None:
-                error(f"Cannot create a Daemon without a target.")
+                error("Cannot create a Daemon without a target.")
             self.target = target
         if 'target_args' not in self.__dict__:
             self.target_args = target_args if target_args is not None else []
@@ -113,16 +123,16 @@ class Daemon:
             self._properties = properties
         if self._properties is None:
             self._properties = {}
-        self._properties.update({'label' : self.label})
+        self._properties.update({'label': self.label})
         ### Instantiate the process and if it doesn't exist, make sure the PID is removed.
         _ = self.process
 
 
     def _run_exit(
-            self,
-            keep_daemon_output: bool = True,
-            allow_dirty_run: bool = False,
-        ) -> Any:
+        self,
+        keep_daemon_output: bool = True,
+        allow_dirty_run: bool = False,
+    ) -> Any:
         """Run the daemon's target function.
         NOTE: This WILL EXIT the parent process!
 
@@ -130,7 +140,7 @@ class Daemon:
         ----------
         keep_daemon_output: bool, default True
             If `False`, delete the daemon's output directory upon exiting.
-            
+
         allow_dirty_run, bool, default False:
             If `True`, run the daemon, even if the `daemon_id` directory exists.
             This option is dangerous because if the same `daemon_id` runs twice,
@@ -141,31 +151,34 @@ class Daemon:
         Nothing — this will exit the parent process.
         """
         import platform, sys, os, traceback
-        from meerschaum.config._paths import DAEMON_ERROR_LOG_PATH
         from meerschaum.utils.warnings import warn
         from meerschaum.config import get_config
         daemon = attempt_import('daemon')
         lines = get_config('jobs', 'terminal', 'lines')
-        columns = get_config('jobs','terminal', 'columns')
+        columns = get_config('jobs', 'terminal', 'columns')
 
         if platform.system() == 'Windows':
             return False, "Windows is no longer supported."
 
         self._setup(allow_dirty_run)
 
+        ### NOTE: The SIGINT handler has been removed so that child processes may handle
+        ###       KeyboardInterrupts themselves.
+        ###       The previous aggressive approach was redundant because of the SIGTERM handler.
         self._daemon_context = daemon.DaemonContext(
-            pidfile = self.pid_lock,
-            stdout = self.rotating_log,
-            stderr = self.rotating_log,
-            working_directory = os.getcwd(),
-            detach_process = True,
-            files_preserve = list(self.rotating_log.subfile_objects.values()),
-            signal_map = {
-                signal.SIGINT: self._handle_interrupt,
+            pidfile=self.pid_lock,
+            stdout=self.rotating_log,
+            stderr=self.rotating_log,
+            working_directory=os.getcwd(),
+            detach_process=True,
+            files_preserve=list(self.rotating_log.subfile_objects.values()),
+            signal_map={
                 signal.SIGTERM: self._handle_sigterm,
             },
         )
 
+        _daemons.append(self)
+
         log_refresh_seconds = get_config('jobs', 'logs', 'refresh_files_seconds')
         self._log_refresh_timer = RepeatTimer(
             log_refresh_seconds,
@@ -177,53 +190,52 @@ class Daemon:
             with self._daemon_context:
                 os.environ[STATIC_CONFIG['environment']['daemon_id']] = self.daemon_id
                 self.rotating_log.refresh_files(start_interception=True)
+                result = None
                 try:
                     with open(self.pid_path, 'w+', encoding='utf-8') as f:
                         f.write(str(os.getpid()))
 
                     self._log_refresh_timer.start()
+                    self.properties['result'] = None
+                    self.write_properties()
                     result = self.target(*self.target_args, **self.target_kw)
                     self.properties['result'] = result
+                except (BrokenPipeError, KeyboardInterrupt, SystemExit):
+                    pass
                 except Exception as e:
-                    warn(f"Exception in daemon target function: {e}", stacklevel=3)
+                    warn(
+                        f"Exception in daemon target function: {traceback.format_exc()}",
+                    )
                     result = e
                 finally:
+                    _results[self.daemon_id] = result
+
+                    if keep_daemon_output:
+                        self._capture_process_timestamp('ended')
+                    else:
+                        self.cleanup()
+
                     self._log_refresh_timer.cancel()
-                    self.rotating_log.close()
                     if self.pid is None and self.pid_path.exists():
                         self.pid_path.unlink()
 
-                if keep_daemon_output:
-                    self._capture_process_timestamp('ended')
-                else:
-                    self.cleanup()
+                    if is_success_tuple(result):
+                        try:
+                            mrsm.pprint(result)
+                        except BrokenPipeError:
+                            pass
 
-                return result
         except Exception as e:
             daemon_error = traceback.format_exc()
             with open(DAEMON_ERROR_LOG_PATH, 'a+', encoding='utf-8') as f:
                 f.write(daemon_error)
             warn(f"Encountered an error while running the daemon '{self}':\n{daemon_error}")
-        finally:
-            self._cleanup_on_exit()
-
-    def _cleanup_on_exit(self):
-        """Perform cleanup operations when the daemon exits."""
-        try:
-            self._log_refresh_timer.cancel()
-            self.rotating_log.close()
-            if self.pid is None and self.pid_path.exists():
-                self.pid_path.unlink()
-            self._capture_process_timestamp('ended')
-        except Exception as e:
-            warn(f"Error during daemon cleanup: {e}")
-
 
     def _capture_process_timestamp(
-            self,
-            process_key: str,
-            write_properties: bool = True,
-        ) -> None:
+        self,
+        process_key: str,
+        write_properties: bool = True,
+    ) -> None:
         """
         Record the current timestamp to the parameters `process:<process_key>`.
 
@@ -247,13 +259,12 @@ class Daemon:
         if write_properties:
             self.write_properties()
 
-
     def run(
-            self,
-            keep_daemon_output: bool = True,
-            allow_dirty_run: bool = False,
-            debug: bool = False,
-        ) -> SuccessTuple:
+        self,
+        keep_daemon_output: bool = True,
+        allow_dirty_run: bool = False,
+        debug: bool = False,
+    ) -> SuccessTuple:
         """Run the daemon as a child process and continue executing the parent.
 
         Parameters
@@ -288,7 +299,7 @@ class Daemon:
             "from meerschaum.utils.daemon import Daemon; "
             + f"daemon = Daemon(daemon_id='{self.daemon_id}'); "
             + f"daemon._run_exit(keep_daemon_output={keep_daemon_output}, "
-            + f"allow_dirty_run=True)"
+            + "allow_dirty_run=True)"
         )
         env = dict(os.environ)
         env['MRSM_NOASK'] = 'true'
@@ -298,11 +309,9 @@ class Daemon:
             if _launch_success_bool
             else f"Failed to start daemon '{self.daemon_id}'."
         )
-        self._capture_process_timestamp('began')
         return _launch_success_bool, msg
 
-
-    def kill(self, timeout: Optional[int] = 8) -> SuccessTuple:
+    def kill(self, timeout: Union[int, float, None] = 8) -> SuccessTuple:
         """Forcibly terminate a running daemon.
         Sends a SIGTERM signal to the process.
 
@@ -318,7 +327,6 @@ class Daemon:
         if self.status != 'paused':
             success, msg = self._send_signal(signal.SIGTERM, timeout=timeout)
             if success:
-                self._capture_process_timestamp('ended')
                 return success, msg
 
         if self.status == 'stopped':
@@ -332,7 +340,6 @@ class Daemon:
         except Exception as e:
             return False, f"Failed to kill job {self} with exception: {e}"
 
-        self._capture_process_timestamp('ended')
         if self.pid_path.exists():
             try:
                 self.pid_path.unlink()
@@ -340,22 +347,18 @@ class Daemon:
                 pass
         return True, "Success"
 
-
     def quit(self, timeout: Union[int, float, None] = None) -> SuccessTuple:
         """Gracefully quit a running daemon."""
         if self.status == 'paused':
             return self.kill(timeout)
         signal_success, signal_msg = self._send_signal(signal.SIGINT, timeout=timeout)
-        if signal_success:
-            self._capture_process_timestamp('ended')
         return signal_success, signal_msg
 
-
     def pause(
-            self,
-            timeout: Union[int, float, None] = None,
-            check_timeout_interval: Union[float, int, None] = None,
-        ) -> SuccessTuple:
+        self,
+        timeout: Union[int, float, None] = None,
+        check_timeout_interval: Union[float, int, None] = None,
+    ) -> SuccessTuple:
         """
         Pause the daemon if it is running.
 
@@ -414,7 +417,6 @@ class Daemon:
             + ('s' if timeout != 1 else '') + '.'
         )
 
-
     def resume(
             self,
             timeout: Union[int, float, None] = None,
@@ -471,38 +473,6 @@ class Daemon:
         )
 
 
-    def _handle_interrupt(self, signal_number: int, stack_frame: 'frame') -> None:
-        """
-        Handle `SIGINT` within the Daemon context.
-        This method is injected into the `DaemonContext`.
-        """
-        from meerschaum.utils.process import signal_handler
-        signal_handler(signal_number, stack_frame)
-
-        self.rotating_log.stop_log_fd_interception(unused_only=False)
-        timer = self.__dict__.get('_log_refresh_timer', None)
-        if timer is not None:
-            timer.cancel()
-
-        daemon_context = self.__dict__.get('_daemon_context', None)
-        if daemon_context is not None:
-            daemon_context.close()
-
-        _close_pools()
-
-        import threading
-        for thread in threading.enumerate():
-            if thread.name == 'MainThread':
-                continue
-            try:
-                if thread.is_alive():
-                    stack = traceback.format_stack(sys._current_frames()[thread.ident])
-                    thread.join()
-            except Exception as e:
-                warn(traceback.format_exc())
-        raise KeyboardInterrupt()
-
-
     def _handle_sigterm(self, signal_number: int, stack_frame: 'frame') -> None:
         """
         Handle `SIGTERM` within the `Daemon` context.
@@ -522,7 +492,6 @@ class Daemon:
         _close_pools()
         raise SystemExit(0)
 
- 
     def _send_signal(
             self,
             signal_to_send,
@@ -578,7 +547,6 @@ class Daemon:
             + ('s' if timeout != 1 else '') + '.'
         )
 
-
     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,
@@ -618,7 +586,6 @@ class Daemon:
                 return None
         return self._process
 
-
     @property
     def status(self) -> str:
         """
@@ -633,7 +600,7 @@ class Daemon:
                 return 'paused'
             if self.process.status() == 'zombie':
                 raise psutil.NoSuchProcess(self.process.pid)
-        except psutil.NoSuchProcess:
+        except (psutil.NoSuchProcess, AttributeError):
             if self.pid_path.exists():
                 try:
                     self.pid_path.unlink()
@@ -643,7 +610,6 @@ class Daemon:
 
         return 'running'
 
-
     @classmethod
     def _get_path_from_daemon_id(cls, daemon_id: str) -> pathlib.Path:
         """
@@ -651,7 +617,6 @@ class Daemon:
         """
         return DAEMON_RESOURCES_PATH / daemon_id
 
-
     @property
     def path(self) -> pathlib.Path:
         """
@@ -659,7 +624,6 @@ class Daemon:
         """
         return self._get_path_from_daemon_id(self.daemon_id)
 
-
     @classmethod
     def _get_properties_path_from_daemon_id(cls, daemon_id: str) -> pathlib.Path:
         """
@@ -667,7 +631,6 @@ class Daemon:
         """
         return cls._get_path_from_daemon_id(daemon_id) / 'properties.json'
 
-
     @property
     def properties_path(self) -> pathlib.Path:
         """
@@ -675,7 +638,6 @@ class Daemon:
         """
         return self._get_properties_path_from_daemon_id(self.daemon_id)
 
-
     @property
     def log_path(self) -> pathlib.Path:
         """
@@ -683,7 +645,6 @@ class Daemon:
         """
         return LOGS_RESOURCES_PATH / (self.daemon_id + '.log')
 
-
     @property
     def log_offset_path(self) -> pathlib.Path:
         """
@@ -691,7 +652,6 @@ class Daemon:
         """
         return LOGS_RESOURCES_PATH / ('.' + self.daemon_id + '.log.offset')
 
-    
     @property
     def rotating_log(self) -> RotatingFile:
         if '_rotating_log' in self.__dict__:
@@ -705,7 +665,6 @@ class Daemon:
         )
         return self._rotating_log
 
-
     @property
     def log_text(self) -> Optional[str]:
         """Read the log files and return their contents.
@@ -720,7 +679,6 @@ class Daemon:
         )
         return new_rotating_log.read()
 
-
     def readlines(self) -> List[str]:
         """
         Read the next log lines, persisting the cursor for later use.
@@ -731,7 +689,6 @@ class Daemon:
         self._write_log_offset()
         return lines
 
-
     def _read_log_offset(self) -> Tuple[int, int]:
         """
         Return the current log offset cursor.
@@ -749,7 +706,6 @@ class Daemon:
         subfile_index, subfile_position = int(cursor_parts[0]), int(cursor_parts[1])
         return subfile_index, subfile_position
 
-
     def _write_log_offset(self) -> None:
         """
         Write the current log offset file.
@@ -759,7 +715,6 @@ class Daemon:
             subfile_position = self.rotating_log._cursor[1]
             f.write(f"{subfile_index} {subfile_position}")
 
-
     @property
     def pid(self) -> Union[int, None]:
         """Read the PID file and return its contents.
@@ -777,7 +732,6 @@ class Daemon:
             pid = None
         return pid
 
-
     @property
     def pid_path(self) -> pathlib.Path:
         """
@@ -785,7 +739,6 @@ class Daemon:
         """
         return self.path / 'process.pid'
 
-
     @property
     def pid_lock(self) -> 'fasteners.InterProcessLock':
         """
@@ -798,7 +751,6 @@ class Daemon:
         self._pid_lock = fasteners.InterProcessLock(self.pid_path)
         return self._pid_lock
 
-
     @property
     def pickle_path(self) -> pathlib.Path:
         """
@@ -806,7 +758,6 @@ class Daemon:
         """
         return self.path / 'pickle.pkl'
 
-
     def read_properties(self) -> Optional[Dict[str, Any]]:
         """Read the properties JSON file and return the dictionary."""
         if not self.properties_path.exists():
@@ -817,7 +768,6 @@ class Daemon:
         except Exception as e:
             return {}
 
-
     def read_pickle(self) -> Daemon:
         """Read a Daemon's pickle file and return the `Daemon`."""
         import pickle, traceback
@@ -837,21 +787,30 @@ class Daemon:
             error(msg)
         return daemon
 
-
     @property
     def properties(self) -> Dict[str, Any]:
         """
         Return the contents of the properties JSON file.
         """
-        _file_properties = self.read_properties()
+        try:
+            _file_properties = self.read_properties()
+        except Exception:
+            traceback.print_exc()
+            _file_properties = {}
+
         if not self._properties:
             self._properties = _file_properties
+
         if self._properties is None:
             self._properties = {}
+
         if _file_properties is not None:
-            self._properties = apply_patch_to_config(_file_properties, self._properties)
-        return self._properties
+            self._properties = apply_patch_to_config(
+                _file_properties,
+                self._properties,
+            )
 
+        return self._properties
 
     @property
     def hidden(self) -> bool:
@@ -860,12 +819,14 @@ class Daemon:
         """
         return self.daemon_id.startswith('_') or self.daemon_id.startswith('.')
 
-
     def write_properties(self) -> SuccessTuple:
         """Write the properties dictionary to the properties JSON file
         (only if self.properties exists).
         """
-        success, msg = False, f"No properties to write for daemon '{self.daemon_id}'."
+        success, msg = (
+            False,
+            f"No properties to write for daemon '{self.daemon_id}'."
+        )
         if self.properties is not None:
             try:
                 self.path.mkdir(parents=True, exist_ok=True)
@@ -876,7 +837,6 @@ class Daemon:
                 success, msg = False, str(e)
         return success, msg
 
-
     def write_pickle(self) -> SuccessTuple:
         """Write the pickle file for the daemon."""
         import pickle, traceback
@@ -892,9 +852,9 @@ class Daemon:
 
 
     def _setup(
-            self,
-            allow_dirty_run: bool = False,
-        ) -> None:
+        self,
+        allow_dirty_run: bool = False,
+    ) -> None:
         """
         Update properties before starting the Daemon.
         """
@@ -918,7 +878,6 @@ class Daemon:
         if not _write_pickle_success_tuple[0]:
             error(_write_pickle_success_tuple[1])
 
-
     def cleanup(self, keep_logs: bool = False) -> SuccessTuple:
         """
         Remove a daemon's directory after execution.

meerschaum/utils/daemon/FileDescriptorInterceptor.py

@@ -9,10 +9,12 @@ Intercept OS-level file descriptors.
 import os
 import select
 import traceback
+import errno
 from threading import Event
 from datetime import datetime
 from meerschaum.utils.typing import Callable
 from meerschaum.utils.warnings import warn
+from meerschaum.config.paths import DAEMON_ERROR_LOG_PATH
 
 FD_CLOSED: int = 9
 STOP_READING_FD_EVENT: Event = Event()
@@ -65,8 +67,13 @@ class FileDescriptorInterceptor:
             except BlockingIOError:
                 continue
             except OSError as e:
-                from meerschaum.utils.warnings import warn
-                warn(f"OSError in FileDescriptorInterceptor: {e}")
+                if e.errno == errno.EBADF:
+                    ### File descriptor is closed.
+                    pass
+                elif e.errno == errno.EINTR:
+                    continue  # Interrupted system call, just try again
+                else:
+                    warn(f"OSError in FileDescriptorInterceptor: {e}")
                 break
 
             try:
@@ -86,9 +93,11 @@ class FileDescriptorInterceptor:
                     else data.replace(b'\n', b'\n' + injected_bytes)
                 )
                 os.write(self.new_file_descriptor, modified_data)
-            except Exception as e:
-                from meerschaum.utils.warnings import warn
-                warn(f"Error in FileDescriptorInterceptor data processing: {e}")
+            except (BrokenPipeError, OSError):
+                break
+            except Exception:
+                with open(DAEMON_ERROR_LOG_PATH, 'a+', encoding='utf-8') as f:
+                    f.write(traceback.format_exc())
                 break
 
 

meerschaum/utils/daemon/RotatingFile.py

@@ -371,6 +371,9 @@ class RotatingFile(io.IOBase):
                 self._current_file_obj.write(data)
                 if suffix_str:
                     self._current_file_obj.write(suffix_str)
+            except BrokenPipeError:
+                warn("BrokenPipeError encountered. The daemon may have been terminated.")
+                return
             except Exception as e:
                 warn(f"Failed to write to subfile:\n{traceback.format_exc()}")
             self.flush()
@@ -581,10 +584,14 @@ class RotatingFile(io.IOBase):
         if self.redirect_streams:
             try:
                 sys.stdout.flush()
+            except BrokenPipeError:
+                pass
             except Exception as e:
                 warn(f"Failed to flush STDOUT:\n{traceback.format_exc()}")
             try:
                 sys.stderr.flush()
+            except BrokenPipeError:
+                pass
             except Exception as e:
                 warn(f"Failed to flush STDERR:\n{traceback.format_exc()}")
 
@@ -596,7 +603,6 @@ class RotatingFile(io.IOBase):
         if not self.write_timestamps:
             return
 
-        threads = self.__dict__.get('_interceptor_threads', [])
         self._stdout_interceptor = FileDescriptorInterceptor(
             sys.stdout.fileno(),
             self.get_timestamp_prefix_str,
@@ -639,6 +645,7 @@ class RotatingFile(io.IOBase):
         """
         if not self.write_timestamps:
             return
+
         interceptors = self.__dict__.get('_interceptors', [])
         interceptor_threads = self.__dict__.get('_interceptor_threads', [])