ominfra 0.0.0.dev127__py3-none-any.whl → 0.0.0.dev128__py3-none-any.whl

ominfra/supervisor/configs.py

@@ -7,11 +7,21 @@ import typing as ta
 
 from ..configs import ConfigMapping
 from ..configs import build_config_named_children
-from .datatypes import byte_size
-from .datatypes import existing_directory
-from .datatypes import existing_dirpath
-from .datatypes import logging_level
-from .datatypes import octal_type
+from .utils.fs import check_existing_dir
+from .utils.fs import check_path_with_existing_dir
+from .utils.strings import parse_bytes_size
+from .utils.strings import parse_octal
+
+
+##
+
+
+class RestartWhenExitUnexpected:
+    pass
+
+
+class RestartUnconditionally:
+    pass
 
 
 ##
@@ -104,12 +114,12 @@ class ServerConfig:
             **kwargs: ta.Any,
     ) -> 'ServerConfig':
         return cls(
-            umask=octal_type(umask),
-            directory=existing_directory(directory) if directory is not None else None,
-            logfile=existing_dirpath(logfile),
-            logfile_maxbytes=byte_size(logfile_maxbytes),
-            loglevel=logging_level(loglevel),
-            pidfile=existing_dirpath(pidfile),
+            umask=parse_octal(umask),
+            directory=check_existing_dir(directory) if directory is not None else None,
+            logfile=check_path_with_existing_dir(logfile),
+            logfile_maxbytes=parse_bytes_size(logfile_maxbytes),
+            loglevel=parse_logging_level(loglevel),
+            pidfile=check_path_with_existing_dir(pidfile),
             child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
             **kwargs,
         )
@@ -129,3 +139,16 @@ def prepare_server_config(dct: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.An
     group_dcts = build_config_named_children(out.get('groups'))
     out['groups'] = [prepare_process_group_config(group_dct) for group_dct in group_dcts or []]
     return out
+
+
+##
+
+
+def parse_logging_level(value: ta.Union[str, int]) -> int:
+    if isinstance(value, int):
+        return value
+    s = str(value).lower()
+    level = logging.getLevelNamesMapping().get(s.upper())
+    if level is None:
+        raise ValueError(f'bad logging level name {value!r}')
+    return level

ominfra/supervisor/context.py

@@ -8,10 +8,11 @@ from omlish.lite.logs import log
 from .configs import ServerConfig
 from .poller import Poller
 from .states import SupervisorState
-from .types import Process
 from .types import ServerContext
 from .types import ServerEpoch
-from .utils import mktempfile
+from .utils.fs import mktempfile
+from .utils.ostypes import Pid
+from .utils.ostypes import Rc
 
 
 class ServerContextImpl(ServerContext):
@@ -28,7 +29,6 @@ class ServerContextImpl(ServerContext):
         self._poller = poller
         self._epoch = epoch
 
-        self._pid_history: ta.Dict[int, Process] = {}
         self._state: SupervisorState = SupervisorState.RUNNING
 
     @property
@@ -50,13 +50,9 @@ class ServerContextImpl(ServerContext):
     def set_state(self, state: SupervisorState) -> None:
         self._state = state
 
-    @property
-    def pid_history(self) -> ta.Dict[int, Process]:
-        return self._pid_history
-
     #
 
-    def waitpid(self) -> ta.Tuple[ta.Optional[int], ta.Optional[int]]:
+    def waitpid(self) -> ta.Tuple[ta.Optional[Pid], ta.Optional[Rc]]:
         # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
         # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
         # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
@@ -72,7 +68,7 @@ class ServerContextImpl(ServerContext):
             if code == errno.EINTR:
                 log.debug('EINTR during reap')
             pid, sts = None, None
-        return pid, sts
+        return pid, sts  # type: ignore
 
     def get_auto_child_log_name(self, name: str, identifier: str, channel: str) -> str:
         prefix = f'{name}-{channel}---{identifier}-'

ominfra/supervisor/dispatchers.py

@@ -1,11 +1,12 @@
 # ruff: noqa: UP006 UP007
-from .collections import KeyedCollection
 from .types import Dispatcher
 from .types import OutputDispatcher
+from .utils.collections import KeyedCollection
+from .utils.ostypes import Fd
 
 
-class Dispatchers(KeyedCollection[int, Dispatcher]):
-    def _key(self, v: Dispatcher) -> int:
+class Dispatchers(KeyedCollection[Fd, Dispatcher]):
+    def _key(self, v: Dispatcher) -> Fd:
         return v.fd
 
     #

ominfra/supervisor/dispatchersimpl.py

@@ -16,11 +16,12 @@ from .types import Dispatcher
 from .types import InputDispatcher
 from .types import OutputDispatcher
 from .types import Process
-from .utils import as_bytes
-from .utils import compact_traceback
-from .utils import find_prefix_at_end
-from .utils import read_fd
-from .utils import strip_escapes
+from .utils.diag import compact_traceback
+from .utils.fds import read_fd
+from .utils.ostypes import Fd
+from .utils.strings import as_bytes
+from .utils.strings import find_prefix_at_end
+from .utils.strings import strip_escapes
 
 
 class BaseDispatcherImpl(Dispatcher, abc.ABC):
@@ -28,7 +29,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             self,
             process: Process,
             channel: str,
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
     ) -> None:
