ominfra 0.0.0.dev122__py3-none-any.whl → 0.0.0.dev124__py3-none-any.whl

ominfra/supervisor/process.py

@@ -1,7 +1,5 @@
 # ruff: noqa: UP006 UP007
-import dataclasses as dc
 import errno
-import functools
 import os.path
 import shlex
 import signal
@@ -9,19 +7,10 @@ import time
 import traceback
 import typing as ta
 
+from omlish.lite.check import check_isinstance
 from omlish.lite.logs import log
 
-from .compat import as_bytes
-from .compat import as_string
-from .compat import close_fd
-from .compat import compact_traceback
-from .compat import decode_wait_status
-from .compat import get_path
-from .compat import real_exit
-from .compat import signame
 from .configs import ProcessConfig
-from .configs import ProcessGroupConfig
-from .context import ServerContext
 from .context import check_execv_args
 from .context import close_child_pipes
 from .context import close_parent_pipes
@@ -31,78 +20,84 @@ from .datatypes import RestartUnconditionally
 from .dispatchers import Dispatcher
 from .dispatchers import InputDispatcher
 from .dispatchers import OutputDispatcher
-from .events import EVENT_CALLBACKS
-from .events import EventRejectedEvent
+from .events import PROCESS_STATE_EVENT_MAP
+from .events import EventCallbacks
 from .events import ProcessCommunicationEvent
 from .events import ProcessCommunicationStderrEvent
 from .events import ProcessCommunicationStdoutEvent
-from .events import ProcessStateBackoffEvent
-from .events import ProcessStateEvent
-from .events import ProcessStateExitedEvent
-from .events import ProcessStateFatalEvent
-from .events import ProcessStateRunningEvent
-from .events import ProcessStateStartingEvent
-from .events import ProcessStateStoppedEvent
-from .events import ProcessStateStoppingEvent
-from .events import ProcessStateUnknownEvent
 from .exceptions import BadCommandError
 from .exceptions import ProcessError
-from .states import STOPPED_STATES
+from .signals import sig_name
 from .states import ProcessState
-from .states import ProcessStates
-from .states import SupervisorStates
-from .states import get_process_state_description
+from .states import SupervisorState
+from .types import AbstractProcessGroup
 from .types import AbstractServerContext
 from .types import AbstractSubprocess
+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
+
+
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
 
 
 ##
 
 
-@functools.total_ordering
 class Subprocess(AbstractSubprocess):
     """A class to manage a subprocess."""
 
-    # Initial state; overridden by instance variables
-
-    # pid = 0  # Subprocess pid; 0 when not running
-    # config = None  # ProcessConfig instance
-    # state = None  # process state code
-    listener_state = None  # listener state code (if we're an event listener)
-    event = None  # event currently being processed (if we're an event listener)
-    laststart = 0.  # Last time the subprocess was started; 0 if never
-    laststop = 0.  # Last time the subprocess was stopped; 0 if never
-    last_stop_report = 0.  # Last time "waiting for x to stop" logged, to throttle
-    delay = 0.  # If nonzero, delay starting or killing until this time
-    administrative_stop = False  # true if process has been stopped by an admin
-    system_stop = False  # true if process has been stopped by the system
-    killing = False  # true if we are trying to kill this process
-    backoff = 0  # backoff counter (to startretries)
-    dispatchers = None  # asyncore output dispatchers (keyed by fd)
-    pipes = None  # map of channel name to file descriptor #
-    exitstatus = None  # status attached to dead process by finish()
-    spawn_err = None  # error message attached by spawn() if any
-    group = None  # ProcessGroup instance if process is in the group
-
     def __init__(
             self,
             config: ProcessConfig,
-            group: 'ProcessGroup',
+            group: AbstractProcessGroup,
+            *,
             context: AbstractServerContext,
+            event_callbacks: EventCallbacks,
+
+            inherited_fds: ta.Optional[InheritedFds] = None,
     ) -> None:
         super().__init__()
+
         self._config = config
-        self.group = group
+        self._group = group
         self._context = context
