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

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

@@ -1,7 +1,6 @@
 # ruff: noqa: UP006 UP007
 import errno
 import os.path
-import shlex
 import signal
 import time
 import traceback
@@ -9,47 +8,31 @@ import typing as ta
 
 from omlish.lite.check import check_isinstance
 from omlish.lite.logs import log
-from omlish.lite.typing import Func
+from omlish.lite.typing import Func1
 
 from .configs import ProcessConfig
-from .context import check_execv_args
-from .context import close_child_pipes
-from .context import close_parent_pipes
-from .context import drop_privileges
-from .context import make_pipes
 from .datatypes import RestartUnconditionally
+from .dispatchers import Dispatchers
 from .events import PROCESS_STATE_EVENT_MAP
 from .events import EventCallbacks
-from .events import ProcessCommunicationEvent
-from .events import ProcessCommunicationStderrEvent
-from .events import ProcessCommunicationStdoutEvent
-from .exceptions import BadCommandError
-from .exceptions import ProcessError
+from .pipes import ProcessPipes
+from .pipes import close_parent_pipes
+from .processes import ProcessStateError
 from .signals import sig_name
+from .spawning import ProcessSpawnError
+from .spawning import ProcessSpawning
 from .states import ProcessState
 from .states import SupervisorState
-from .types import Dispatcher
 from .types import InputDispatcher
-from .types import OutputDispatcher
 from .types import Process
 from .types import ProcessGroup
 from .types import ServerContext
-from .utils import as_bytes
 from .utils import as_string
-from .utils import close_fd
-from .utils import compact_traceback
 from .utils import decode_wait_status
-from .utils import get_path
-from .utils import real_exit
 
 
-# (process: Process, event_type: ta.Type[ProcessCommunicationEvent], fd: int)
-OutputDispatcherFactory = ta.NewType('OutputDispatcherFactory', Func[OutputDispatcher])
-
-# (process: Process, event_type: ta.Type[ProcessCommunicationEvent], fd: int)
-InputDispatcherFactory = ta.NewType('InputDispatcherFactory', Func[InputDispatcher])
-
-InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
+    pass
 
 
 ##
@@ -65,12 +48,7 @@ class ProcessImpl(Process):
             *,
             context: ServerContext,
             event_callbacks: EventCallbacks,
-
-            output_dispatcher_factory: OutputDispatcherFactory,
-            input_dispatcher_factory: InputDispatcherFactory,
-
-            inherited_fds: ta.Optional[InheritedFds] = None,
-
+            process_spawning_factory: ProcessSpawningFactory,
     ) -> None:
         super().__init__()
 
@@ -80,13 +58,12 @@ class ProcessImpl(Process):
         self._context = context
         self._event_callbacks = event_callbacks
 
-        self._output_dispatcher_factory = output_dispatcher_factory
-        self._input_dispatcher_factory = input_dispatcher_factory
+        self._spawning = process_spawning_factory(self)
 
-        self._inherited_fds = InheritedFds(frozenset(inherited_fds or []))
+        #
 
-        self._dispatchers: ta.Dict[int, Dispatcher] = {}
-        self._pipes: ta.Dict[str, int] = {}
+        self._dispatchers = Dispatchers([])
+        self._pipes = ProcessPipes()
 
         self._state = ProcessState.STOPPED
         self._pid = 0  # 0 when not running
@@ -106,17 +83,30 @@ class ProcessImpl(Process):
         self._exitstatus: ta.Optional[int] = None  # status attached to dead process by finish()
         self._spawn_err: ta.Optional[str] = None  # error message attached by spawn() if any
 
+    #
+
+    def __repr__(self) -> str:
+        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self.get_state().name}>'
+
+    #
+
     @property
-    def pid(self) -> int:
-        return self._pid
+    def name(self) -> str:
+        return self._config.name
+
+    @property
+    def config(self) -> ProcessConfig:
+        return self._config
 
     @property
     def group(self) -> ProcessGroup:
         return self._group
 
     @property
-    def config(self) -> ProcessConfig:
-        return self._config
+    def pid(self) -> int:
+        return self._pid
+
+    #
 
     @property
     def context(self) -> ServerContext:
@@ -130,33 +120,59 @@ class ProcessImpl(Process):
     def backoff(self) -> int:
         return self._backoff
 
