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

ominfra/supervisor/configs.py

@@ -37,32 +37,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,)
 
@@ -87,14 +87,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
@@ -107,7 +107,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,
@@ -117,7 +117,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(),

ominfra/supervisor/dispatchersimpl.py

@@ -13,6 +13,7 @@ from .events import EventCallbacks
 from .events import ProcessCommunicationEvent
 from .events import ProcessLogStderrEvent
 from .events import ProcessLogStdoutEvent
+from .events import ProcessOutputChannel
 from .types import Process
 from .types import ProcessDispatcher
 from .types import ProcessInputDispatcher
@@ -29,7 +30,7 @@ class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def __init__(
             self,
             process: Process,
-            channel: str,
+            channel: ProcessOutputChannel,
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
@@ -57,7 +58,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:
@@ -147,7 +148,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
 
@@ -159,8 +160,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,
         #     )
 
@@ -172,17 +173,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:
@@ -295,7 +296,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()
 
@@ -304,7 +305,7 @@ class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatch
     def __init__(
             self,
             process: Process,
-            channel: str,
+            channel: ProcessOutputChannel,
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,

ominfra/supervisor/events.py

@@ -8,6 +8,9 @@ from .states import ProcessState
 EventCallback = ta.Callable[['Event'], None]
 
 
+ProcessOutputChannel = ta.Literal['stdout', 'stderr']  # ta.TypeAlias
+
+
 ##
 
 
@@ -43,7 +46,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__()
@@ -68,7 +71,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__()

ominfra/supervisor/http.py

@@ -1,9 +1,11 @@
 # ruff: noqa: U006 UP007
+import contextlib
 import json
 import socket
 import typing as ta
 
 from omlish.lite.check import check_not_none
+from omlish.lite.contextmanagers import defer
 from omlish.lite.fdio.corohttp import CoroHttpServerConnectionFdIoHandler
 from omlish.lite.fdio.handlers import SocketFdIoHandler
 from omlish.lite.http.handlers import HttpHandler
@@ -59,6 +61,8 @@ class HttpServer(HasDispatchers):
             self,
             handler: Handler,
             addr: Address = Address(('localhost', 8000)),
+            *,
+            exit_stack: contextlib.ExitStack,
     ) -> None:
         super().__init__()
 
@@ -69,6 +73,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:
@@ -113,6 +119,7 @@ class SupervisorHttpHandler:
                     'processes': {
                         p.name: {
                             'pid': p.pid,
+                            'state': p.state.name,
                         }
                         for p in g
                     },

ominfra/supervisor/inject.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+import contextlib
 import dataclasses as dc
 import typing as ta
 
@@ -56,6 +57,7 @@ class _FdIoPollerDaemonizeListener(DaemonizeListener):
 
 
 def bind_server(
+        exit_stack: contextlib.ExitStack,
         config: ServerConfig,
         *,
         server_epoch: ta.Optional[ServerEpoch] = None,
@@ -64,6 +66,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),
 
@@ -119,8 +123,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),
+    ])
 
     #
 

ominfra/supervisor/io.py

@@ -44,9 +44,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:

ominfra/supervisor/main.py

@@ -29,6 +29,7 @@
 #   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 #   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 #   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import contextlib
 import itertools
 import os.path
 import typing as ta
@@ -96,18 +97,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

ominfra/supervisor/pipes.py

@@ -29,8 +29,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]] = {

ominfra/supervisor/privileges.py

@@ -7,9 +7,8 @@ import typing as ta
 
 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:
@@ -33,9 +32,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:

ominfra/supervisor/processimpl.py

@@ -79,7 +79,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
@@ -156,7 +156,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
 
@@ -214,17 +214,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):
@@ -233,7 +233,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."""
@@ -256,7 +256,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
@@ -264,8 +264,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)
@@ -280,25 +280,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
 
@@ -308,7 +308,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
@@ -351,7 +351,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
@@ -378,8 +378,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(
@@ -451,8 +450,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:
@@ -460,29 +459,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')
@@ -491,7 +490,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)

ominfra/supervisor/setupimpl.py

@@ -77,21 +77,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:
@@ -105,8 +105,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 = []
@@ -115,12 +115,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',
             })
@@ -130,11 +130,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',
             })
@@ -220,11 +220,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
@@ -256,7 +256,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)

ominfra/supervisor/spawningimpl.py

@@ -316,7 +316,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))

ominfra/supervisor/states.py

@@ -27,6 +27,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,