@@ -57,7 +58,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         return self._channel
 
     @property
-    def fd(self) -> int:
+    def fd(self) -> Fd:
         return self._fd
 
     @property
@@ -91,7 +92,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self,
             process: Process,
             event_type: ta.Type[ProcessCommunicationEvent],
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
     ) -> None:
@@ -301,7 +302,7 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             self,
             process: Process,
             channel: str,
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
     ) -> None:

ominfra/supervisor/groups.py

@@ -1,13 +1,13 @@
 # ruff: noqa: UP006 UP007
 import typing as ta
 
-from .collections import KeyedCollectionAccessors
 from .configs import ProcessGroupConfig
 from .events import EventCallbacks
 from .events import ProcessGroupAddedEvent
 from .events import ProcessGroupRemovedEvent
 from .types import Process
 from .types import ProcessGroup
+from .utils.collections import KeyedCollectionAccessors
 
 
 class ProcessGroupManager(KeyedCollectionAccessors[str, ProcessGroup]):

ominfra/supervisor/inject.py

@@ -15,15 +15,14 @@ from .groupsimpl import ProcessFactory
 from .groupsimpl import ProcessGroupImpl
 from .poller import Poller
 from .poller import get_poller_impl
-from .processes import PidHistory
-from .processesimpl import ProcessImpl
-from .processesimpl import ProcessSpawningFactory
+from .process import PidHistory
+from .processimpl import ProcessImpl
+from .processimpl import ProcessSpawningFactory
 from .setup import DaemonizeListener
 from .setup import DaemonizeListeners
 from .setup import SupervisorUser
 from .setupimpl import SupervisorSetup
 from .setupimpl import SupervisorSetupImpl
-from .signals import SignalReceiver
 from .spawningimpl import InheritedFds
 from .spawningimpl import InputDispatcherFactory
 from .spawningimpl import OutputDispatcherFactory
@@ -33,7 +32,8 @@ from .supervisor import SignalHandler
 from .supervisor import Supervisor
 from .types import ServerContext
 from .types import ServerEpoch