-        self._dispatchers: dict = {}
-        self._pipes: dict = {}
-        self.state = ProcessStates.STOPPED
-        self._pid = 0
+        self._event_callbacks = event_callbacks
+        self._inherited_fds = InheritedFds(frozenset(inherited_fds or []))
+
+        self._dispatchers: ta.Dict[int, Dispatcher] = {}
+        self._pipes: ta.Dict[str, int] = {}
+
+        self._state = ProcessState.STOPPED
+        self._pid = 0  # 0 when not running
+
+        self._last_start = 0.  # Last time the subprocess was started; 0 if never
+        self._last_stop = 0.  # Last time the subprocess was stopped; 0 if never
+        self._last_stop_report = 0.  # Last time "waiting for x to stop" logged, to throttle
+        self._delay = 0.  # If nonzero, delay starting or killing until this time
+
+        self._administrative_stop = False  # true if process has been stopped by an admin
+        self._system_stop = False  # true if process has been stopped by the system
+
+        self._killing = False  # true if we are trying to kill this process
+
+        self._backoff = 0  # backoff counter (to startretries)
+
+        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
 
     @property
     def pid(self) -> int:
         return self._pid
 
+    @property
+    def group(self) -> AbstractProcessGroup:
+        return self._group
+
     @property
     def config(self) -> ProcessConfig:
         return self._config
@@ -111,6 +106,17 @@ class Subprocess(AbstractSubprocess):
     def context(self) -> AbstractServerContext:
         return self._context
 
+    @property
+    def state(self) -> ProcessState:
+        return self._state
+
+    @property
+    def backoff(self) -> int:
+        return self._backoff
+
+    def get_dispatchers(self) -> ta.Mapping[int, Dispatcher]:
+        return self._dispatchers
+
     def remove_logs(self) -> None:
         for dispatcher in self._dispatchers.values():
             if hasattr(dispatcher, 'remove_logs'):
@@ -131,18 +137,18 @@ class Subprocess(AbstractSubprocess):
                 dispatcher.handle_write_event()
 
     def write(self, chars: ta.Union[bytes, str]) -> None:
-        if not self.pid or self.killing:
+        if not self.pid or self._killing:
             raise OSError(errno.EPIPE, 'Process already closed')
 
         stdin_fd = self._pipes['stdin']
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-        dispatcher = self._dispatchers[stdin_fd]
+        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
         if dispatcher.closed:
             raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