-    def get_dispatchers(self) -> ta.Mapping[int, Dispatcher]:
-        return self._dispatchers
+    #
+
+    def spawn(self) -> ta.Optional[int]:
+        process_name = as_string(self._config.name)
 
-    def remove_logs(self) -> None:
-        for dispatcher in self._dispatchers.values():
-            if hasattr(dispatcher, 'remove_logs'):
-                dispatcher.remove_logs()
-
-    def reopen_logs(self) -> None:
-        for dispatcher in self._dispatchers.values():
-            if hasattr(dispatcher, 'reopen_logs'):
-                dispatcher.reopen_logs()
-
-    def drain(self) -> None:
-        for dispatcher in self._dispatchers.values():
-            # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
-            # dispatcher (eg. call handle_listener_state_change for event listener processes)
-            if dispatcher.readable():
-                dispatcher.handle_read_event()
-            if dispatcher.writable():
-                dispatcher.handle_write_event()
+        if self.pid:
+            log.warning('process \'%s\' already running', process_name)
+            return None
+
+        self.check_in_state(
+            ProcessState.EXITED,
+            ProcessState.FATAL,
+            ProcessState.BACKOFF,
+            ProcessState.STOPPED,
+        )
+
+        self._killing = False
+        self._spawn_err = None
+        self._exitstatus = None
+        self._system_stop = False
+        self._administrative_stop = False
+
+        self._last_start = time.time()
+
+        self.change_state(ProcessState.STARTING)
+
+        try:
+            sp = self._spawning.spawn()
+        except ProcessSpawnError as err:
+            log.exception('Spawn error')
+            self._spawn_err = err.args[0]
+            self.check_in_state(ProcessState.STARTING)
+            self.change_state(ProcessState.BACKOFF)
+            return None
+
+        log.info("Spawned: '%s' with pid %s", self.name, sp.pid)
+
+        self._pid = sp.pid
+        self._pipes = sp.pipes
+        self._dispatchers = sp.dispatchers
+
+        self._delay = time.time() + self.config.startsecs
+
+        return sp.pid
+
+    def get_dispatchers(self) -> Dispatchers:
+        return self._dispatchers
 
     def write(self, chars: ta.Union[bytes, str]) -> None:
         if not self.pid or self._killing:
             raise OSError(errno.EPIPE, 'Process already closed')
 
-        stdin_fd = self._pipes['stdin']
+        stdin_fd = self._pipes.stdin
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
@@ -167,51 +183,7 @@ class ProcessImpl(Process):
         dispatcher.write(chars)
         dispatcher.flush()  # this must raise EPIPE if the pipe is closed
 
-    def _get_execv_args(self) -> ta.Tuple[str, ta.Sequence[str]]:
-        """
-        Internal: turn a program name into a file name, using $PATH, make sure it exists / is executable, raising a
-        ProcessError if not
-        """
-
-        try:
-            commandargs = shlex.split(self._config.command)
-        except ValueError as e:
-            raise BadCommandError(f"can't parse command {self._config.command!r}: {e}")  # noqa
-
-        if commandargs:
-            program = commandargs[0]
-        else:
-            raise BadCommandError('command is empty')
-
-        if '/' in program:
-            filename = program
-            try:
-                st = os.stat(filename)
-            except OSError:
-                st = None
-
-        else:
-            path = get_path()
-            found = None
-            st = None
-            for dir in path:  # noqa
-                found = os.path.join(dir, program)
-                try:
-                    st = os.stat(found)
-                except OSError:
-                    pass
-                else:
-                    break
-            if st is None:
-                filename = program
-            else:
-                filename = found  # type: ignore
-
-        # check_execv_args will raise a ProcessError if the execv args are bogus, we break it out into a separate
-        # options method call here only to service unit tests
-        check_execv_args(filename, commandargs, st)
-
-        return filename, commandargs
+    #
 
     def change_state(self, new_state: ProcessState, expected: bool = True) -> bool:
         old_state = self._state
@@ -231,209 +203,14 @@ class ProcessImpl(Process):
 
         return True
 
-    def _check_in_state(self, *states: ProcessState) -> None:
+    def check_in_state(self, *states: ProcessState) -> None:
         if self._state not in states:
