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

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
 
 
@@ -103,7 +112,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the duplicated file descriptor:\n"
+                    "Error while trying to close the duplicated file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
 
@@ -112,7 +121,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the write-pipe "
+                    "Error while trying to close the write-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
@@ -121,7 +130,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the read-pipe "
+                    "Error while trying to close the read-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
@@ -131,7 +140,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the signal-read-pipe "
+                    "Error while trying to close the signal-read-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
@@ -141,7 +150,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the signal-write-pipe "
+                    "Error while trying to close the signal-write-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )

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.
@@ -63,12 +63,18 @@ 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 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:
@@ -232,10 +238,10 @@ class RotatingFile(io.IOBase):
 
 
     def refresh_files(
-            self,
-            potential_new_len: int = 0,
-            start_interception: bool = False,
-        ) -> '_io.TextUIWrapper':
+        self,
+        potential_new_len: int = 0,
+        start_interception: bool = False,
+    ) -> '_io.TextUIWrapper':
         """
         Check the state of the subfiles.
         If the latest subfile is too large, create a new file and delete old ones.
@@ -339,7 +345,7 @@ class RotatingFile(io.IOBase):
 
     def get_timestamp_prefix_str(self) -> str:
         """
-        Return the current minute prefixm string.
+        Return the current minute prefix string.
         """
         return datetime.now(timezone.utc).strftime(self.timestamp_format) + ' | '
 
@@ -371,6 +377,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()
@@ -565,7 +574,8 @@ class RotatingFile(io.IOBase):
             return
 
         self._cursor = (max_ix, position)
-        self._current_file_obj.seek(position)
+        if self._current_file_obj is not None:
+            self._current_file_obj.seek(position)
 
     
     def flush(self) -> None:
@@ -581,10 +591,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 +610,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 +652,7 @@ class RotatingFile(io.IOBase):
         """
         if not self.write_timestamps:
             return
+
         interceptors = self.__dict__.get('_interceptors', [])
         interceptor_threads = self.__dict__.get('_interceptor_threads', [])
 

meerschaum/utils/daemon/StdinFile.py

@@ -0,0 +1,121 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim:fenc=utf-8
+
+"""
+Create a file manager to pass STDIN to the Daemon.
+"""
+
+import io
+import pathlib
+import time
+import os
+import selectors
+import traceback
+
+from meerschaum.utils.typing import Optional, Union
+from meerschaum.utils.warnings import warn
+
+
+class StdinFile(io.TextIOBase):
+    """
+    Redirect user input into a Daemon's context.
+    """
+    def __init__(
+        self,
+        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
+            if lock_file_path is not None
+            else (file_path.parent / (file_path.name + '.block'))
+        )
+        self._file_handler = None
+        self._fd = None
+        self.sel = selectors.DefaultSelector()
+
+    @property
+    def file_handler(self):
+        """
+        Return the read file handler to the provided file path.
+        """
+        if self._file_handler is not None:
+            return self._file_handler
+
+        if self.file_path.exists():
+            self.file_path.unlink()
+
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        os.mkfifo(self.file_path.as_posix(), mode=0o600)
+
+        self._fd = os.open(self.file_path, os.O_RDONLY | os.O_NONBLOCK)
+        self._file_handler = os.fdopen(self._fd, 'rb', buffering=0)
+        self.sel.register(self._file_handler, selectors.EVENT_READ)
+        return self._file_handler
+
+    def write(self, data):
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+
+        with open(self.file_path, 'wb') as f:
+            f.write(data)
+
+    def fileno(self):
+        fileno = self.file_handler.fileno()
+        return fileno
+
+    def read(self, size=-1):
+        """
+        Read from the FIFO pipe, blocking on EOFError.
+        """
+        _ = self.file_handler
+        while True:
+            try:
+                data = self._file_handler.read(size)
+                if data:
+                    try:
+                        if self.blocking_file_path.exists():
+                            self.blocking_file_path.unlink()
+                    except Exception:
+                        warn(traceback.format_exc())
+                    return data.decode('utf-8')
+            except (OSError, EOFError):
+                pass
+
+            self.blocking_file_path.touch()
+            time.sleep(0.1)
+
+    def readline(self, size=-1):
+        line = ''
+        while True:
+            data = self.read(1)
+            if not data or data == '\n':
+                break
+            line += data
+
+        return line
+
+    def close(self):
+        if self._file_handler is not None:
+            self.sel.unregister(self._file_handler)
+            self._file_handler.close()
+            os.close(self._fd)
+            self._file_handler = None
+            self._fd = None
+
+        super().close()
+
+    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:
@@ -67,19 +69,17 @@ def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
             if daemon.status == 'running':
                 return True, f"Daemon '{daemon}' is already running."
             return daemon.run(
-                debug = debug,
-                allow_dirty_run = True,
+                debug=debug,
+                allow_dirty_run=True,
             )
 
     success_tuple = run_daemon(
         entry,
         filtered_sysargs,
-        daemon_id = _args.get('name', None) if _args else None,
-        label = label,
-        keep_daemon_output = ('--rm' not in sysargs)
+        daemon_id=_args.get('name', None) if _args else None,
+        label=label,
+        keep_daemon_output=('--rm' not in (sysargs or [])),
     )
