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

ominfra/supervisor/poller.py

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

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

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

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

@@ -11,24 +11,25 @@ from omlish.lite.logs import log
 from omlish.lite.typing import Func1
 
 from .configs import ProcessConfig
-from .datatypes import RestartUnconditionally
+from .configs import RestartUnconditionally
 from .dispatchers import Dispatchers
 from .events import PROCESS_STATE_EVENT_MAP
 from .events import EventCallbacks
 from .pipes import ProcessPipes
 from .pipes import close_parent_pipes
-from .processes import ProcessStateError
-from .signals import sig_name
+from .process import ProcessStateError
 from .spawning import ProcessSpawnError
 from .spawning import ProcessSpawning
 from .states import ProcessState
 from .states import SupervisorState
-from .types import InputDispatcher
 from .types import Process
 from .types import ProcessGroup
-from .types import ServerContext
-from .utils import as_string
-from .utils import decode_wait_status
+from .types import ProcessInputDispatcher
+from .types import SupervisorStateManager
+from .utils.os import decode_wait_status
+from .utils.ostypes import Pid
+from .utils.ostypes import Rc
+from .utils.signals import sig_name
 
 
 class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
@@ -46,7 +47,7 @@ class ProcessImpl(Process):
             config: ProcessConfig,
             group: ProcessGroup,
             *,
-            context: ServerContext,
+            supervisor_states: SupervisorStateManager,
             event_callbacks: EventCallbacks,
             process_spawning_factory: ProcessSpawningFactory,
     ) -> None:
@@ -55,7 +56,7 @@ class ProcessImpl(Process):
         self._config = config
         self._group = group
 
-        self._context = context
+        self._supervisor_states = supervisor_states
         self._event_callbacks = event_callbacks
 
         self._spawning = process_spawning_factory(self)
@@ -66,7 +67,7 @@ class ProcessImpl(Process):
         self._pipes = ProcessPipes()
 
         self._state = ProcessState.STOPPED
-        self._pid = 0  # 0 when not running
+        self._pid = 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
@@ -80,13 +81,13 @@ class ProcessImpl(Process):
 
         self._backoff = 0  # backoff counter (to startretries)
 
-        self._exitstatus: ta.Optional[int] = None  # status attached to dead process by finish()
+        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
 
     #
 
     def __repr__(self) -> str:
-        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self.get_state().name}>'
+        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self._state.name}>'
 
     #
 
@@ -103,15 +104,11 @@ class ProcessImpl(Process):
         return self._group
 
     @property
-    def pid(self) -> int:
+    def pid(self) -> Pid:
         return self._pid
 
     #
 
-    @property
-    def context(self) -> ServerContext:
-        return self._context
-
     @property
     def state(self) -> ProcessState:
         return self._state
@@ -122,11 +119,9 @@ class ProcessImpl(Process):
 
     #
 
-    def spawn(self) -> ta.Optional[int]:
-        process_name = as_string(self._config.name)
-
+    def spawn(self) -> ta.Optional[Pid]:
         if self.pid:
-            log.warning('process \'%s\' already running', process_name)
+            log.warning('process \'%s\' already running', self.name)
             return None
 
         self.check_in_state(
@@ -176,7 +171,7 @@ class ProcessImpl(Process):
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
+        dispatcher = check_isinstance(self._dispatchers[stdin_fd], ProcessInputDispatcher)
         if dispatcher.closed:
             raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
@@ -249,7 +244,7 @@ class ProcessImpl(Process):
             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))
+                log.info('waiting for %s to stop', self.name)
                 self._last_stop_report = now
 
     def give_up(self) -> None:
@@ -269,18 +264,17 @@ class ProcessImpl(Process):
         """
         now = time.time()
 
-        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 == ProcessState.BACKOFF:
-            log.debug('Attempted to kill %s, which is in BACKOFF state.', process_name)
+            log.debug('Attempted to kill %s, which is in BACKOFF state.', self.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", (process_name, sig_name(sig))
+            fmt, args = "attempted to kill %s with sig %s but it wasn't running", (self.name, sig_name(sig))
             log.debug(fmt, *args)
             return fmt % args
 
@@ -294,7 +288,7 @@ class ProcessImpl(Process):
         if killasgroup:
             as_group = 'process group '
 
-        log.debug('killing %s (pid %s) %s with signal %s', process_name, self.pid, as_group, sig_name(sig))
+        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
@@ -303,24 +297,24 @@ class ProcessImpl(Process):
         self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
         self.change_state(ProcessState.STOPPING)
 
-        pid = self.pid
+        kpid = int(self.pid)
         if killasgroup:
             # send to the whole process group instead
-            pid = -self.pid
+            kpid = -kpid
 
         try:
             try:
-                os.kill(pid, sig)
+                os.kill(kpid, 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', process_name, self.pid, str(exc))  # noqa
+                    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
                     # processing.
                     return None
                 raise
         except Exception:  # noqa
             tb = traceback.format_exc()
-            fmt, args = 'unknown problem killing %s (%s):%s', (process_name, self.pid, tb)
+            fmt, args = 'unknown problem killing %s (%s):%s', (self.name, self.pid, tb)
             log.critical(fmt, *args)
             self.change_state(ProcessState.UNKNOWN)
             self._killing = False
@@ -336,14 +330,13 @@ class ProcessImpl(Process):
         Return None if the signal was sent, or an error message string if an error occurred or if the subprocess is not
         running.
         """