-        dispatcher.input_buffer += chars
+        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]]:
@@ -152,9 +158,9 @@ class Subprocess(AbstractSubprocess):
         """
 
         try:
-            commandargs = shlex.split(self.config.command)
+            commandargs = shlex.split(self._config.command)
         except ValueError as e:
-            raise BadCommandError(f"can't parse command {self.config.command!r}: {e}")  # noqa
+            raise BadCommandError(f"can't parse command {self._config.command!r}: {e}")  # noqa
 
         if commandargs:
             program = commandargs[0]
@@ -191,76 +197,65 @@ class Subprocess(AbstractSubprocess):
 
         return filename, commandargs
 
-    event_map: ta.ClassVar[ta.Mapping[int, ta.Type[ProcessStateEvent]]] = {
-        ProcessStates.BACKOFF: ProcessStateBackoffEvent,
-        ProcessStates.FATAL: ProcessStateFatalEvent,
-        ProcessStates.UNKNOWN: ProcessStateUnknownEvent,
-        ProcessStates.STOPPED: ProcessStateStoppedEvent,
-        ProcessStates.EXITED: ProcessStateExitedEvent,
-        ProcessStates.RUNNING: ProcessStateRunningEvent,
-        ProcessStates.STARTING: ProcessStateStartingEvent,
-        ProcessStates.STOPPING: ProcessStateStoppingEvent,
-    }
-
     def change_state(self, new_state: ProcessState, expected: bool = True) -> bool:
-        old_state = self.state
+        old_state = self._state
         if new_state is old_state:
             return False
 
-        self.state = new_state
-        if new_state == ProcessStates.BACKOFF:
+        self._state = new_state
+        if new_state == ProcessState.BACKOFF:
             now = time.time()
-            self.backoff += 1
-            self.delay = now + self.backoff
+            self._backoff += 1
+            self._delay = now + self._backoff
 
-        event_class = self.event_map.get(new_state)
+        event_class = PROCESS_STATE_EVENT_MAP.get(new_state)
         if event_class is not None:
             event = event_class(self, old_state, expected)
-            EVENT_CALLBACKS.notify(event)
+            self._event_callbacks.notify(event)
 
         return True
 
     def _check_in_state(self, *states: ProcessState) -> None:
-        if self.state not in states:
-            current_state = get_process_state_description(self.state)
-            allowable_states = ' '.join(map(get_process_state_description, states))
-            processname = as_string(self.config.name)
-            raise AssertionError('Assertion failed for %s: %s not in %s' % (processname, current_state, allowable_states))  # noqa
+        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)
+        self._spawn_err = msg
+        log.info('_spawn_err: %s', msg)
 
     def spawn(self) -> ta.Optional[int]:
-        processname = as_string(self.config.name)
+        process_name = as_string(self._config.name)
 
         if self.pid:
-            log.warning('process \'%s\' already running', processname)
+            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._killing = False
+        self._spawn_err = None
+        self._exitstatus = None
+        self._system_stop = False
+        self._administrative_stop = False
 
-        self.laststart = time.time()
+        self._last_start = time.time()
 
         self._check_in_state(
-            ProcessStates.EXITED,
-            ProcessStates.FATAL,
-            ProcessStates.BACKOFF,
-            ProcessStates.STOPPED,
+            ProcessState.EXITED,
+            ProcessState.FATAL,
+            ProcessState.BACKOFF,
+            ProcessState.STOPPED,
         )
 
-        self.change_state(ProcessStates.STARTING)
+        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(ProcessStates.STARTING)
-            self.change_state(ProcessStates.BACKOFF)
+            self._check_in_state(ProcessState.STARTING)
+            self.change_state(ProcessState.BACKOFF)
             return None
 
         try:
@@ -269,12 +264,12 @@ class Subprocess(AbstractSubprocess):
             code = why.args[0]
             if code == errno.EMFILE:
                 # too many file descriptors open
-                msg = f"too many open files to spawn '{processname}'"
+                msg = f"too many open files to spawn '{process_name}'"
             else:
-                msg = f"unknown error making dispatchers for '{processname}': {errno.errorcode.get(code, code)}"
+                msg = f"unknown error making dispatchers for '{process_name}': {errno.errorcode.get(code, code)}"
             self._record_spawn_err(msg)
-            self._check_in_state(ProcessStates.STARTING)
-            self.change_state(ProcessStates.BACKOFF)
+            self._check_in_state(ProcessState.STARTING)
+            self.change_state(ProcessState.BACKOFF)
             return None
 
         try:
@@ -283,12 +278,12 @@ class Subprocess(AbstractSubprocess):
             code = why.args[0]
             if code == errno.EAGAIN:
                 # process table full
-                msg = f'Too many processes in process table to spawn \'{processname}\''
+                msg = f'Too many processes in process table to spawn \'{process_name}\''
             else:
-                msg = f'unknown error during fork for \'{processname}\': {errno.errorcode.get(code, code)}'
+                msg = f'unknown error during fork for \'{process_name}\': {errno.errorcode.get(code, code)}'
             self._record_spawn_err(msg)
-            self._check_in_state(ProcessStates.STARTING)
-            self.change_state(ProcessStates.BACKOFF)
+            self._check_in_state(ProcessState.STARTING)
+            self.change_state(ProcessState.BACKOFF)
             close_parent_pipes(self._pipes)
             close_child_pipes(self._pipes)
             return None
@@ -301,41 +296,66 @@ class Subprocess(AbstractSubprocess):
             return None
 
     def _make_dispatchers(self) -> ta.Tuple[ta.Mapping[int, Dispatcher], ta.Mapping[str, int]]:
-        use_stderr = not self.config.redirect_stderr
+        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] = OutputDispatcher(self, etype, stdout_fd)
+            dispatchers[stdout_fd] = OutputDispatcher(
+                self,
+                etype,
+                stdout_fd,
+                **dispatcher_kw,
+            )
+
         if stderr_fd is not None:
             etype = ProcessCommunicationStderrEvent
-            dispatchers[stderr_fd] = OutputDispatcher(self, etype, stderr_fd)
+            dispatchers[stderr_fd] = OutputDispatcher(
+                self,
+                etype,
+                stderr_fd,
+                **dispatcher_kw,
+            )
+
         if stdin_fd is not None:
-            dispatchers[stdin_fd] = InputDispatcher(self, 'stdin', stdin_fd)
+            dispatchers[stdin_fd] = InputDispatcher(
+                self,
+                'stdin',
+                stdin_fd,
+                **dispatcher_kw,
+            )
+
         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
+        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:
+        if self._config.redirect_stderr:
             os.dup2(self._pipes['child_stdout'], 2)
         else:
             os.dup2(self._pipes['child_stderr'], 2)
 
         for i in range(3, self.context.config.minfds):
-            if i in self.context.inherited_fds:
+            if i in self._inherited_fds:
                 continue
             close_fd(i)
 
@@ -353,7 +373,7 @@ class Subprocess(AbstractSubprocess):
             # set user
             setuid_msg = self.set_uid()
             if setuid_msg:
-                uid = self.config.uid
+                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
@@ -361,14 +381,14 @@ class Subprocess(AbstractSubprocess):
             # 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)
+            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
+            cwd = self._config.directory
             try:
                 if cwd is not None:
                     os.chdir(os.path.expanduser(cwd))
@@ -380,8 +400,8 @@ class Subprocess(AbstractSubprocess):
 
             # set umask, then execve
             try:
-                if self.config.umask is not None:
-                    os.umask(self.config.umask)
+                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])
@@ -403,46 +423,48 @@ class Subprocess(AbstractSubprocess):
         """
         Check if system clock has rolled backward beyond test_time. If so, set affected timestamps to test_time.
         """
-        if self.state == ProcessStates.STARTING:
-            self.laststart = min(test_time, self.laststart)
-            if self.delay > 0 and test_time < (self.delay - self.config.startsecs):
-                self.delay = test_time + self.config.startsecs
 
-        elif self.state == ProcessStates.RUNNING:
-            if test_time > self.laststart and test_time < (self.laststart + self.config.startsecs):
-                self.laststart = test_time - self.config.startsecs
+        if self._state == ProcessState.STARTING:
+            self._last_start = min(test_time, self._last_start)
+            if self._delay > 0 and test_time < (self._delay - self._config.startsecs):
+                self._delay = test_time + self._config.startsecs
 
-        elif self.state == ProcessStates.STOPPING:
-            self.last_stop_report = min(test_time, self.last_stop_report)
-            if self.delay > 0 and test_time < (self.delay - self.config.stopwaitsecs):
-                self.delay = test_time + self.config.stopwaitsecs
+        elif self._state == ProcessState.RUNNING:
+            if test_time > self._last_start and test_time < (self._last_start + self._config.startsecs):
+                self._last_start = test_time - self._config.startsecs
 
-        elif self.state == ProcessStates.BACKOFF:
-            if self.delay > 0 and test_time < (self.delay - self.backoff):
-                self.delay = test_time + self.backoff
+        elif self._state == ProcessState.STOPPING:
+            self._last_stop_report = min(test_time, self._last_stop_report)
+            if self._delay > 0 and test_time < (self._delay - self._config.stopwaitsecs):
+                self._delay = test_time + self._config.stopwaitsecs
+
+        elif self._state == ProcessState.BACKOFF:
+            if self._delay > 0 and test_time < (self._delay - self._backoff):
+                self._delay = test_time + self._backoff
 
     def stop(self) -> ta.Optional[str]:
-        self.administrative_stop = True
-        self.last_stop_report = 0
-        return self.kill(self.config.stopsignal)
+        self._administrative_stop = True
+        self._last_stop_report = 0
+        return self.kill(self._config.stopsignal)
 
     def stop_report(self) -> None:
         """Log a 'waiting for x to stop' message with throttling."""
-        if self.state == ProcessStates.STOPPING:
+
+        if self._state == ProcessState.STOPPING:
             now = time.time()
 
             self._check_and_adjust_for_system_clock_rollback(now)
 
-            if now > (self.last_stop_report + 2):  # every 2 seconds
-                log.info('waiting for %s to stop', as_string(self.config.name))
-                self.last_stop_report = now
+            if now > (self._last_stop_report + 2):  # every 2 seconds
+                log.info('waiting for %s to stop', as_string(self._config.name))
+                self._last_stop_report = now
 
     def give_up(self) -> None:
-        self.delay = 0
-        self.backoff = 0
-        self.system_stop = True
-        self._check_in_state(ProcessStates.BACKOFF)
-        self.change_state(ProcessStates.FATAL)
+        self._delay = 0
+        self._backoff = 0
+        self._system_stop = True
+        self._check_in_state(ProcessState.BACKOFF)
+        self.change_state(ProcessState.FATAL)
 
     def kill(self, sig: int) -> ta.Optional[str]:
         """