-from .users import get_user
+from .utils.signals import SignalReceiver
+from .utils.users import get_user
 
 
 def bind_server(

ominfra/supervisor/main.py

@@ -46,9 +46,9 @@ from .context import ServerEpoch
 from .inject import bind_server
 from .spawningimpl import InheritedFds
 from .states import SupervisorState
+from .supervisor import ExitNow
 from .supervisor import Supervisor
-from .utils import ExitNow
-from .utils import get_open_fds
+from .utils.fds import get_open_fds
 
 
 ##

ominfra/supervisor/pipes.py

@@ -4,24 +4,26 @@ import fcntl
 import os
 import typing as ta
 
-from .utils import close_fd
+from .utils.fds import close_fd
+from .utils.fds import make_pipe
+from .utils.ostypes import Fd
 
 
 @dc.dataclass(frozen=True)
 class ProcessPipes:
-    child_stdin: ta.Optional[int] = None
-    stdin: ta.Optional[int] = None
+    child_stdin: ta.Optional[Fd] = None
+    stdin: ta.Optional[Fd] = None
 
-    stdout: ta.Optional[int] = None
-    child_stdout: ta.Optional[int] = None
+    stdout: ta.Optional[Fd] = None
+    child_stdout: ta.Optional[Fd] = None
 
-    stderr: ta.Optional[int] = None
-    child_stderr: ta.Optional[int] = None
+    stderr: ta.Optional[Fd] = None
+    child_stderr: ta.Optional[Fd] = None
 
-    def child_fds(self) -> ta.List[int]:
+    def child_fds(self) -> ta.List[Fd]:
         return [fd for fd in [self.child_stdin, self.child_stdout, self.child_stderr] if fd is not None]
 
-    def parent_fds(self) -> ta.List[int]:
+    def parent_fds(self) -> ta.List[Fd]:
         return [fd for fd in [self.stdin, self.stdout, self.stderr] if fd is not None]
 
 
@@ -31,7 +33,7 @@ def make_process_pipes(stderr=True) -> ProcessPipes:
     read them in the mainloop without blocking.  If stderr is False, don't create a pipe for stderr.
     """
 
-    pipes: ta.Dict[str, ta.Optional[int]] = {
+    pipes: ta.Dict[str, ta.Optional[Fd]] = {
         'child_stdin': None,
         'stdin': None,
 
@@ -43,11 +45,11 @@ def make_process_pipes(stderr=True) -> ProcessPipes:
     }
 
     try:
-        pipes['child_stdin'], pipes['stdin'] = os.pipe()
-        pipes['stdout'], pipes['child_stdout'] = os.pipe()
+        pipes['child_stdin'], pipes['stdin'] = make_pipe()
+        pipes['stdout'], pipes['child_stdout'] = make_pipe()
 
         if stderr:
-            pipes['stderr'], pipes['child_stderr'] = os.pipe()
+            pipes['stderr'], pipes['child_stderr'] = make_pipe()
 
         for fd in (
                 pipes['stdout'],

ominfra/supervisor/poller.py

@@ -8,6 +8,7 @@ import typing as ta
 from omlish.lite.logs import log
 
 from .setup import DaemonizeListener
+from .utils.ostypes import Fd
 
 
 class Poller(DaemonizeListener, abc.ABC):
@@ -15,23 +16,23 @@ class Poller(DaemonizeListener, abc.ABC):
         super().__init__()
 
     @abc.abstractmethod
-    def register_readable(self, fd: int) -> None:
+    def register_readable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def register_writable(self, fd: int) -> None:
+    def register_writable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unregister_readable(self, fd: int) -> None:
+    def unregister_readable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unregister_writable(self, fd: int) -> None:
+    def unregister_writable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
         raise NotImplementedError
 
     def before_daemonize(self) -> None:  # noqa
@@ -48,37 +49,37 @@ class SelectPoller(Poller):
     def __init__(self) -> None:
         super().__init__()
 
-        self._readable: ta.Set[int] = set()
-        self._writable: ta.Set[int] = set()
+        self._readable: ta.Set[Fd] = set()
+        self._writable: ta.Set[Fd] = set()
 
-    def register_readable(self, fd: int) -> None:
+    def register_readable(self, fd: Fd) -> None:
         self._readable.add(fd)
 
-    def register_writable(self, fd: int) -> None:
+    def register_writable(self, fd: Fd) -> None:
         self._writable.add(fd)
 
-    def unregister_readable(self, fd: int) -> None:
+    def unregister_readable(self, fd: Fd) -> None:
         self._readable.discard(fd)
 
-    def unregister_writable(self, fd: int) -> None:
+    def unregister_writable(self, fd: Fd) -> None:
         self._writable.discard(fd)
 
     def unregister_all(self) -> None:
         self._readable.clear()
         self._writable.clear()
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
         try:
             r, w, x = select.select(
                 self._readable,
                 self._writable,
                 [], timeout,
             )
-        except OSError as err:
-            if err.args[0] == errno.EINTR:
+        except OSError as exc:
+            if exc.args[0] == errno.EINTR:
                 log.debug('EINTR encountered in poll')
                 return [], []
-            if err.args[0] == errno.EBADF:
+            if exc.args[0] == errno.EBADF:
                 log.debug('EBADF encountered in poll')
                 self.unregister_all()
                 return [], []
@@ -94,30 +95,30 @@ class PollPoller(Poller):
         super().__init__()
 
         self._poller = select.poll()
-        self._readable: set[int] = set()
-        self._writable: set[int] = set()
+        self._readable: set[Fd] = set()
+        self._writable: set[Fd] = set()
 
-    def register_readable(self, fd: int) -> None:
+    def register_readable(self, fd: Fd) -> None:
         self._poller.register(fd, self._READ)
         self._readable.add(fd)
 
-    def register_writable(self, fd: int) -> None:
+    def register_writable(self, fd: Fd) -> None:
         self._poller.register(fd, self._WRITE)
         self._writable.add(fd)
 
-    def unregister_readable(self, fd: int) -> None:
+    def unregister_readable(self, fd: Fd) -> None:
         self._readable.discard(fd)
         self._poller.unregister(fd)
         if fd in self._writable:
             self._poller.register(fd, self._WRITE)
 
-    def unregister_writable(self, fd: int) -> None:
+    def unregister_writable(self, fd: Fd) -> None:
         self._writable.discard(fd)
         self._poller.unregister(fd)
         if fd in self._readable:
             self._poller.register(fd, self._READ)
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
         fds = self._poll_fds(timeout)  # type: ignore
         readable, writable = [], []
         for fd, eventmask in fds:
@@ -129,16 +130,16 @@ class PollPoller(Poller):
                 writable.append(fd)
         return readable, writable
 
-    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[int, int]]:
+    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[Fd, Fd]]:
         try:
-            return self._poller.poll(timeout * 1000)
-        except OSError as err:
-            if err.args[0] == errno.EINTR:
+            return self._poller.poll(timeout * 1000)  # type: ignore
+        except OSError as exc:
+            if exc.args[0] == errno.EINTR:
                 log.debug('EINTR encountered in poll')
                 return []
             raise
 
-    def _ignore_invalid(self, fd: int, eventmask: int) -> bool:
+    def _ignore_invalid(self, fd: Fd, eventmask: int) -> bool:
         if eventmask & select.POLLNVAL:
             # POLLNVAL means `fd` value is invalid, not open. When a process quits it's `fd`s are closed so there is no
             # more reason to keep this `fd` registered If the process restarts it's `fd`s are registered again.
@@ -157,30 +158,30 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
             super().__init__()
 
             self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-            self._readable: set[int] = set()
-            self._writable: set[int] = set()
+            self._readable: set[Fd] = set()
+            self._writable: set[Fd] = set()
 
-        def register_readable(self, fd: int) -> None:
+        def register_readable(self, fd: Fd) -> None:
             self._readable.add(fd)
             kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
             self._kqueue_control(fd, kevent)
 
-        def register_writable(self, fd: int) -> None:
+        def register_writable(self, fd: Fd) -> None:
             self._writable.add(fd)
             kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
             self._kqueue_control(fd, kevent)
 
-        def unregister_readable(self, fd: int) -> None:
+        def unregister_readable(self, fd: Fd) -> None:
             kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
             self._readable.discard(fd)
             self._kqueue_control(fd, kevent)
 
-        def unregister_writable(self, fd: int) -> None:
+        def unregister_writable(self, fd: Fd) -> None:
             kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
             self._writable.discard(fd)
             self._kqueue_control(fd, kevent)
 
-        def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
+        def _kqueue_control(self, fd: Fd, kevent: 'select.kevent') -> None:
             try:
                 self._kqueue.control([kevent], 0)  # type: ignore
             except OSError as error:
@@ -189,7 +190,7 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
                 else:
                     raise
 
-        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
             readable, writable = [], []  # type: ignore
 
             try:

ominfra/supervisor/{processes.py → process.py}

@@ -2,6 +2,7 @@
 import typing as ta
 
 from .types import Process
+from .utils.ostypes import Pid
 
 
 ##
@@ -14,5 +15,5 @@ class ProcessStateError(RuntimeError):
 ##
 
 
-class PidHistory(ta.Dict[int, Process]):
+class PidHistory(ta.Dict[Pid, Process]):
     pass