-        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", (process_name, sig_name(sig))
+            fmt, args = "Attempted to send %s sig %s but it wasn't running", (self.name, sig_name(sig))
             log.debug(fmt, *args)
             return fmt % args
 
-        log.debug('sending %s (pid %s) sig %s', process_name, self.pid, sig_name(sig))
+        log.debug('sending %s (pid %s) sig %s', self.name, self.pid, sig_name(sig))
 
         self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
 
@@ -354,7 +347,7 @@ class ProcessImpl(Process):
                 if exc.errno == errno.ESRCH:
                     log.debug(
                         'unable to signal %s (pid %s), it probably just now exited on its own: %s',
-                        process_name,
+                        self.name,
                         self.pid,
                         str(exc),
                     )
@@ -364,14 +357,14 @@ class ProcessImpl(Process):
                 raise
         except Exception:  # noqa
             tb = traceback.format_exc()
-            fmt, args = 'unknown problem sending sig %s (%s):%s', (process_name, self.pid, tb)
+            fmt, args = 'unknown problem sending sig %s (%s):%s', (self.name, self.pid, tb)
             log.critical(fmt, *args)
             self.change_state(ProcessState.UNKNOWN)
             return fmt % args
 
         return None
 
-    def finish(self, sts: int) -> None:
+    def finish(self, sts: Rc) -> None:
         """The process was reaped and we need to report and manage its state."""
 
         self._dispatchers.drain()
@@ -383,7 +376,6 @@ class ProcessImpl(Process):
         self._check_and_adjust_for_system_clock_rollback(now)
 
         self._last_stop = now
-        process_name = as_string(self._config.name)
 
         if now > self._last_start:
             too_quickly = now - self._last_start < self._config.startsecs
@@ -392,7 +384,7 @@ class ProcessImpl(Process):
             log.warning(
                 "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",
-                process_name,
+                self.name,
                 self.pid,
             )
 
@@ -402,9 +394,9 @@ class ProcessImpl(Process):
             # likely the result of a stop request implies STOPPING -> STOPPED
             self._killing = False
             self._delay = 0
-            self._exitstatus = es
+            self._exitstatus = Rc(es)
 
-            fmt, args = 'stopped: %s (%s)', (process_name, msg)
+            fmt, args = 'stopped: %s (%s)', (self.name, msg)
             self.check_in_state(ProcessState.STOPPING)
             self.change_state(ProcessState.STOPPED)
             if exit_expected:
@@ -418,7 +410,7 @@ class ProcessImpl(Process):
             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')
+            log.warning('exited: %s (%s)', self.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
@@ -437,21 +429,18 @@ class ProcessImpl(Process):
             if exit_expected:
                 # expected exit code
                 self.change_state(ProcessState.EXITED, expected=True)
-                log.info('exited: %s (%s)', process_name, msg + '; expected')
+                log.info('exited: %s (%s)', self.name, msg + '; expected')
             else:
                 # unexpected exit code
                 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')
+                log.warning('exited: %s (%s)', self.name, msg + '; not expected')
 
-        self._pid = 0
+        self._pid = Pid(0)
         close_parent_pipes(self._pipes)
         self._pipes = ProcessPipes()
         self._dispatchers = Dispatchers([])
 
-    def get_state(self) -> ProcessState:
-        return self._state
-
     def transition(self) -> None:
         now = time.time()
         state = self._state
@@ -460,7 +449,7 @@ class ProcessImpl(Process):
 
         logger = log
 
-        if self.context.state > SupervisorState.RESTARTING:
+        if self._supervisor_states.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
             if state == ProcessState.EXITED:
                 if self._config.autorestart:
@@ -482,7 +471,6 @@ class ProcessImpl(Process):
                         # BACKOFF -> STARTING
                         self.spawn()
 
-        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
@@ -492,21 +480,21 @@ class ProcessImpl(Process):
                 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)