@@ -454,39 +476,39 @@ class Subprocess(AbstractSubprocess):
         """
         now = time.time()
 
-        processname = as_string(self.config.name)
+        process_name = as_string(self._config.name)
         # If the process is in BACKOFF and we want to stop or kill it, then BACKOFF -> STOPPED.  This is needed because
         # if startretries is a large number and the process isn't starting successfully, the stop request would be
         # blocked for a long time waiting for the retries.
-        if self.state == ProcessStates.BACKOFF:
-            log.debug('Attempted to kill %s, which is in BACKOFF state.', processname)
-            self.change_state(ProcessStates.STOPPED)
+        if self._state == ProcessState.BACKOFF:
+            log.debug('Attempted to kill %s, which is in BACKOFF state.', process_name)
+            self.change_state(ProcessState.STOPPED)
             return None
 
         args: tuple
         if not self.pid:
-            fmt, args = "attempted to kill %s with sig %s but it wasn't running", (processname, signame(sig))
+            fmt, args = "attempted to kill %s with sig %s but it wasn't running", (process_name, sig_name(sig))
             log.debug(fmt, *args)
             return fmt % args
 
         # If we're in the stopping state, then we've already sent the stop signal and this is the kill signal
-        if self.state == ProcessStates.STOPPING:
-            killasgroup = self.config.killasgroup
+        if self._state == ProcessState.STOPPING:
+            killasgroup = self._config.killasgroup
         else:
-            killasgroup = self.config.stopasgroup
+            killasgroup = self._config.stopasgroup
 
         as_group = ''
         if killasgroup:
             as_group = 'process group '
 
-        log.debug('killing %s (pid %s) %swith signal %s', processname, self.pid, as_group, signame(sig))
+        log.debug('killing %s (pid %s) %s with signal %s', process_name, self.pid, as_group, sig_name(sig))
 
         # RUNNING/STARTING/STOPPING -> STOPPING
-        self.killing = True
-        self.delay = now + self.config.stopwaitsecs
+        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(ProcessStates.RUNNING, ProcessStates.STARTING, ProcessStates.STOPPING)
-        self.change_state(ProcessStates.STOPPING)
+        self._check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
+        self.change_state(ProcessState.STOPPING)
 
         pid = self.pid
         if killasgroup:
@@ -498,18 +520,18 @@ class Subprocess(AbstractSubprocess):
                 os.kill(pid, sig)
             except OSError as exc:
                 if exc.errno == errno.ESRCH:
-                    log.debug('unable to signal %s (pid %s), it probably just exited on its own: %s', processname, self.pid, str(exc))  # noqa
+                    log.debug('unable to signal %s (pid %s), it probably just exited on its own: %s', process_name, self.pid, str(exc))  # noqa
                     # we could change the state here but we intentionally do not.  we will do it during normal SIGCHLD
                     # processing.
                     return None
                 raise
         except Exception:  # noqa
             tb = traceback.format_exc()
-            fmt, args = 'unknown problem killing %s (%s):%s', (processname, self.pid, tb)
+            fmt, args = 'unknown problem killing %s (%s):%s', (process_name, self.pid, tb)
             log.critical(fmt, *args)
-            self.change_state(ProcessStates.UNKNOWN)
-            self.killing = False
-            self.delay = 0
+            self.change_state(ProcessState.UNKNOWN)
+            self._killing = False
+            self._delay = 0
             return fmt % args
 
         return None
@@ -521,16 +543,16 @@ class Subprocess(AbstractSubprocess):
         Return None if the signal was sent, or an error message string if an error occurred or if the subprocess is not
         running.
         """