-            current_state = self._state.name
-            allowable_states = ' '.join(s.name for s in states)
-            process_name = as_string(self._config.name)
-            raise RuntimeError('Assertion failed for %s: %s not in %s' % (process_name, current_state, allowable_states))  # noqa
-
-    def _record_spawn_err(self, msg: str) -> None:
-        self._spawn_err = msg
-        log.info('_spawn_err: %s', msg)
-
-    def spawn(self) -> ta.Optional[int]:
-        process_name = as_string(self._config.name)
-
-        if self.pid:
-            log.warning('process \'%s\' already running', process_name)
-            return None
-
-        self._killing = False
-        self._spawn_err = None
-        self._exitstatus = None
-        self._system_stop = False
-        self._administrative_stop = False
-
-        self._last_start = time.time()
-
-        self._check_in_state(
-            ProcessState.EXITED,
-            ProcessState.FATAL,
-            ProcessState.BACKOFF,
-            ProcessState.STOPPED,
-        )
-
-        self.change_state(ProcessState.STARTING)
-
-        try:
-            filename, argv = self._get_execv_args()
-        except ProcessError as what:
-            self._record_spawn_err(what.args[0])
-            self._check_in_state(ProcessState.STARTING)
-            self.change_state(ProcessState.BACKOFF)
-            return None
-
-        try:
-            self._dispatchers, self._pipes = self._make_dispatchers()  # type: ignore
-        except OSError as why:
-            code = why.args[0]
-            if code == errno.EMFILE:
-                # too many file descriptors open
-                msg = f"too many open files to spawn '{process_name}'"
-            else:
-                msg = f"unknown error making dispatchers for '{process_name}': {errno.errorcode.get(code, code)}"
-            self._record_spawn_err(msg)
-            self._check_in_state(ProcessState.STARTING)
-            self.change_state(ProcessState.BACKOFF)
-            return None
-
-        try:
-            pid = os.fork()
-        except OSError as why:
-            code = why.args[0]
-            if code == errno.EAGAIN:
-                # process table full
-                msg = f'Too many processes in process table to spawn \'{process_name}\''
-            else:
-                msg = f'unknown error during fork for \'{process_name}\': {errno.errorcode.get(code, code)}'
-            self._record_spawn_err(msg)
-            self._check_in_state(ProcessState.STARTING)
-            self.change_state(ProcessState.BACKOFF)
-            close_parent_pipes(self._pipes)
-            close_child_pipes(self._pipes)
-            return None
-
-        if pid != 0:
-            return self._spawn_as_parent(pid)
-
-        else:
-            self._spawn_as_child(filename, argv)
-            return None
-
-    def _make_dispatchers(self) -> ta.Tuple[ta.Mapping[int, Dispatcher], ta.Mapping[str, int]]:
-        use_stderr = not self._config.redirect_stderr
-
-        p = make_pipes(use_stderr)
-        stdout_fd, stderr_fd, stdin_fd = p['stdout'], p['stderr'], p['stdin']
-
-        dispatchers: ta.Dict[int, Dispatcher] = {}
-
-        dispatcher_kw = dict(
-            event_callbacks=self._event_callbacks,
-        )
-
-        etype: ta.Type[ProcessCommunicationEvent]
-        if stdout_fd is not None:
-            etype = ProcessCommunicationStdoutEvent
-            dispatchers[stdout_fd] = check_isinstance(self._output_dispatcher_factory(
-                self,
-                etype,
-                stdout_fd,
-                **dispatcher_kw,
-            ), OutputDispatcher)
-
-        if stderr_fd is not None:
-            etype = ProcessCommunicationStderrEvent
-            dispatchers[stderr_fd] = check_isinstance(self._output_dispatcher_factory(
-                self,
-                etype,
-                stderr_fd,
-                **dispatcher_kw,
-            ), OutputDispatcher)
-
-        if stdin_fd is not None:
-            dispatchers[stdin_fd] = check_isinstance(self._input_dispatcher_factory(
-                self,
-                'stdin',
-                stdin_fd,
-                **dispatcher_kw,
-            ), InputDispatcher)
-
-        return dispatchers, p
-
-    def _spawn_as_parent(self, pid: int) -> int:
-        # Parent
-        self._pid = pid
-        close_child_pipes(self._pipes)
-        log.info('spawned: \'%s\' with pid %s', as_string(self._config.name), pid)
-        self._spawn_err = None
-        self._delay = time.time() + self._config.startsecs
-        self.context.pid_history[pid] = self
-        return pid
-
-    def _prepare_child_fds(self) -> None:
-        os.dup2(self._pipes['child_stdin'], 0)
-        os.dup2(self._pipes['child_stdout'], 1)
-        if self._config.redirect_stderr:
-            os.dup2(self._pipes['child_stdout'], 2)
-        else:
-            os.dup2(self._pipes['child_stderr'], 2)
+            raise ProcessStateError(
+                f'Check failed for {self._config.name}: '
+                f'{self._state.name} not in {" ".join(s.name for s in states)}',
+            )
 
