ominfra 0.0.0.dev130__py3-none-any.whl → 0.0.0.dev132__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -90,50 +90,54 @@ if sys.version_info < (3, 8):
 ########################################
 
 
-# ../../../omdev/toml/parser.py
+# ../../omdev/toml/parser.py
 TomlParseFloat = ta.Callable[[str], ta.Any]
 TomlKey = ta.Tuple[str, ...]
 TomlPos = int  # ta.TypeAlias
 
-# ../utils/collections.py
+# utils/collections.py
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
-# ../../../omlish/lite/cached.py
+# ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 
-# ../../../omlish/lite/check.py
+# ../../omlish/lite/check.py
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
 
-# ../../../omlish/lite/socket.py
+# ../../omlish/lite/socket.py
 SocketAddress = ta.Any
 SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
 
-# ../../../omlish/lite/typing.py
+# ../../omlish/lite/typing.py
 A0 = ta.TypeVar('A0')
 A1 = ta.TypeVar('A1')
 A2 = ta.TypeVar('A2')
 
-# ../events.py
+# events.py
 EventCallback = ta.Callable[['Event'], None]
+ProcessOutputChannel = ta.Literal['stdout', 'stderr']  # ta.TypeAlias
 
-# ../../../omlish/lite/http/parsing.py
+# ../../omlish/lite/contextmanagers.py
+ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
+
+# ../../omlish/lite/http/parsing.py
 HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 
-# ../../../omlish/lite/inject.py
+# ../../omlish/lite/inject.py
 U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
 InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 
-# ../../configs.py
+# ../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
-# ../../../omlish/lite/http/handlers.py
+# ../../omlish/lite/http/handlers.py
 HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
 
-# ../../../omlish/lite/http/coroserver.py
+# ../../omlish/lite/http/coroserver.py
 CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
 
@@ -991,9 +995,8 @@ class NoPermissionError(ProcessError):
 
 def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
     """
-    Drop privileges to become the specified user, which may be a username or uid.  Called for supervisord startup
-    and when spawning subprocesses.  Returns None on success or a string error message if privileges could not be
-    dropped.
+    Drop privileges to become the specified user, which may be a username or uid. Called for supervisord startup and
+    when spawning subprocesses. Returns None on success or a string error message if privileges could not be dropped.
     """
 
     if user is None:
@@ -1017,9 +1020,8 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
     current_uid = os.getuid()
 
     if current_uid == uid:
-        # do nothing and return successfully if the uid is already the current one.  this allows a supervisord
-        # running as an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in
-        # it.
+        # do nothing and return successfully if the uid is already the current one. this allows a supervisord running as
+        # an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in it.
         return None
 
     if current_uid != 0:
@@ -1079,6 +1081,17 @@ class ProcessState(enum.IntEnum):
         return self in SIGNALABLE_STATES
 
 