-        processname = as_string(self.config.name)
+        process_name = as_string(self._config.name)
         args: tuple
         if not self.pid:
-            fmt, args = "attempted to send %s sig %s but it wasn't running", (processname, signame(sig))
+            fmt, args = "attempted to send %s sig %s but it wasn't running", (process_name, sig_name(sig))
             log.debug(fmt, *args)
             return fmt % args
 
-        log.debug('sending %s (pid %s) sig %s', processname, self.pid, signame(sig))
+        log.debug('sending %s (pid %s) sig %s', process_name, self.pid, sig_name(sig))
 
-        self._check_in_state(ProcessStates.RUNNING, ProcessStates.STARTING, ProcessStates.STOPPING)
+        self._check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
 
         try:
             try:
@@ -539,7 +561,7 @@ class Subprocess(AbstractSubprocess):
                 if exc.errno == errno.ESRCH:
                     log.debug(
                         'unable to signal %s (pid %s), it probably just now exited on its own: %s',
-                        processname,
+                        process_name,
                         self.pid,
                         str(exc),
                     )
@@ -549,9 +571,9 @@ class Subprocess(AbstractSubprocess):
                 raise
         except Exception:  # noqa
             tb = traceback.format_exc()
-            fmt, args = 'unknown problem sending sig %s (%s):%s', (processname, self.pid, tb)
+            fmt, args = 'unknown problem sending sig %s (%s):%s', (process_name, self.pid, tb)
             log.critical(fmt, *args)