-    if not isinstance(success_tuple, tuple):
-        success_tuple = False, str(success_tuple)
     return success_tuple
 
 
@@ -109,25 +109,25 @@ def daemon_action(**kw) -> SuccessTuple:
 
 
 def run_daemon(
-        func: Callable[[Any], Any],
-        *args,
-        daemon_id: Optional[str] = None,
-        keep_daemon_output: bool = False,
-        allow_dirty_run: bool = False,
-        label: Optional[str] = None,
-        **kw
-    ) -> Any:
+    func: Callable[[Any], Any],
+    *args,
+    daemon_id: Optional[str] = None,
+    keep_daemon_output: bool = True,
+    allow_dirty_run: bool = False,
+    label: Optional[str] = None,
+    **kw
+) -> Any:
     """Execute a function as a daemon."""
     daemon = Daemon(
         func,
-        daemon_id = daemon_id,
-        target_args = [arg for arg in args],
-        target_kw = kw,
-        label = label,
+        daemon_id=daemon_id,
+        target_args=[arg for arg in args],
+        target_kw=kw,
+        label=label,
     )
     return daemon.run(
-        keep_daemon_output = keep_daemon_output,
-        allow_dirty_run = allow_dirty_run,
+        keep_daemon_output=keep_daemon_output,
+        allow_dirty_run=allow_dirty_run,
     )
 
 
@@ -183,7 +183,11 @@ def get_daemon_ids() -> List[str]:
     """
     Return the IDs of all daemons on disk.
     """
-    return sorted(os.listdir(DAEMON_RESOURCES_PATH))
+    return [
+        daemon_dir
+        for daemon_dir in sorted(os.listdir(DAEMON_RESOURCES_PATH))
+        if (DAEMON_RESOURCES_PATH / daemon_dir / 'properties.json').exists()
+    ]
 
 
 def get_running_daemons(daemons: Optional[List[Daemon]] = None) -> List[Daemon]:
@@ -227,10 +231,11 @@ def get_stopped_daemons(daemons: Optional[List[Daemon]] = None) -> List[Daemon]:
 
 
 def get_filtered_daemons(
-        filter_list: Optional[List[str]] = None,
-        warn: bool = False,
-    ) -> List[Daemon]:
-    """Return a list of `Daemons` filtered by a list of `daemon_ids`.
+    filter_list: Optional[List[str]] = None,
+    warn: bool = False,
+) -> List[Daemon]:
+    """
+    Return a list of `Daemons` filtered by a list of `daemon_ids`.
     Only `Daemons` that exist are returned.
     
     If `filter_list` is `None` or empty, return all `Daemons` (from `get_daemons()`).