-        for i in range(3, self.context.config.minfds):
-            if i in self._inherited_fds:
-                continue
-            close_fd(i)
-
-    def _spawn_as_child(self, filename: str, argv: ta.Sequence[str]) -> None:
-        try:
-            # prevent child from receiving signals sent to the parent by calling os.setpgrp to create a new process
-            # group for the child; this prevents, for instance, the case of child processes being sent a SIGINT when
-            # running supervisor in foreground mode and Ctrl-C in the terminal window running supervisord is pressed.
-            # Presumably it also prevents HUP, etc received by supervisord from being sent to children.
-            os.setpgrp()
-
-            self._prepare_child_fds()
-            # sending to fd 2 will put this output in the stderr log
-
-            # set user
-            setuid_msg = self.set_uid()
-            if setuid_msg:
-                uid = self._config.uid
-                msg = f"couldn't setuid to {uid}: {setuid_msg}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
-                return  # finally clause will exit the child process
-
-            # set environment
-            env = os.environ.copy()
-            env['SUPERVISOR_ENABLED'] = '1'
-            env['SUPERVISOR_PROCESS_NAME'] = self._config.name
-            if self._group:
-                env['SUPERVISOR_GROUP_NAME'] = self._group.config.name
-            if self._config.environment is not None:
-                env.update(self._config.environment)
-
-            # change directory
-            cwd = self._config.directory
-            try:
-                if cwd is not None:
-                    os.chdir(os.path.expanduser(cwd))
-            except OSError as why:
-                code = errno.errorcode.get(why.args[0], why.args[0])
-                msg = f"couldn't chdir to {cwd}: {code}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
-                return  # finally clause will exit the child process
-
-            # set umask, then execve
-            try:
-                if self._config.umask is not None:
-                    os.umask(self._config.umask)
-                os.execve(filename, list(argv), env)
-            except OSError as why:
-                code = errno.errorcode.get(why.args[0], why.args[0])
-                msg = f"couldn't exec {argv[0]}: {code}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
-            except Exception:  # noqa
-                (file, fun, line), t, v, tbinfo = compact_traceback()
-                error = f'{t}, {v}: file: {file} line: {line}'
-                msg = f"couldn't exec {filename}: {error}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
-
-            # this point should only be reached if execve failed. the finally clause will exit the child process.
-
-        finally:
-            os.write(2, as_bytes('supervisor: child process was not spawned\n'))
-            real_exit(127)  # exit process with code for spawn failure
+    #
 
     def _check_and_adjust_for_system_clock_rollback(self, test_time):
         """
@@ -479,7 +256,7 @@ class ProcessImpl(Process):
         self._delay = 0
         self._backoff = 0
         self._system_stop = True
-        self._check_in_state(ProcessState.BACKOFF)
+        self.check_in_state(ProcessState.BACKOFF)
         self.change_state(ProcessState.FATAL)
 
     def kill(self, sig: int) -> ta.Optional[str]:
@@ -523,7 +300,7 @@ class ProcessImpl(Process):
         self._killing = True
         self._delay = now + self._config.stopwaitsecs
         # we will already be in the STOPPING state if we're doing a SIGKILL as a result of overrunning stopwaitsecs
-        self._check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
+        self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
         self.change_state(ProcessState.STOPPING)
 
         pid = self.pid
@@ -568,7 +345,7 @@ class ProcessImpl(Process):
 
         log.debug('sending %s (pid %s) sig %s', process_name, self.pid, sig_name(sig))
 
-        self._check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
+        self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
 
         try:
             try:
@@ -597,7 +374,7 @@ class ProcessImpl(Process):
     def finish(self, sts: int) -> None:
         """The process was reaped and we need to report and manage its state."""
 
-        self.drain()
+        self._dispatchers.drain()
 
         es, msg = decode_wait_status(sts)
 
@@ -628,7 +405,7 @@ class ProcessImpl(Process):
             self._exitstatus = es
 
             fmt, args = 'stopped: %s (%s)', (process_name, msg)
-            self._check_in_state(ProcessState.STOPPING)
+            self.check_in_state(ProcessState.STOPPING)
             self.change_state(ProcessState.STOPPED)
             if exit_expected:
                 log.info(fmt, *args)
@@ -639,7 +416,7 @@ class ProcessImpl(Process):
             # the program did not stay up long enough to make it to RUNNING implies STARTING -> BACKOFF
             self._exitstatus = None
             self._spawn_err = 'Exited too quickly (process log may have details)'
-            self._check_in_state(ProcessState.STARTING)
+            self.check_in_state(ProcessState.STARTING)
             self.change_state(ProcessState.BACKOFF)
             log.warning('exited: %s (%s)', process_name, msg + '; not expected')
 
@@ -655,7 +432,7 @@ class ProcessImpl(Process):
             if self._state == ProcessState.STARTING:
                 self.change_state(ProcessState.RUNNING)
 
-            self._check_in_state(ProcessState.RUNNING)
+            self.check_in_state(ProcessState.RUNNING)
 
             if exit_expected:
                 # expected exit code
@@ -669,19 +446,8 @@ class ProcessImpl(Process):
 
         self._pid = 0
         close_parent_pipes(self._pipes)
-        self._pipes = {}
-        self._dispatchers = {}
-
-    def set_uid(self) -> ta.Optional[str]:
-        if self._config.uid is None:
-            return None
-        msg = drop_privileges(self._config.uid)
-        return msg
-
-    def __repr__(self) -> str:
-        # repr can't return anything other than a native string, but the name might be unicode - a problem on Python 2.
-        name = self._config.name
-        return f'<Subprocess at {id(self)} with name {name} in state {self.get_state().name}>'
+        self._pipes = ProcessPipes()
+        self._dispatchers = Dispatchers([])
 
     def get_state(self) -> ProcessState:
         return self._state
@@ -723,7 +489,7 @@ class ProcessImpl(Process):
                 # proc.config.startsecs,
                 self._delay = 0
                 self._backoff = 0
-                self._check_in_state(ProcessState.STARTING)
+                self.check_in_state(ProcessState.STARTING)
                 self.change_state(ProcessState.RUNNING)
                 msg = ('entered RUNNING state, process has stayed up for > than %s seconds (startsecs)' % self._config.startsecs)  # noqa
                 logger.info('success: %s %s', process_name, msg)
@@ -743,7 +509,7 @@ class ProcessImpl(Process):
                 log.warning('killing \'%s\' (%s) with SIGKILL', process_name, self.pid)
                 self.kill(signal.SIGKILL)
 
-    def create_auto_child_logs(self) -> None:
+    def after_setuid(self) -> None:
         # temporary logfiles which are erased at start time
         # get_autoname = self.context.get_auto_child_log_name  # noqa
         # sid = self.context.config.identifier  # noqa

ominfra/supervisor/setup.py

@@ -0,0 +1,38 @@
+# ruff: noqa: UP006 UP007
+import abc
+import typing as ta
+
+from .users import User
+
+
+##
+
+
+SupervisorUser = ta.NewType('SupervisorUser', User)
+
+
+##
+
+
+class DaemonizeListener(abc.ABC):  # noqa
+    def before_daemonize(self) -> None:  # noqa
+        pass
+
+    def after_daemonize(self) -> None:  # noqa
+        pass
+
+
+DaemonizeListeners = ta.NewType('DaemonizeListeners', ta.Sequence[DaemonizeListener])
+
+
+##
+
+
+class SupervisorSetup(abc.ABC):
+    @abc.abstractmethod
+    def setup(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def cleanup(self) -> None:
+        raise NotImplementedError