-            self.change_state(ProcessStates.UNKNOWN)
+            self.change_state(ProcessState.UNKNOWN)
             return fmt % args
 
         return None
@@ -567,31 +589,31 @@ class Subprocess(AbstractSubprocess):
 
         self._check_and_adjust_for_system_clock_rollback(now)
 
-        self.laststop = now
-        processname = as_string(self.config.name)
+        self._last_stop = now
+        process_name = as_string(self._config.name)
 
-        if now > self.laststart:
-            too_quickly = now - self.laststart < self.config.startsecs
+        if now > self._last_start:
+            too_quickly = now - self._last_start < self._config.startsecs
         else:
             too_quickly = False
             log.warning(
-                "process '%s' (%s) laststart time is in the future, don't know how long process was running so "
+                "process '%s' (%s) last_start time is in the future, don't know how long process was running so "
                 "assuming it did not exit too quickly",
-                processname,
+                process_name,
                 self.pid,
             )
 
-        exit_expected = es in self.config.exitcodes
+        exit_expected = es in self._config.exitcodes
 
-        if self.killing:
+        if self._killing:
             # likely the result of a stop request implies STOPPING -> STOPPED
-            self.killing = False
-            self.delay = 0
-            self.exitstatus = es
+            self._killing = False
+            self._delay = 0
+            self._exitstatus = es
 
-            fmt, args = 'stopped: %s (%s)', (processname, msg)
-            self._check_in_state(ProcessStates.STOPPING)
-            self.change_state(ProcessStates.STOPPED)
+            fmt, args = 'stopped: %s (%s)', (process_name, msg)
+            self._check_in_state(ProcessState.STOPPING)
+            self.change_state(ProcessState.STOPPED)
             if exit_expected:
                 log.info(fmt, *args)
             else:
@@ -599,226 +621,119 @@ class Subprocess(AbstractSubprocess):
 
         elif too_quickly:
             # 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(ProcessStates.STARTING)
-            self.change_state(ProcessStates.BACKOFF)
-            log.warning('exited: %s (%s)', processname, msg + '; not expected')
+            self._exitstatus = None
+            self._spawn_err = 'Exited too quickly (process log may have details)'
+            self._check_in_state(ProcessState.STARTING)
+            self.change_state(ProcessState.BACKOFF)
+            log.warning('exited: %s (%s)', process_name, msg + '; not expected')
 
         else:
             # this finish was not the result of a stop request, the program was in the RUNNING state but exited implies
             # RUNNING -> EXITED normally but see next comment
-            self.delay = 0
-            self.backoff = 0
-            self.exitstatus = es
+            self._delay = 0
+            self._backoff = 0
+            self._exitstatus = es
 
-            # if the process was STARTING but a system time change causes self.laststart to be in the future, the normal
-            # STARTING->RUNNING transition can be subverted so we perform the transition here.
-            if self.state == ProcessStates.STARTING:
-                self.change_state(ProcessStates.RUNNING)
+            # if the process was STARTING but a system time change causes self.last_start to be in the future, the
+            # normal STARTING->RUNNING transition can be subverted so we perform the transition here.
+            if self._state == ProcessState.STARTING:
+                self.change_state(ProcessState.RUNNING)
 