+# http://supervisord.org/subprocess.html
+STATE_TRANSITIONS = {
+    ProcessState.STOPPED: (ProcessState.STARTING,),
+    ProcessState.STARTING: (ProcessState.RUNNING, ProcessState.BACKOFF, ProcessState.STOPPING),
+    ProcessState.RUNNING: (ProcessState.STOPPING, ProcessState.EXITED),
+    ProcessState.BACKOFF: (ProcessState.STARTING, ProcessState.FATAL),
+    ProcessState.STOPPING: (ProcessState.STOPPED,),
+    ProcessState.EXITED: (ProcessState.STARTING,),
+    ProcessState.FATAL: (ProcessState.STARTING,),
+}
+
 STOPPED_STATES = (
     ProcessState.STOPPED,
     ProcessState.EXITED,
@@ -1373,8 +1386,8 @@ def strip_escapes(s: bytes) -> bytes:
 
 
 class SuffixMultiplier:
-    # d is a dictionary of suffixes to integer multipliers.  If no suffixes match, default is the multiplier.  Matches
-    # are case insensitive.  Return values are in the fundamental unit.
+    # d is a dictionary of suffixes to integer multipliers. If no suffixes match, default is the multiplier. Matches are
+    # case insensitive. Return values are in the fundamental unit.
     def __init__(self, d, default=1):
         super().__init__()
         self._d = d
@@ -1578,16 +1591,16 @@ class FdIoPoller(abc.ABC):
     def register_readable(self, fd: int) -> bool:
         if fd in self._readable:
             return False
-        self._readable.add(fd)
         self._register_readable(fd)
+        self._readable.add(fd)
         return True
 
     @ta.final
     def register_writable(self, fd: int) -> bool:
         if fd in self._writable:
             return False
-        self._writable.add(fd)
         self._register_writable(fd)
+        self._writable.add(fd)
         return True
 
     @ta.final
@@ -1691,24 +1704,24 @@ if hasattr(select, 'poll'):
 
         #
 
-        _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
-        _WRITE = select.POLLOUT
-
         def _register_readable(self, fd: int) -> None:
-            self._update_registration(fd)
+            self._update_registration(fd, r=True, w=fd in self._writable)
 
         def _register_writable(self, fd: int) -> None:
-            self._update_registration(fd)
+            self._update_registration(fd, r=fd in self._readable, w=True)
 
         def _unregister_readable(self, fd: int) -> None:
-            self._update_registration(fd)
+            self._update_registration(fd, r=False, w=False)
 
         def _unregister_writable(self, fd: int) -> None:
-            self._update_registration(fd)
+            self._update_registration(fd, r=fd in self._readable, w=False)
 
-        def _update_registration(self, fd: int) -> None:
-            r = fd in self._readable
-            w = fd in self._writable
+        #
+
+        _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
+        _WRITE = select.POLLOUT
+
+        def _update_registration(self, fd: int, *, r: bool, w: bool) -> None:
             if r or w:
                 self._poller.register(fd, (self._READ if r else 0) | (self._WRITE if w else 0))
             else:
@@ -2121,7 +2134,7 @@ class EventCallbacks:
 
 
 class ProcessLogEvent(Event, abc.ABC):
-    channel: ta.Optional[str] = None
+    channel: ta.ClassVar[ProcessOutputChannel]
 
     def __init__(self, process, pid, data):
         super().__init__()
@@ -2146,7 +2159,7 @@ class ProcessCommunicationEvent(Event, abc.ABC):
     BEGIN_TOKEN = b'<!--XSUPERVISOR:BEGIN-->'
     END_TOKEN = b'<!--XSUPERVISOR:END-->'
 
-    channel: ta.ClassVar[str]
+    channel: ta.ClassVar[ProcessOutputChannel]
 
     def __init__(self, process, pid, data):
         super().__init__()
@@ -2430,7 +2443,7 @@ def decode_wait_status(sts: int) -> ta.Tuple[Rc, str]:
     Decode the status returned by wait() or waitpid().
 
     Return a tuple (exitstatus, message) where exitstatus is the exit status, or -1 if the process was killed by a
-    signal; and message is a message telling what happened.  It is the caller's responsibility to display the message.
+    signal; and message is a message telling what happened. It is the caller's responsibility to display the message.
     """
 
     if os.WIFEXITED(sts):
@@ -2518,6 +2531,64 @@ def get_user(name: str) -> User:
     )
 
 
+########################################
+# ../../../omlish/lite/contextmanagers.py
+
+
+##
+
+
+class ExitStacked:
+    _exit_stack: ta.Optional[contextlib.ExitStack] = None
+
+    def __enter__(self: ExitStackedT) -> ExitStackedT:
+        check_state(self._exit_stack is None)
+        es = self._exit_stack = contextlib.ExitStack()
+        es.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (es := self._exit_stack) is None:
+            return None
+        self._exit_contexts()
+        return es.__exit__(exc_type, exc_val, exc_tb)
+
+    def _exit_contexts(self) -> None:
+        pass
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        es = check_not_none(self._exit_stack)
+        return es.enter_context(cm)
+
+
+##
+
+
+@contextlib.contextmanager
+def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
+    try:
+        yield fn
+    finally:
+        fn()
+
+
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):  # noqa
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)
+
+
 ########################################
 # ../../../omlish/lite/fdio/handlers.py
 
@@ -2626,19 +2697,40 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
         #
 
         def _register_readable(self, fd: int) -> None:
-            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_ADD)
+            self._update_registration(fd, 'read', 'add')
 
         def _register_writable(self, fd: int) -> None:
-            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_ADD)
+            self._update_registration(fd, 'write', 'add')
 
         def _unregister_readable(self, fd: int) -> None:
-            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_DELETE)
+            self._update_registration(fd, 'read', 'del')
 
         def _unregister_writable(self, fd: int) -> None:
-            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_DELETE)
+            self._update_registration(fd, 'write', 'del')
+
+        #
 
-        def _control(self, fd: int, filter: int, flags: int) -> None:  # noqa
-            ke = select.kevent(fd, filter=filter, flags=flags)
+        _CONTROL_FILTER_BY_READ_OR_WRITE: ta.ClassVar[ta.Mapping[ta.Literal['read', 'write'], int]] = {
+            'read': select.KQ_FILTER_READ,
+            'write': select.KQ_FILTER_WRITE,
+        }
+
+        _CONTROL_FLAGS_BY_ADD_OR_DEL: ta.ClassVar[ta.Mapping[ta.Literal['add', 'del'], int]] = {
+            'add': select.KQ_EV_ADD,
+            'del': select.KQ_EV_DELETE,
+        }
+
+        def _update_registration(
+                self,
+                fd: int,
+                read_or_write: ta.Literal['read', 'write'],
+                add_or_del: ta.Literal['add', 'del'],
+        ) -> None:  # noqa
+            ke = select.kevent(
+                fd,
+                filter=self._CONTROL_FILTER_BY_READ_OR_WRITE[read_or_write],
+                flags=self._CONTROL_FLAGS_BY_ADD_OR_DEL[add_or_del],
+            )
             kq = self._get_kqueue()
             try:
                 kq.control([ke], 0)
@@ -2649,7 +2741,8 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
                     pass
                 elif exc.errno == errno.ENOENT:
                     # Can happen when trying to remove an already closed socket
-                    pass
+                    if add_or_del == 'add':
+                        raise
                 else:
                     raise
 
@@ -5068,8 +5161,8 @@ class ProcessPipes:
 
 def make_process_pipes(stderr=True) -> ProcessPipes:
     """
-    Create pipes for parent to child stdin/stdout/stderr communications.  Open fd in non-blocking mode so we can
-    read them in the mainloop without blocking.  If stderr is False, don't create a pipe for stderr.
+    Create pipes for parent to child stdin/stdout/stderr communications. Open fd in non-blocking mode so we can read
+    them in the mainloop without blocking. If stderr is False, don't create a pipe for stderr.
     """
 
     pipes: ta.Dict[str, ta.Optional[Fd]] = {
@@ -5219,32 +5312,32 @@ class ProcessConfig:
     umask: ta.Optional[int] = None
     priority: int = 999
 
-    autostart: bool = True
-    autorestart: str = 'unexpected'
+    auto_start: bool = True
+    auto_restart: str = 'unexpected'
 
-    startsecs: int = 1
-    startretries: int = 3
+    start_secs: int = 1
+    start_retries: int = 3
 
-    numprocs: int = 1
-    numprocs_start: int = 0
+    num_procs: int = 1
+    num_procs_start: int = 0
 
     @dc.dataclass(frozen=True)
     class Log:
         file: ta.Optional[str] = None
-        capture_maxbytes: ta.Optional[int] = None
+        capture_max_bytes: ta.Optional[int] = None
         events_enabled: bool = False
         syslog: bool = False
         backups: ta.Optional[int] = None
-        maxbytes: ta.Optional[int] = None
+        max_bytes: ta.Optional[int] = None
 
     stdout: Log = Log()
     stderr: Log = Log()
 
-    stopsignal: int = signal.SIGTERM
-    stopwaitsecs: int = 10
-    stopasgroup: bool = False
+    stop_signal: int = signal.SIGTERM
+    stop_wait_secs: int = 10
+    stop_as_group: bool = False
 
-    killasgroup: bool = False
+    kill_as_group: bool = False
 
     exitcodes: ta.Sequence[int] = (0,)
 
@@ -5269,14 +5362,14 @@ class ServerConfig:
     umask: int = 0o22
     directory: ta.Optional[str] = None
     logfile: str = 'supervisord.log'
-    logfile_maxbytes: int = 50 * 1024 * 1024
+    logfile_max_bytes: int = 50 * 1024 * 1024
     logfile_backups: int = 10
     loglevel: int = logging.INFO
     pidfile: str = 'supervisord.pid'
     identifier: str = 'supervisor'
     child_logdir: str = '/dev/null'
-    minfds: int = 1024
-    minprocs: int = 200
+    min_fds: int = 1024
+    min_procs: int = 200
     nocleanup: bool = False
     strip_ansi: bool = False
     silent: bool = False
@@ -5289,7 +5382,7 @@ class ServerConfig:
             umask: ta.Union[int, str] = 0o22,
             directory: ta.Optional[str] = None,
             logfile: str = 'supervisord.log',
-            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
+            logfile_max_bytes: ta.Union[int, str] = 50 * 1024 * 1024,
             loglevel: ta.Union[int, str] = logging.INFO,
             pidfile: str = 'supervisord.pid',
             child_logdir: ta.Optional[str] = None,
@@ -5299,7 +5392,7 @@ class ServerConfig:
             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),
+            logfile_max_bytes=parse_bytes_size(logfile_max_bytes),
             loglevel=parse_logging_level(loglevel),
             pidfile=check_path_with_existing_dir(pidfile),
             child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
@@ -5953,7 +6046,7 @@ class HasDispatchers(abc.ABC):
 class ProcessDispatcher(FdIoHandler, abc.ABC):
     @property
     @abc.abstractmethod
-    def channel(self) -> str:
+    def channel(self) -> ProcessOutputChannel:
         raise NotImplementedError
 
     @property
@@ -6242,7 +6335,7 @@ class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def __init__(
             self,
             process: Process,
-            channel: str,
+            channel: ProcessOutputChannel,
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
@@ -6270,7 +6363,7 @@ class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
         return self._process
 
     @property
-    def channel(self) -> str:
+    def channel(self) -> ProcessOutputChannel:
         return self._channel
 
     def fd(self) -> Fd:
@@ -6360,7 +6453,7 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
         channel = self._channel  # noqa
 
         logfile = self._lc.file
-        maxbytes = self._lc.maxbytes  # noqa
+        max_bytes = self._lc.max_bytes  # noqa
         backups = self._lc.backups  # noqa
         to_syslog = self._lc.syslog
 
@@ -6372,8 +6465,8 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
         #         self.normal_log,
         #         filename=logfile,
         #         fmt='%(message)s',
-        #         rotating=bool(maxbytes),  # optimization
-        #         maxbytes=maxbytes,
+        #         rotating=bool(max_bytes),  # optimization
+        #         max_bytes=max_bytes,
         #         backups=backups,
         #     )
 
@@ -6385,17 +6478,17 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
 
     def _init_capture_log(self) -> None:
         """
-        Configure the capture log for this process.  This log is used to temporarily capture output when special output
+        Configure the capture log for this process. This log is used to temporarily capture output when special output
         is detected. Sets self.capture_log if capturing is enabled.
         """
 
-        capture_maxbytes = self._lc.capture_maxbytes
-        if capture_maxbytes:
+        capture_max_bytes = self._lc.capture_max_bytes
+        if capture_max_bytes:
             self._capture_log = logging.getLogger(__name__)
             # loggers.handle_boundIO(
             #     self._capture_log,
             #     fmt='%(message)s',
-            #     maxbytes=capture_maxbytes,
+            #     max_bytes=capture_max_bytes,
             # )
 
     def remove_logs(self) -> None:
@@ -6508,7 +6601,7 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
         self._output_buffer += data
         self.record_output()
         if not data:
-            # if we get no data back from the pipe, it means that the child process has ended.  See
+            # if we get no data back from the pipe, it means that the child process has ended. See
             # mail.python.org/pipermail/python-dev/2004-August/046850.html
             self.close()
 
@@ -6517,7 +6610,7 @@ class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatch
     def __init__(
             self,
             process: Process,
-            channel: str,
+            channel: ProcessOutputChannel,
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
@@ -6717,21 +6810,21 @@ class SupervisorSetupImpl(SupervisorSetup):
     def _cleanup_fds(self) -> None:
         # try to close any leaked file descriptors (for reload)
         start = 5
-        os.closerange(start, self._config.minfds)
+        os.closerange(start, self._config.min_fds)
 
     #
 
     def _set_uid_or_exit(self) -> None:
         """
-        Set the uid of the supervisord process.  Called during supervisord startup only.  No return value.  Exits the
+        Set the uid of the supervisord process. Called during supervisord startup only. No return value. Exits the
         process via usage() if privileges could not be dropped.
         """
 
         if self._user is None:
             if os.getuid() == 0:
                 warnings.warn(
-                    'Supervisor is running as root.  Privileges were not dropped because no user is specified in the '
-                    'config file.  If you intend to run as root, you can set user=root in the config file to avoid '
+                    'Supervisor is running as root. Privileges were not dropped because no user is specified in the '
+                    'config file. If you intend to run as root, you can set user=root in the config file to avoid '
                     'this message.',
                 )
         else:
@@ -6745,8 +6838,8 @@ class SupervisorSetupImpl(SupervisorSetup):
 
     def _set_rlimits_or_exit(self) -> None:
         """
-        Set the rlimits of the supervisord process.  Called during supervisord startup only.  No return value.  Exits
-        the process via usage() if any rlimits could not be set.
+        Set the rlimits of the supervisord process. Called during supervisord startup only. No return value. Exits the
+        process via usage() if any rlimits could not be set.
         """
 
         limits = []
@@ -6755,12 +6848,12 @@ class SupervisorSetupImpl(SupervisorSetup):
             limits.append({
                 'msg': (
                     'The minimum number of file descriptors required to run this process is %(min_limit)s as per the '
-                    '"minfds" command-line argument or config file setting. The current environment will only allow '
-                    'you to open %(hard)s file descriptors.  Either raise the number of usable file descriptors in '
-                    'your environment (see README.rst) or lower the minfds setting in the config file to allow the '
+                    '"min_fds" command-line argument or config file setting. The current environment will only allow '
+                    'you to open %(hard)s file descriptors. Either raise the number of usable file descriptors in '
+                    'your environment (see README.rst) or lower the min_fds setting in the config file to allow the '
                     'process to start.'
                 ),
-                'min': self._config.minfds,
+                'min': self._config.min_fds,
                 'resource': resource.RLIMIT_NOFILE,
                 'name': 'RLIMIT_NOFILE',
             })
@@ -6770,11 +6863,11 @@ class SupervisorSetupImpl(SupervisorSetup):
                 'msg': (
                     'The minimum number of available processes required to run this program is %(min_limit)s as per '
                     'the "minprocs" command-line argument or config file setting. The current environment will only '
-                    'allow you to open %(hard)s processes.  Either raise the number of usable processes in your '
+                    'allow you to open %(hard)s processes. Either raise the number of usable processes in your '
                     'environment (see README.rst) or lower the minprocs setting in the config file to allow the '
                     'program to start.'
                 ),
-                'min': self._config.minprocs,
+                'min': self._config.min_procs,
                 'resource': resource.RLIMIT_NPROC,
                 'name': 'RLIMIT_NPROC',
             })
@@ -6860,11 +6953,11 @@ class SupervisorSetupImpl(SupervisorSetup):
             dl.after_daemonize()
 
     def _do_daemonize(self) -> None:
-        # To daemonize, we need to become the leader of our own session (process) group.  If we do not, signals sent to
-        # our parent process will also be sent to us.   This might be bad because signals such as SIGINT can be sent to
+        # To daemonize, we need to become the leader of our own session (process) group. If we do not, signals sent to
+        # our parent process will also be sent to us. This might be bad because signals such as SIGINT can be sent to
         # our parent process during normal (uninteresting) operations such as when we press Ctrl-C in the parent
         # terminal window to escape from a logtail command. To disassociate ourselves from our parent's session group we
-        # use os.setsid.  It means "set session id", which has the effect of disassociating a process from is current
+        # use os.setsid. It means "set session id", which has the effect of disassociating a process from is current
         # session and process group and setting itself up as a new session leader.
         #
         # Unfortunately we cannot call setsid if we're already a session group leader, so we use "fork" to make a copy
@@ -6896,7 +6989,7 @@ class SupervisorSetupImpl(SupervisorSetup):
         os.dup2(2, os.open('/dev/null', os.O_WRONLY))
 
         # XXX Stevens, in his Advanced Unix book, section 13.3 (page 417) recommends calling umask(0) and closing unused
-        # file descriptors.  In his Network Programming book, he additionally recommends ignoring SIGHUP and forking
+        # file descriptors. In his Network Programming book, he additionally recommends ignoring SIGHUP and forking
         # again after the setsid() call, for obscure SVR4 reasons.
         os.setsid()
         os.umask(self._config.umask)
@@ -7026,9 +7119,9 @@ class IoManager(HasDispatchers):
         )
 
         timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-        log.info(f'Polling: {timeout=}')  # noqa
+
         polled = self._poller.poll(timeout)
-        log.info(f'Polled: {polled=}')  # noqa
+
         if polled.msg is not None:
             log.error(polled.msg)
         if polled.exc is not None:
@@ -7153,6 +7246,8 @@ class HttpServer(HasDispatchers):
             self,
             handler: Handler,
             addr: Address = Address(('localhost', 8000)),
+            *,
+            exit_stack: contextlib.ExitStack,
     ) -> None:
         super().__init__()
 
@@ -7163,6 +7258,8 @@ class HttpServer(HasDispatchers):
 
         self._conns: ta.List[CoroHttpServerConnectionFdIoHandler] = []
 
+        exit_stack.enter_context(defer(self._server.close))  # noqa
+
     def get_dispatchers(self) -> Dispatchers:
         l = []
         for c in self._conns:
@@ -7207,6 +7304,7 @@ class SupervisorHttpHandler:
                     'processes': {
                         p.name: {
                             'pid': p.pid,
+                            'state': p.state.name,
                         }
                         for p in g
                     },
@@ -7275,7 +7373,7 @@ class ProcessImpl(Process):
 
         self._killing = False  # true if we are trying to kill this process
 
-        self._backoff = 0  # backoff counter (to startretries)
+        self._backoff = 0  # backoff counter (to start_retries)
 
         self._exitstatus: ta.Optional[Rc] = None  # status attached to dead process by finish()
         self._spawn_err: ta.Optional[str] = None  # error message attached by spawn() if any
@@ -7352,7 +7450,7 @@ class ProcessImpl(Process):
         self._pipes = sp.pipes
         self._dispatchers = sp.dispatchers
 
-        self._delay = time.time() + self.config.startsecs
+        self._delay = time.time() + self.config.start_secs
 
         return sp.pid
 
@@ -7410,17 +7508,17 @@ class ProcessImpl(Process):
 
         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
+            if self._delay > 0 and test_time < (self._delay - self._config.start_secs):
+                self._delay = test_time + self._config.start_secs
 
         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
+            if test_time > self._last_start and test_time < (self._last_start + self._config.start_secs):
+                self._last_start = test_time - self._config.start_secs
 
         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
+            if self._delay > 0 and test_time < (self._delay - self._config.stop_wait_secs):
+                self._delay = test_time + self._config.stop_wait_secs
 
         elif self._state == ProcessState.BACKOFF:
             if self._delay > 0 and test_time < (self._delay - self._backoff):
@@ -7429,7 +7527,7 @@ class ProcessImpl(Process):
     def stop(self) -> ta.Optional[str]:
         self._administrative_stop = True
         self._last_stop_report = 0
-        return self.kill(self._config.stopsignal)
+        return self.kill(self._config.stop_signal)
 
     def stop_report(self) -> None:
         """Log a 'waiting for x to stop' message with throttling."""
@@ -7452,7 +7550,7 @@ class ProcessImpl(Process):
 
     def kill(self, sig: int) -> ta.Optional[str]:
         """
-        Send a signal to the subprocess with the intention to kill it (to make it exit).  This may or may not actually
+        Send a signal to the subprocess with the intention to kill it (to make it exit). This may or may not actually
         kill it.
 
         Return None if the signal was sent, or an error message string if an error occurred or if the subprocess is not
@@ -7460,8 +7558,8 @@ class ProcessImpl(Process):
         """
         now = time.time()
 
-        # 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
+        # If the process is in BACKOFF and we want to stop or kill it, then BACKOFF -> STOPPED. This is needed because
+        # if start_retries 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 == ProcessState.BACKOFF:
             log.debug('Attempted to kill %s, which is in BACKOFF state.', self.name)
@@ -7476,25 +7574,25 @@ class ProcessImpl(Process):
 
         # If we're in the stopping state, then we've already sent the stop signal and this is the kill signal
         if self._state == ProcessState.STOPPING:
-            killasgroup = self._config.killasgroup
+            kill_as_group = self._config.kill_as_group
         else:
-            killasgroup = self._config.stopasgroup
+            kill_as_group = self._config.stop_as_group
 
         as_group = ''
-        if killasgroup:
+        if kill_as_group:
             as_group = 'process group '
 
         log.debug('killing %s (pid %s) %s with signal %s', self.name, self.pid, as_group, sig_name(sig))
 
         # RUNNING/STARTING/STOPPING -> STOPPING
         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._delay = now + self._config.stop_wait_secs
+        # we will already be in the STOPPING state if we're doing a SIGKILL as a result of overrunning stop_wait_secs
         self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
         self.change_state(ProcessState.STOPPING)
 
         kpid = int(self.pid)
-        if killasgroup:
+        if kill_as_group:
             # send to the whole process group instead
             kpid = -kpid
 
@@ -7504,7 +7602,7 @@ class ProcessImpl(Process):
             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', self.name, self.pid, str(exc))  # noqa
-                    # we could change the state here but we intentionally do not.  we will do it during normal SIGCHLD
+                    # we could change the state here but we intentionally do not. we will do it during normal SIGCHLD
                     # processing.
                     return None
                 raise
@@ -7547,7 +7645,7 @@ class ProcessImpl(Process):
                         self.pid,
                         str(exc),
                     )
-                    # we could change the state here but we intentionally do not.  we will do it during normal SIGCHLD
+                    # we could change the state here but we intentionally do not. we will do it during normal SIGCHLD
                     # processing.
                     return None
                 raise
@@ -7574,8 +7672,7 @@ class ProcessImpl(Process):
         self._last_stop = now
 
         if now > self._last_start:
-            log.info(f'{now - self._last_start=}')  # noqa
-            too_quickly = now - self._last_start < self._config.startsecs
+            too_quickly = now - self._last_start < self._config.start_secs
         else:
             too_quickly = False
             log.warning(
@@ -7647,8 +7744,8 @@ class ProcessImpl(Process):
         if self._supervisor_states.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
             if state == ProcessState.EXITED:
-                if self._config.autorestart:
-                    if self._config.autorestart is RestartUnconditionally:
+                if self._config.auto_restart:
+                    if self._config.auto_restart is RestartUnconditionally:
                         # EXITED -> STARTING
                         self.spawn()
                     elif self._exitstatus not in self._config.exitcodes:
@@ -7656,29 +7753,29 @@ class ProcessImpl(Process):
                         self.spawn()
 
             elif state == ProcessState.STOPPED and not self._last_start:
-                if self._config.autostart:
+                if self._config.auto_start:
                     # STOPPED -> STARTING
                     self.spawn()
 
             elif state == ProcessState.BACKOFF:
-                if self._backoff <= self._config.startretries:
+                if self._backoff <= self._config.start_retries:
                     if now > self._delay:
                         # BACKOFF -> STARTING
                         self.spawn()
 
         if state == ProcessState.STARTING:
-            if now - self._last_start > self._config.startsecs:
+            if now - self._last_start > self._config.start_secs:
                 # STARTING -> RUNNING if the proc has started successfully and it has stayed up for at least
-                # proc.config.startsecs,
+                # proc.config.start_secs,
                 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
+                msg = ('entered RUNNING state, process has stayed up for > than %s seconds (start_secs)' % self._config.start_secs)  # noqa
                 log.info('success: %s %s', self.name, msg)
 
         if state == ProcessState.BACKOFF:
-            if self._backoff > self._config.startretries:
+            if self._backoff > self._config.start_retries:
                 # BACKOFF -> FATAL if the proc has exceeded its number of retries
                 self.give_up()
                 msg = ('entered FATAL state, too many start retries too quickly')
@@ -7687,7 +7784,7 @@ class ProcessImpl(Process):
         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
+                # 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', self.name, self.pid)
                 self.kill(signal.SIGKILL)
@@ -8039,7 +8136,7 @@ class ProcessSpawningImpl(ProcessSpawning):
         else:
             os.dup2(check_not_none(pipes.child_stderr), 2)
 
-        for i in range(3, self._server_config.minfds):
+        for i in range(3, self._server_config.min_fds):
             if i in self._inherited_fds:
                 continue
             close_fd(Fd(i))
@@ -8229,11 +8326,29 @@ class Supervisor:
     #
 
     def _run_once(self) -> None:
-        now = time.time()
-        self._poll()
-        log.info(f'Poll took {time.time() - now}')  # noqa
+        if self._states.state < SupervisorState.RUNNING:
+            if not self._stopping:
+                # first time, set the stopping flag, do a notification and set stop_groups
+                self._stopping = True
+                self._stop_groups = sorted(self._process_groups)
+                self._event_callbacks.notify(SupervisorStoppingEvent())
+
+            self._ordered_stop_groups_phase_1()
+
+            if not self.shutdown_report():
+                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
+                raise ExitNow
+
+        self._io.poll()
+
+        for group in sorted(self._process_groups):
+            for process in group:
+                process.transition()
+
         self._reap()
+
         self._signal_handler.handle_signals()
+
         self._tick()
 
         if self._states.state < SupervisorState.RUNNING:
@@ -8255,38 +8370,18 @@ class Supervisor:
                 # down, so push it back on to the end of the stop group queue
                 self._stop_groups.append(group)
 
-    def _poll(self) -> None:
-        sorted_groups = list(self._process_groups)
-        sorted_groups.sort()
-
-        if self._states.state < SupervisorState.RUNNING:
-            if not self._stopping:
-                # first time, set the stopping flag, do a notification and set stop_groups
-                self._stopping = True
-                self._stop_groups = sorted_groups[:]
-                self._event_callbacks.notify(SupervisorStoppingEvent())
-
-            self._ordered_stop_groups_phase_1()
-
-            if not self.shutdown_report():
-                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
-                raise ExitNow
-
-        self._io.poll()
-
-        for group in sorted_groups:
-            for process in group:
-                process.transition()
+    #
 
     def _reap(self, *, once: bool = False, depth: int = 0) -> None:
         if depth >= 100:
             return
 
         wp = waitpid()
-        log.info(f'Waited pid: {wp}')  # noqa
+
         if wp is None or not wp.pid:
             return
 
+        log.info(f'Waited pid: {wp}')  # noqa
         process = self._pid_history.get(wp.pid, None)
         if process is None:
             _, msg = decode_wait_status(wp.sts)
@@ -8299,6 +8394,8 @@ class Supervisor:
             # keep reaping until no more kids to reap, but don't recurse infinitely
             self._reap(once=False, depth=depth + 1)
 
+    #
+
     def _tick(self, now: ta.Optional[float] = None) -> None:
         """Send one or more 'tick' events when the timeslice related to the period for the event type rolls over"""
 
@@ -8329,7 +8426,7 @@ class WaitedPid(ta.NamedTuple):
 
 
 def waitpid() -> ta.Optional[WaitedPid]:
-    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
+    # 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
     # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
@@ -8364,6 +8461,7 @@ class _FdIoPollerDaemonizeListener(DaemonizeListener):
 
 
 def bind_server(
+        exit_stack: contextlib.ExitStack,
         config: ServerConfig,
         *,
         server_epoch: ta.Optional[ServerEpoch] = None,
@@ -8372,6 +8470,8 @@ def bind_server(
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(config),
 
+        inj.bind(exit_stack),
+
         inj.bind_array(DaemonizeListener),
         inj.bind_array_type(DaemonizeListener, DaemonizeListeners),
 
@@ -8427,8 +8527,10 @@ def bind_server(
         PollFdIoPoller,
         SelectFdIoPoller,
     ]))
-    lst.append(inj.bind(poller_impl, key=FdIoPoller, singleton=True))
-    inj.bind(_FdIoPollerDaemonizeListener, array=True, singleton=True)
+    lst.extend([
+        inj.bind(poller_impl, key=FdIoPoller, singleton=True),
+        inj.bind(_FdIoPollerDaemonizeListener, array=True, singleton=True),
+    ])
 
     #
 
@@ -8497,18 +8599,20 @@ def main(
             prepare=prepare_server_config,
         )
 
-        injector = inj.create_injector(bind_server(
-            config,
-            server_epoch=ServerEpoch(epoch),
-            inherited_fds=inherited_fds,
-        ))
+        with contextlib.ExitStack() as es:
+            injector = inj.create_injector(bind_server(
+                es,
+                config,
+                server_epoch=ServerEpoch(epoch),
+                inherited_fds=inherited_fds,
+            ))
 
-        supervisor = injector[Supervisor]
+            supervisor = injector[Supervisor]
 
-        try:
-            supervisor.main()
-        except ExitNow:
-            pass
+            try:
+                supervisor.main()
+            except ExitNow:
+                pass
 
         if supervisor.state < SupervisorState.RESTARTING:
             break