@@ -252,13 +257,14 @@ def get_filtered_daemons(
     if not filter_list:
         daemons = get_daemons()
         return [d for d in daemons if not d.hidden]
+
     from meerschaum.utils.warnings import warn as _warn
     daemons = []
     for d_id in filter_list:
         try:
             d = Daemon(daemon_id=d_id)
             _exists = d.path.exists()
-        except Exception as e:
+        except Exception:
             _exists = False
         if not _exists:
             if warn:
@@ -268,3 +274,12 @@ def get_filtered_daemons(
             pass
         daemons.append(d)
     return daemons
+
+
+def running_in_daemon() -> bool:
+    """
+    Return whether the current thread is running in a Daemon context.
+    """
+    from meerschaum.config.static import STATIC_CONFIG
+    daemon_env_var = STATIC_CONFIG['environment']['daemon_id']
+    return daemon_env_var in os.environ

meerschaum/utils/daemon/_names.py

@@ -18,7 +18,8 @@ _bank: Dict[str, Dict[str, List[str]]] = {
             'bright', 'dark', 'neon',
         ],
         'sizes': [
-            'big', 'small', 'large', 'huge', 'tiny', 'long', 'short', 'grand', 'mini', 'micro'
+            'big', 'small', 'large', 'huge', 'tiny', 'long', 'short', 'average', 'mini', 'micro',
+            'maximum', 'minimum', 'median',
         ],
         'personalities': [
             'groovy', 'cool', 'awesome', 'nice', 'fantastic', 'sweet', 'great', 'amazing',
@@ -26,29 +27,36 @@ _bank: Dict[str, Dict[str, List[str]]] = {
         ],
         'emotions': [
             'angry', 'happy', 'excited', 'suspicious', 'sad', 'thankful', 'grateful', 'satisfied',
+            'peaceful', 'ferocious', 'content',
         ],
         'sensations': [
             'sleepy', 'awake', 'alert', 'thirsty', 'comfy', 'warm', 'cold', 'chilly', 'soft',
-            'smooth', 'chunky',
+            'smooth', 'chunky', 'hungry',
         ],
         'materials': [
             'golden', 'silver', 'metal', 'plastic', 'wool', 'wooden', 'nylon', 'fuzzy', 'silky',
+            'suede', 'vinyl',
         ],
         'qualities': [
             'expensive', 'cheap', 'premier', 'best', 'favorite', 'better', 'good', 'affordable',
+            'organic', 'electric',
         ],
     },
     'nouns' : {
         'animals': [
-            'mouse', 'fox', 'horse', 'dragon', 'pig', 'hippo', 'elephant' , 'tiger', 'deer',
+            'mouse', 'fox', 'horse', 'pig', 'hippo', 'elephant' , 'tiger', 'deer', 'salmon',
             'gerbil', 'snake', 'turtle', 'rhino', 'dog', 'cat', 'giraffe', 'rabbit', 'squirrel',
             'unicorn', 'lizard', 'lion', 'bear', 'gazelle', 'whale', 'dolphin', 'fish', 'butterfly',
             'ladybug', 'fly', 'shrimp', 'flamingo', 'parrot', 'tuna', 'panda', 'lemur', 'duck',
             'seal', 'walrus', 'seagull', 'iguana', 'salamander', 'kitten', 'puppy', 'octopus',
         ],
+        'weather': [
+            'rain', 'sun', 'snow', 'wind', 'tornado', 'hurricane', 'blizzard', 'monsoon', 'storm',
+            'shower', 'hail',
+        ],
         'plants': [
             'tree', 'flower', 'vine', 'fern', 'palm', 'palmetto', 'oak', 'pine', 'rose', 'lily',
-            'ivy',
+            'ivy', 'leaf', 'shrubbery', 'acorn', 'fruit',
         ],
         'foods': [
             'pizza', 'sushi', 'apple', 'banana', 'sandwich', 'burger', 'taco', 'bratwurst',
@@ -74,8 +82,6 @@ _bank: Dict[str, Dict[str, List[str]]] = {
     },
 }
 
-_disallow_combinations: List[Tuple[str, str]] = []
-
 _adjectives: List[str]= []
 for category, items in _bank['adjectives'].items():
     _adjectives += items
@@ -84,7 +90,7 @@ _nouns: List[str] = []
 for category, items in _bank['nouns'].items():
     _nouns += items
 
-def generate_random_name(separator: str = '_'):
+def generate_random_name(separator: str = '-'):
     """
     Return a random adjective and noun combination.
 
@@ -96,12 +102,8 @@ def generate_random_name(separator: str = '_'):
     -------
     A string containing an random adjective and random noun. 
     """
-    while True:
-        adjective_category = random.choice(list(_bank['adjectives'].keys()))
-        noun_category = random.choice(list(_bank['nouns'].keys()))
-        if (adjective_category, noun_category) in _disallow_combinations:
-            continue
-        break
+    adjective_category = random.choice(list(_bank['adjectives'].keys()))
+    noun_category = random.choice(list(_bank['nouns'].keys()))
     return (
         random.choice(_bank['adjectives'][adjective_category])
         + separator