-            self._check_in_state(ProcessStates.RUNNING)
+            self._check_in_state(ProcessState.RUNNING)
 
             if exit_expected:
                 # expected exit code
-                self.change_state(ProcessStates.EXITED, expected=True)
-                log.info('exited: %s (%s)', processname, msg + '; expected')
+                self.change_state(ProcessState.EXITED, expected=True)
+                log.info('exited: %s (%s)', process_name, msg + '; expected')
             else:
                 # unexpected exit code
-                self.spawn_err = f'Bad exit code {es}'
-                self.change_state(ProcessStates.EXITED, expected=False)
-                log.warning('exited: %s (%s)', processname, msg + '; not expected')
+                self._spawn_err = f'Bad exit code {es}'
+                self.change_state(ProcessState.EXITED, expected=False)
+                log.warning('exited: %s (%s)', process_name, msg + '; not expected')
 
         self._pid = 0
         close_parent_pipes(self._pipes)
         self._pipes = {}
         self._dispatchers = {}
 
-        # if we died before we processed the current event (only happens if we're an event listener), notify the event
-        # system that this event was rejected so it can be processed again.
-        if self.event is not None:
-            # Note: this should only be true if we were in the BUSY state when finish() was called.
-            EVENT_CALLBACKS.notify(EventRejectedEvent(self, self.event))  # type: ignore
-            self.event = None
-
     def set_uid(self) -> ta.Optional[str]:
-        if self.config.uid is None:
+        if self._config.uid is None:
             return None
-        msg = drop_privileges(self.config.uid)
+        msg = drop_privileges(self._config.uid)
         return msg
 
-    def __lt__(self, other):
-        return self.config.priority < other.config.priority
-
-    def __eq__(self, other):
-        return self.config.priority == other.config.priority
-
-    def __repr__(self):
+    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 {get_process_state_description(self.get_state())}>'
+        name = self._config.name
+        return f'<Subprocess at {id(self)} with name {name} in state {self.get_state().name}>'
 
     def get_state(self) -> ProcessState:
-        return self.state
+        return self._state
 
-    def transition(self):
+    def transition(self) -> None:
         now = time.time()
-        state = self.state
+        state = self._state
 
         self._check_and_adjust_for_system_clock_rollback(now)
 
         logger = log
 
-        if self.context.state > SupervisorStates.RESTARTING:
+        if self.context.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
-            if state == ProcessStates.EXITED:
-                if self.config.autorestart:
-                    if self.config.autorestart is RestartUnconditionally:
+            if state == ProcessState.EXITED:
+                if self._config.autorestart:
+                    if self._config.autorestart is RestartUnconditionally:
                         # EXITED -> STARTING
                         self.spawn()
-                    elif self.exitstatus not in self.config.exitcodes:
+                    elif self._exitstatus not in self._config.exitcodes:
                         # EXITED -> STARTING
                         self.spawn()
 
-            elif state == ProcessStates.STOPPED and not self.laststart:
-                if self.config.autostart:
+            elif state == ProcessState.STOPPED and not self._last_start:
+                if self._config.autostart:
                     # STOPPED -> STARTING
                     self.spawn()
 
-            elif state == ProcessStates.BACKOFF:
-                if self.backoff <= self.config.startretries:
-                    if now > self.delay:
+            elif state == ProcessState.BACKOFF:
+                if self._backoff <= self._config.startretries:
+                    if now > self._delay:
                         # BACKOFF -> STARTING
                         self.spawn()
 
-        processname = as_string(self.config.name)
-        if state == ProcessStates.STARTING:
-            if now - self.laststart > self.config.startsecs:
+        process_name = as_string(self._config.name)
+        if state == ProcessState.STARTING:
+            if now - self._last_start > self._config.startsecs:
                 # STARTING -> RUNNING if the proc has started successfully and it has stayed up for at least
                 # proc.config.startsecs,
-                self.delay = 0
-                self.backoff = 0
-                self._check_in_state(ProcessStates.STARTING)
-                self.change_state(ProcessStates.RUNNING)
-                msg = ('entered RUNNING state, process has stayed up for > than %s seconds (startsecs)' % self.config.startsecs)  # noqa
-                logger.info('success: %s %s', processname, msg)
-
-        if state == ProcessStates.BACKOFF:
-            if self.backoff > self.config.startretries:
+                self._delay = 0
+                self._backoff = 0
+                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)
+
+        if state == ProcessState.BACKOFF:
+            if self._backoff > self._config.startretries:
                 # BACKOFF -> FATAL if the proc has exceeded its number of retries
                 self.give_up()
                 msg = ('entered FATAL state, too many start retries too quickly')