+                logger.info('success: %s %s', self.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', process_name, msg)
+                logger.info('gave up: %s %s', self.name, msg)
 
         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', process_name, self.pid)
+                log.warning('killing \'%s\' (%s) with SIGKILL', self.name, self.pid)
                 self.kill(signal.SIGKILL)
 
     def after_setuid(self) -> None:

ominfra/supervisor/setup.py

@@ -2,7 +2,7 @@
 import abc
 import typing as ta
 
-from .users import User
+from .utils.users import User
 
 
 ##

ominfra/supervisor/setupimpl.py

@@ -14,8 +14,9 @@ from .setup import DaemonizeListeners
 from .setup import SupervisorSetup
 from .setup import SupervisorUser
 from .types import ServerEpoch
-from .utils import real_exit
-from .utils import try_unlink
+from .utils.fs import try_unlink
+from .utils.os import real_exit
+from .utils.ostypes import Rc
 
 
 ##
@@ -238,7 +239,7 @@ class SupervisorSetupImpl(SupervisorSetup):
         if pid != 0:
             # Parent
             log.debug('supervisord forked; parent exiting')
-            real_exit(0)
+            real_exit(Rc(0))
 
         # Child
         log.info('daemonizing the supervisord process')

ominfra/supervisor/signals.py

@@ -1,60 +1,66 @@
 # ruff: noqa: UP006 UP007
 import signal
-import typing as ta
 
+from omlish.lite.logs import log
 
-##
+from .groups import ProcessGroupManager
+from .states import SupervisorState
+from .types import ProcessOutputDispatcher
+from .types import SupervisorStateManager
+from .utils.signals import SignalReceiver
+from .utils.signals import sig_name
 
 
-_SIGS_BY_NUM: ta.Mapping[int, signal.Signals] = {s.value: s for s in signal.Signals}
-_SIGS_BY_NAME: ta.Mapping[str, signal.Signals] = {s.name: s for s in signal.Signals}
-
-
-def sig_num(value: ta.Union[int, str]) -> int:
-    try:
-        num = int(value)
-
-    except (ValueError, TypeError):
-        name = value.strip().upper()  # type: ignore
-        if not name.startswith('SIG'):
-            name = f'SIG{name}'
-
-        if (sn := _SIGS_BY_NAME.get(name)) is None:
-            raise ValueError(f'value {value!r} is not a valid signal name')  # noqa
-        num = sn
-
-    if num not in _SIGS_BY_NUM:
-        raise ValueError(f'value {value!r} is not a valid signal number')
-
-    return num
-
-
-def sig_name(num: int) -> str:
-    if (sig := _SIGS_BY_NUM.get(num)) is not None:
-        return sig.name
-    return f'signal {sig}'
-
-
-##
-
-
-class SignalReceiver:
-    def __init__(self) -> None:
+class SignalHandler:
+    def __init__(
+            self,
+            *,
+            states: SupervisorStateManager,
+            signal_receiver: SignalReceiver,
+            process_groups: ProcessGroupManager,
+    ) -> None:
         super().__init__()
 
-        self._signals_recvd: ta.List[int] = []
-
-    def receive(self, sig: int, frame: ta.Any = None) -> None:
-        if sig not in self._signals_recvd:
-            self._signals_recvd.append(sig)
-
-    def install(self, *sigs: int) -> None:
-        for sig in sigs:
-            signal.signal(sig, self.receive)
+        self._states = states
+        self._signal_receiver = signal_receiver
+        self._process_groups = process_groups
+
+    def set_signals(self) -> None:
+        self._signal_receiver.install(
+            signal.SIGTERM,
+            signal.SIGINT,
+            signal.SIGQUIT,
+            signal.SIGHUP,
+            signal.SIGCHLD,
+            signal.SIGUSR2,
+        )
+
+    def handle_signals(self) -> None:
+        sig = self._signal_receiver.get_signal()
+        if not sig:
+            return
+
+        if sig in (signal.SIGTERM, signal.SIGINT, signal.SIGQUIT):
+            log.warning('received %s indicating exit request', sig_name(sig))
+            self._states.set_state(SupervisorState.SHUTDOWN)
+
+        elif sig == signal.SIGHUP:
+            if self._states.state == SupervisorState.SHUTDOWN:
+                log.warning('ignored %s indicating restart request (shutdown in progress)', sig_name(sig))  # noqa
+            else:
+                log.warning('received %s indicating restart request', sig_name(sig))  # noqa
+                self._states.set_state(SupervisorState.RESTARTING)
+
+        elif sig == signal.SIGCHLD:
+            log.debug('received %s indicating a child quit', sig_name(sig))
+
+        elif sig == signal.SIGUSR2:
+            log.info('received %s indicating log reopen request', sig_name(sig))
+
+            for p in self._process_groups.all_processes():
+                for d in p.get_dispatchers():
+                    if isinstance(d, ProcessOutputDispatcher):
+                        d.reopen_logs()
 
-    def get_signal(self) -> ta.Optional[int]:
-        if self._signals_recvd:
-            sig = self._signals_recvd.pop(0)
         else:
-            sig = None
-        return sig
+            log.debug('received %s indicating nothing', sig_name(sig))