-                logger.info('gave up: %s %s', processname, msg)
+                logger.info('gave up: %s %s', process_name, msg)
 
-        elif state == ProcessStates.STOPPING:
-            time_left = self.delay - now
+        elif state == ProcessState.STOPPING:
+            time_left = self._delay - now
             if time_left <= 0:
                 # kill processes which are taking too long to stop with a final sigkill.  if this doesn't kill it, the
                 # process will be stuck in the STOPPING state forever.
-                log.warning('killing \'%s\' (%s) with SIGKILL', processname, self.pid)
+                log.warning('killing \'%s\' (%s) with SIGKILL', process_name, self.pid)
                 self.kill(signal.SIGKILL)
 
-    def create_auto_child_logs(self):
+    def create_auto_child_logs(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
-        # name = self.config.name  # noqa
+        # name = self._config.name  # noqa
         # if self.stdout_logfile is Automatic:
         #     self.stdout_logfile = get_autoname(name, sid, 'stdout')
         # if self.stderr_logfile is Automatic:
         #     self.stderr_logfile = get_autoname(name, sid, 'stderr')
         pass
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class SubprocessFactory:
-    fn: ta.Callable[[ProcessConfig, 'ProcessGroup'], Subprocess]
-
-    def __call__(self, config: ProcessConfig, group: 'ProcessGroup') -> Subprocess:
-        return self.fn(config, group)
-
-
-@functools.total_ordering
-class ProcessGroup:
-    def __init__(
-            self,
-            config: ProcessGroupConfig,
-            context: ServerContext,
-            *,
-            subprocess_factory: ta.Optional[SubprocessFactory] = None,
-    ):
-        super().__init__()
-        self.config = config
-        self.context = context
-
-        if subprocess_factory is None:
-            def make_subprocess(config: ProcessConfig, group: ProcessGroup) -> Subprocess:
-                return Subprocess(config, group, self.context)
-            subprocess_factory = SubprocessFactory(make_subprocess)
-        self._subprocess_factory = subprocess_factory
-
-        self.processes = {}
-        for pconfig in self.config.processes or []:
-            process = self._subprocess_factory(pconfig, self)
-            self.processes[pconfig.name] = process
-
-    def __lt__(self, other):
-        return self.config.priority < other.config.priority
-
-    def __eq__(self, other):
-        return self.config.priority == other.config.priority
-
-    def __repr__(self):
-        # 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'<{self.__class__.__name__} instance at {id(self)} named {name}>'
-
-    def remove_logs(self) -> None:
-        for process in self.processes.values():
-            process.remove_logs()
-
-    def reopen_logs(self) -> None:
-        for process in self.processes.values():
-            process.reopen_logs()
-
-    def stop_all(self) -> None:
-        processes = list(self.processes.values())
-        processes.sort()
-        processes.reverse()  # stop in desc priority order
-
-        for proc in processes:
-            state = proc.get_state()
-            if state == ProcessStates.RUNNING:
-                # RUNNING -> STOPPING
-                proc.stop()
-
-            elif state == ProcessStates.STARTING:
-                # STARTING -> STOPPING
-                proc.stop()
-
-            elif state == ProcessStates.BACKOFF:
-                # BACKOFF -> FATAL
-                proc.give_up()
-
-    def get_unstopped_processes(self) -> ta.List[Subprocess]:
-        return [x for x in self.processes.values() if x.get_state() not in STOPPED_STATES]
-
-    def get_dispatchers(self) -> ta.Dict[int, Dispatcher]:
-        dispatchers = {}
-        for process in self.processes.values():
-            dispatchers.update(process._dispatchers)  # noqa
-        return dispatchers
-
-    def before_remove(self) -> None:
-        pass
-
-    def transition(self) -> None:
-        for proc in self.processes.values():
-            proc.transition()
-
-    def after_setuid(self) -> None:
-        for proc in self.processes.values():
-            proc.create_auto_child_logs()