ominfra 0.0.0.dev118__py3-none-any.whl → 0.0.0.dev120__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -2,12 +2,13 @@
 # noinspection DuplicatedCode
 # @omlish-lite
 # @omlish-script
-# @omlish-amalg-output ../supervisor/supervisor.py
-# ruff: noqa: N802 UP006 UP007 UP036
+# @omlish-amalg-output ../supervisor/main.py
+# ruff: noqa: N802 UP006 UP007 UP012 UP036
 import abc
 import base64
 import collections.abc
 import contextlib
+import ctypes as ct
 import dataclasses as dc
 import datetime
 import decimal
@@ -17,9 +18,11 @@ import fcntl
 import fractions
 import functools
 import grp
+import itertools
 import json
 import logging
 import os
+import os.path
 import pwd
 import re
 import resource
@@ -28,6 +31,7 @@ import shlex
 import signal
 import stat
 import sys
+import syslog
 import tempfile
 import threading
 import time
@@ -466,240 +470,28 @@ class NoPermissionError(ProcessError):
 
 
 ########################################
-# ../poller.py
-
-
-log = logging.getLogger(__name__)
-
-
-class BasePoller(abc.ABC):
-
-    def __init__(self) -> None:
-        super().__init__()
-
-    @abc.abstractmethod
-    def register_readable(self, fd: int) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def register_writable(self, fd: int) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unregister_readable(self, fd: int) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unregister_writable(self, fd: int) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
-        raise NotImplementedError
-
-    def before_daemonize(self) -> None:  # noqa
-        pass
-
-    def after_daemonize(self) -> None:  # noqa
-        pass
-
-    def close(self) -> None:  # noqa
-        pass
-
-
-class SelectPoller(BasePoller):
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._readables: ta.Set[int] = set()
-        self._writables: ta.Set[int] = set()
-
-    def register_readable(self, fd: int) -> None:
-        self._readables.add(fd)
-
-    def register_writable(self, fd: int) -> None:
-        self._writables.add(fd)
-
-    def unregister_readable(self, fd: int) -> None:
-        self._readables.discard(fd)
-
-    def unregister_writable(self, fd: int) -> None:
-        self._writables.discard(fd)
-
-    def unregister_all(self) -> None:
-        self._readables.clear()
-        self._writables.clear()
+# ../../../omlish/lite/cached.py
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
-        try:
-            r, w, x = select.select(
-                self._readables,
-                self._writables,
-                [], timeout,
-            )
-        except OSError as err:
-            if err.args[0] == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return [], []
-            if err.args[0] == errno.EBADF:
-                log.debug('EBADF encountered in poll')
-                self.unregister_all()
-                return [], []
-            raise
-        return r, w
-
-
-class PollPoller(BasePoller):
-    _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
-    _WRITE = select.POLLOUT
 
-    def __init__(self) -> None:
+class _cached_nullary:  # noqa
+    def __init__(self, fn):
         super().__init__()
+        self._fn = fn
+        self._value = self._missing = object()
+        functools.update_wrapper(self, fn)
 
-        self._poller = select.poll()
-        self._readables: set[int] = set()
-        self._writables: set[int] = set()
-
-    def register_readable(self, fd: int) -> None:
-        self._poller.register(fd, self._READ)
-        self._readables.add(fd)
-
-    def register_writable(self, fd: int) -> None:
-        self._poller.register(fd, self._WRITE)
-        self._writables.add(fd)
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
 
-    def unregister_readable(self, fd: int) -> None:
-        self._readables.discard(fd)
-        self._poller.unregister(fd)
-        if fd in self._writables:
-            self._poller.register(fd, self._WRITE)
+    def __get__(self, instance, owner):  # noqa
+        bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
+        return bound
 
-    def unregister_writable(self, fd: int) -> None:
-        self._writables.discard(fd)
-        self._poller.unregister(fd)
-        if fd in self._readables:
-            self._poller.register(fd, self._READ)
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
-        fds = self._poll_fds(timeout)  # type: ignore
-        readables, writables = [], []
-        for fd, eventmask in fds:
-            if self._ignore_invalid(fd, eventmask):
-                continue
-            if eventmask & self._READ:
-                readables.append(fd)
-            if eventmask & self._WRITE:
-                writables.append(fd)
-        return readables, writables
-
-    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[int, int]]:
-        try:
-            return self._poller.poll(timeout * 1000)
-        except OSError as err:
-            if err.args[0] == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return []
-            raise
-
-    def _ignore_invalid(self, fd: int, 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.
-            self._poller.unregister(fd)
-            self._readables.discard(fd)
-            self._writables.discard(fd)
-            return True
-        return False
-
-
-if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
-    class KqueuePoller(BasePoller):
-        max_events = 1000
-
-        def __init__(self) -> None:
-            super().__init__()
-
-            self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-            self._readables: set[int] = set()
-            self._writables: set[int] = set()
-
-        def register_readable(self, fd: int) -> None:
-            self._readables.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:
-            self._writables.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:
-            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
-            self._readables.discard(fd)
-            self._kqueue_control(fd, kevent)
-
-        def unregister_writable(self, fd: int) -> None:
-            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
-            self._writables.discard(fd)
-            self._kqueue_control(fd, kevent)
-
-        def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
-            try:
-                self._kqueue.control([kevent], 0)  # type: ignore
-            except OSError as error:
-                if error.errno == errno.EBADF:
-                    log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
-                else:
-                    raise
-
-        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
-            readables, writables = [], []  # type: ignore
-
-            try:
-                kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
-            except OSError as error:
-                if error.errno == errno.EINTR:
-                    log.debug('EINTR encountered in poll')
-                    return readables, writables
-                raise
-
-            for kevent in kevents:
-                if kevent.filter == select.KQ_FILTER_READ:
-                    readables.append(kevent.ident)
-                if kevent.filter == select.KQ_FILTER_WRITE:
-                    writables.append(kevent.ident)
-
-            return readables, writables
-
-        def before_daemonize(self) -> None:
-            self.close()
-
-        def after_daemonize(self) -> None:
-            self._kqueue = select.kqueue()
-            for fd in self._readables:
-                self.register_readable(fd)
-            for fd in self._writables:
-                self.register_writable(fd)
-
-        def close(self) -> None:
-            self._kqueue.close()  # type: ignore
-            self._kqueue = None
-
-else:
-    KqueuePoller = None
-
-
-Poller: ta.Type[BasePoller]
-if (
-        sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
-        hasattr(select, 'kqueue') and KqueuePoller is not None
-):
-    Poller = KqueuePoller
-elif hasattr(select, 'poll'):
-    Poller = PollPoller
-else:
-    Poller = SelectPoller
+def cached_nullary(fn: ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _cached_nullary(fn)
 
 
 ########################################
@@ -1012,6 +804,164 @@ def get_supervisor_state_description(code: SupervisorState) -> str:
     return check_not_none(_supervisor_states_by_code.get(code))
 
 
+########################################
+# ../../../omlish/lite/journald.py
+
+
+##
+
+
+class sd_iovec(ct.Structure):  # noqa
+    pass
+
+
+sd_iovec._fields_ = [
+    ('iov_base', ct.c_void_p),  # Pointer to data.
+    ('iov_len', ct.c_size_t),  # Length of data.
+]
+
+
+##
+
+
+@cached_nullary
+def sd_libsystemd() -> ta.Any:
+    lib = ct.CDLL('libsystemd.so.0')
+
+    lib.sd_journal_sendv = lib['sd_journal_sendv']  # type: ignore
+    lib.sd_journal_sendv.restype = ct.c_int
+    lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
+
+    return lib
+
+
+@cached_nullary
+def sd_try_libsystemd() -> ta.Optional[ta.Any]:
+    try:
+        return sd_libsystemd()
+    except OSError:  # noqa
+        return None
+
+
+##
+
+
+def sd_journald_send(**fields: str) -> int:
+    lib = sd_libsystemd()
+
+    msgs = [
+        f'{k.upper()}={v}\0'.encode('utf-8')
+        for k, v in fields.items()
+    ]
+
+    vec = (sd_iovec * len(msgs))()
+    cl = (ct.c_char_p * len(msgs))()  # noqa
+    for i in range(len(msgs)):
+        vec[i].iov_base = ct.cast(ct.c_char_p(msgs[i]), ct.c_void_p)
+        vec[i].iov_len = len(msgs[i]) - 1
+
+    return lib.sd_journal_sendv(vec, len(msgs))
+
+
+##
+
+
+SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
+    logging.FATAL: syslog.LOG_EMERG,  # system is unusable
+    # LOG_ALERT ?  # action must be taken immediately
+    logging.CRITICAL: syslog.LOG_CRIT,
+    logging.ERROR: syslog.LOG_ERR,
+    logging.WARNING: syslog.LOG_WARNING,
+    # LOG_NOTICE ?  # normal but significant condition
+    logging.INFO: syslog.LOG_INFO,
+    logging.DEBUG: syslog.LOG_DEBUG,
+}
+
+
+class JournaldLogHandler(logging.Handler):
+    """
+    TODO:
+     - fallback handler for when this barfs
+    """
+
+    def __init__(
+            self,
+            *,
+            use_formatter_output: bool = False,
+    ) -> None:
+        super().__init__()
+
+        sd_libsystemd()
+
+        self._use_formatter_output = use_formatter_output
+
+    #
+
+    EXTRA_RECORD_ATTRS_BY_JOURNALD_FIELD: ta.ClassVar[ta.Mapping[str, str]] = {
+        'name': 'name',
+        'module': 'module',
+        'exception': 'exc_text',
+        'thread_name': 'threadName',
+        'task_name': 'taskName',
+    }
+
+    def make_fields(self, record: logging.LogRecord) -> ta.Mapping[str, str]:
+        formatter_message = self.format(record)
+        if self._use_formatter_output:
+            message = formatter_message
+        else:
+            message = record.message
+
+        fields: dict[str, str] = {
+            'message': message,
+            'priority': str(SD_LOG_LEVEL_MAP[record.levelno]),
+            'tid': str(threading.get_ident()),
+        }
+
+        if (pathname := record.pathname) is not None:
+            fields['code_file'] = pathname
+        if (lineno := record.lineno) is not None:
+            fields['code_lineno'] = str(lineno)
+        if (func_name := record.funcName) is not None:
+            fields['code_func'] = func_name
+
+        for f, a in self.EXTRA_RECORD_ATTRS_BY_JOURNALD_FIELD.items():
+            if (v := getattr(record, a, None)) is not None:
+                fields[f] = str(v)
+
+        return fields
+
+    #
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            fields = self.make_fields(record)
+
+            if rc := sd_journald_send(**fields):
+                raise RuntimeError(f'{self.__class__.__name__}.emit failed: {rc=}')  # noqa
+
+        except RecursionError:  # See issue 36272
+            raise
+
+        except Exception:  # noqa
+            self.handleError(record)
+
+
+def journald_log_handler_factory(
+        *,
+        no_tty_check: bool = False,
+        no_fallback: bool = False,
+) -> logging.Handler:
+    if (
+            sys.platform == 'linux' and
+            (no_tty_check or not sys.stderr.isatty()) and
+            (no_fallback or sd_try_libsystemd() is not None)
+    ):
+        return JournaldLogHandler()
+
+    return logging.StreamHandler()
+
+
 ########################################
 # ../../../omlish/lite/logs.py
 """
@@ -1099,7 +1049,7 @@ class StandardLogFormatter(logging.Formatter):
         if datefmt:
             return ct.strftime(datefmt)  # noqa
         else:
-            t = ct.strftime("%Y-%m-%d %H:%M:%S")  # noqa
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
             return '%s.%03d' % (t, record.msecs)
 
 
@@ -1236,6 +1186,7 @@ def configure_standard_logging(
         json: bool = False,
         target: ta.Optional[logging.Logger] = None,
         force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
 ) -> ta.Optional[StandardLogHandler]:
     with _locking_logging_module_lock():
         if target is None:
@@ -1249,7 +1200,10 @@ def configure_standard_logging(
 
         #
 
-        handler = logging.StreamHandler()
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
 
         #
 
@@ -1649,12 +1603,9 @@ class EventCallbacks:
 
 EVENT_CALLBACKS = EventCallbacks()
 
-notify_event = EVENT_CALLBACKS.notify
-clear_events = EVENT_CALLBACKS.clear
-
 
 class Event(abc.ABC):  # noqa
-    """Abstract event type """
+    """Abstract event type."""
 
 
 class ProcessLogEvent(Event, abc.ABC):
@@ -1734,7 +1685,7 @@ class RemoteCommunicationEvent(Event):
 
 
 class SupervisorStateChangeEvent(Event):
-    """ Abstract class """
+    """Abstract class."""
 
     def payload(self):
         return ''
@@ -1756,7 +1707,7 @@ class EventRejectedEvent:  # purposely does not subclass Event
 
 
 class ProcessStateEvent(Event):
-    """ Abstract class, never raised directly """
+    """Abstract class, never raised directly."""
     frm = None
     to = None
 
@@ -1845,7 +1796,7 @@ class ProcessGroupRemovedEvent(ProcessGroupEvent):
 
 
 class TickEvent(Event):
-    """ Abstract """
+    """Abstract."""
 
     def __init__(self, when, supervisord):
         super().__init__()
@@ -1888,39 +1839,273 @@ class EventTypes:
     PROCESS_STATE_RUNNING = ProcessStateRunningEvent
     PROCESS_STATE_UNKNOWN = ProcessStateUnknownEvent
 
-    PROCESS_COMMUNICATION = ProcessCommunicationEvent  # abstract
-    PROCESS_COMMUNICATION_STDOUT = ProcessCommunicationStdoutEvent
-    PROCESS_COMMUNICATION_STDERR = ProcessCommunicationStderrEvent
+    PROCESS_COMMUNICATION = ProcessCommunicationEvent  # abstract
+    PROCESS_COMMUNICATION_STDOUT = ProcessCommunicationStdoutEvent
+    PROCESS_COMMUNICATION_STDERR = ProcessCommunicationStderrEvent
+
+    PROCESS_LOG = ProcessLogEvent
+    PROCESS_LOG_STDOUT = ProcessLogStdoutEvent
+    PROCESS_LOG_STDERR = ProcessLogStderrEvent
+
+    REMOTE_COMMUNICATION = RemoteCommunicationEvent
+
+    SUPERVISOR_STATE_CHANGE = SupervisorStateChangeEvent  # abstract
+    SUPERVISOR_STATE_CHANGE_RUNNING = SupervisorRunningEvent
+    SUPERVISOR_STATE_CHANGE_STOPPING = SupervisorStoppingEvent
+
+    TICK = TickEvent  # abstract
+    TICK_5 = Tick5Event
+    TICK_60 = Tick60Event
+    TICK_3600 = Tick3600Event
+
+    PROCESS_GROUP = ProcessGroupEvent  # abstract
+    PROCESS_GROUP_ADDED = ProcessGroupAddedEvent
+    PROCESS_GROUP_REMOVED = ProcessGroupRemovedEvent
+
+
+def get_event_name_by_type(requested):
+    for name, typ in EventTypes.__dict__.items():
+        if typ is requested:
+            return name
+    return None
+
+
+def register(name, event):
+    setattr(EventTypes, name, event)
+
+
+########################################
+# ../poller.py
+
+
+class BasePoller(abc.ABC):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @abc.abstractmethod
+    def register_readable(self, fd: int) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def register_writable(self, fd: int) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def unregister_readable(self, fd: int) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def unregister_writable(self, fd: int) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+        raise NotImplementedError
+
+    def before_daemonize(self) -> None:  # noqa
+        pass
+
+    def after_daemonize(self) -> None:  # noqa
+        pass
+
+    def close(self) -> None:  # noqa
+        pass
+
+
+class SelectPoller(BasePoller):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._readables: ta.Set[int] = set()
+        self._writables: ta.Set[int] = set()
+
+    def register_readable(self, fd: int) -> None:
+        self._readables.add(fd)
+
+    def register_writable(self, fd: int) -> None:
+        self._writables.add(fd)
+
+    def unregister_readable(self, fd: int) -> None:
+        self._readables.discard(fd)
+
+    def unregister_writable(self, fd: int) -> None:
+        self._writables.discard(fd)
+
+    def unregister_all(self) -> None:
+        self._readables.clear()
+        self._writables.clear()
+
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+        try:
+            r, w, x = select.select(
+                self._readables,
+                self._writables,
+                [], timeout,
+            )
+        except OSError as err:
+            if err.args[0] == errno.EINTR:
+                log.debug('EINTR encountered in poll')
+                return [], []
+            if err.args[0] == errno.EBADF:
+                log.debug('EBADF encountered in poll')
+                self.unregister_all()
+                return [], []
+            raise
+        return r, w
+
+
+class PollPoller(BasePoller):
+    _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
+    _WRITE = select.POLLOUT
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._poller = select.poll()
+        self._readables: set[int] = set()
+        self._writables: set[int] = set()
+
+    def register_readable(self, fd: int) -> None:
+        self._poller.register(fd, self._READ)
+        self._readables.add(fd)
+
+    def register_writable(self, fd: int) -> None:
+        self._poller.register(fd, self._WRITE)
+        self._writables.add(fd)
+
+    def unregister_readable(self, fd: int) -> None:
+        self._readables.discard(fd)
+        self._poller.unregister(fd)
+        if fd in self._writables:
+            self._poller.register(fd, self._WRITE)
+
+    def unregister_writable(self, fd: int) -> None:
+        self._writables.discard(fd)
+        self._poller.unregister(fd)
+        if fd in self._readables:
+            self._poller.register(fd, self._READ)
+
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+        fds = self._poll_fds(timeout)  # type: ignore
+        readables, writables = [], []
+        for fd, eventmask in fds:
+            if self._ignore_invalid(fd, eventmask):
+                continue
+            if eventmask & self._READ:
+                readables.append(fd)
+            if eventmask & self._WRITE:
+                writables.append(fd)
+        return readables, writables
+
+    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[int, int]]:
+        try:
+            return self._poller.poll(timeout * 1000)
+        except OSError as err:
+            if err.args[0] == errno.EINTR:
+                log.debug('EINTR encountered in poll')
+                return []
+            raise
+
+    def _ignore_invalid(self, fd: int, 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.
+            self._poller.unregister(fd)
+            self._readables.discard(fd)
+            self._writables.discard(fd)
+            return True
+        return False
+
+
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+    class KqueuePoller(BasePoller):
+        max_events = 1000
+
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._kqueue: ta.Optional[ta.Any] = select.kqueue()
+            self._readables: set[int] = set()
+            self._writables: set[int] = set()
+
+        def register_readable(self, fd: int) -> None:
+            self._readables.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:
+            self._writables.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:
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
+            self._readables.discard(fd)
+            self._kqueue_control(fd, kevent)
+
+        def unregister_writable(self, fd: int) -> None:
+            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
+            self._writables.discard(fd)
+            self._kqueue_control(fd, kevent)
+
+        def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
+            try:
+                self._kqueue.control([kevent], 0)  # type: ignore
+            except OSError as error:
+                if error.errno == errno.EBADF:
+                    log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
+                else:
+                    raise
+
+        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+            readables, writables = [], []  # type: ignore
 
-    PROCESS_LOG = ProcessLogEvent
-    PROCESS_LOG_STDOUT = ProcessLogStdoutEvent
-    PROCESS_LOG_STDERR = ProcessLogStderrEvent
+            try:
+                kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
+            except OSError as error:
+                if error.errno == errno.EINTR:
+                    log.debug('EINTR encountered in poll')
+                    return readables, writables
+                raise
 
-    REMOTE_COMMUNICATION = RemoteCommunicationEvent
+            for kevent in kevents:
+                if kevent.filter == select.KQ_FILTER_READ:
+                    readables.append(kevent.ident)
+                if kevent.filter == select.KQ_FILTER_WRITE:
+                    writables.append(kevent.ident)
 
-    SUPERVISOR_STATE_CHANGE = SupervisorStateChangeEvent  # abstract
-    SUPERVISOR_STATE_CHANGE_RUNNING = SupervisorRunningEvent
-    SUPERVISOR_STATE_CHANGE_STOPPING = SupervisorStoppingEvent
+            return readables, writables
 
-    TICK = TickEvent  # abstract
-    TICK_5 = Tick5Event
-    TICK_60 = Tick60Event
-    TICK_3600 = Tick3600Event
+        def before_daemonize(self) -> None:
+            self.close()
 
-    PROCESS_GROUP = ProcessGroupEvent  # abstract
-    PROCESS_GROUP_ADDED = ProcessGroupAddedEvent
-    PROCESS_GROUP_REMOVED = ProcessGroupRemovedEvent
+        def after_daemonize(self) -> None:
+            self._kqueue = select.kqueue()
+            for fd in self._readables:
+                self.register_readable(fd)
+            for fd in self._writables:
+                self.register_writable(fd)
 
+        def close(self) -> None:
+            self._kqueue.close()  # type: ignore
+            self._kqueue = None
 
-def get_event_name_by_type(requested):
-    for name, typ in EventTypes.__dict__.items():
-        if typ is requested:
-            return name
-    return None
+else:
+    KqueuePoller = None
 
 
-def register(name, event):
-    setattr(EventTypes, name, event)
+Poller: ta.Type[BasePoller]
+if (
+        sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
+        hasattr(select, 'kqueue') and KqueuePoller is not None
+):
+    Poller = KqueuePoller
+elif hasattr(select, 'poll'):
+    Poller = PollPoller
+else:
+    Poller = SelectPoller
 
 
 ########################################
@@ -1973,41 +2158,47 @@ class AbstractSubprocess(abc.ABC):
 # ../context.py
 
 
-log = logging.getLogger(__name__)
-
-
 class ServerContext(AbstractServerContext):
-    first = False
-    test = False
-
-    ##
-
-    def __init__(self, config: ServerConfig) -> None:
+    def __init__(
+            self,
+            config: ServerConfig,
+            *,
+            epoch: int = 0,
+    ) -> None:
         super().__init__()
 
         self._config = config
+        self._epoch = epoch
 
         self._pid_history: ta.Dict[int, AbstractSubprocess] = {}
         self._state: SupervisorState = SupervisorStates.RUNNING
 
-        self.signal_receiver = SignalReceiver()
+        self._signal_receiver = SignalReceiver()
 
-        self.poller = Poller()
+        self._poller: BasePoller = Poller()
 
-        if self.config.user is not None:
-            uid = name_to_uid(self.config.user)
-            self.uid = uid
-            self.gid = gid_for_uid(uid)
+        if config.user is not None:
+            uid = name_to_uid(config.user)
+            self._uid: ta.Optional[int] = uid
+            self._gid: ta.Optional[int] = gid_for_uid(uid)
         else:
-            self.uid = None
-            self.gid = None
+            self._uid = None
+            self._gid = None
 
-        self.unlink_pidfile = False
+        self._unlink_pidfile = False
 
     @property
     def config(self) -> ServerConfig:
         return self._config
 
+    @property
+    def epoch(self) -> int:
+        return self._epoch
+
+    @property
+    def first(self) -> bool:
+        return not self._epoch
+
     @property
     def state(self) -> SupervisorState:
         return self._state
@@ -2015,17 +2206,26 @@ class ServerContext(AbstractServerContext):
     def set_state(self, state: SupervisorState) -> None:
         self._state = state
 
+    @property
+    def poller(self) -> BasePoller:
+        return self._poller
+
     @property
     def pid_history(self) -> ta.Dict[int, AbstractSubprocess]:
         return self._pid_history
 
-    uid: ta.Optional[int]
-    gid: ta.Optional[int]
+    @property
+    def uid(self) -> ta.Optional[int]:
+        return self._uid
+
+    @property
+    def gid(self) -> ta.Optional[int]:
+        return self._gid
 
     ##
 
     def set_signals(self) -> None:
-        self.signal_receiver.install(
+        self._signal_receiver.install(
             signal.SIGTERM,
             signal.SIGINT,
             signal.SIGQUIT,
@@ -2136,7 +2336,7 @@ class ServerContext(AbstractServerContext):
                     ))
 
     def cleanup(self) -> None:
-        if self.unlink_pidfile:
+        if self._unlink_pidfile:
             try_unlink(self.config.pidfile)
         self.poller.close()
 
@@ -2189,6 +2389,7 @@ class ServerContext(AbstractServerContext):
             # Parent
             log.debug('supervisord forked; parent exiting')
             real_exit(0)
+
         # Child
         log.info('daemonizing the supervisord process')
         if self.config.directory:
@@ -2198,11 +2399,15 @@ class ServerContext(AbstractServerContext):
                 log.critical("can't chdir into %r: %s", self.config.directory, err)
             else:
                 log.info('set current directory: %r', self.config.directory)
+
         os.dup2(0, os.open('/dev/null', os.O_RDONLY))
         os.dup2(1, os.open('/dev/null', os.O_WRONLY))
         os.dup2(2, os.open('/dev/null', os.O_WRONLY))
+
         os.setsid()
+
         os.umask(self.config.umask)
+
         # 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
         # again after the setsid() call, for obscure SVR4 reasons.
@@ -2217,7 +2422,7 @@ class ServerContext(AbstractServerContext):
         return logfile
 
     def get_signal(self) -> ta.Optional[int]:
-        return self.signal_receiver.get_signal()
+        return self._signal_receiver.get_signal()
 
     def write_pidfile(self) -> None:
         pid = os.getpid()
@@ -2227,7 +2432,7 @@ class ServerContext(AbstractServerContext):
         except OSError:
             log.critical('could not write pidfile %s', self.config.pidfile)
         else:
-            self.unlink_pidfile = True
+            self._unlink_pidfile = True
             log.info('supervisord started with pid %s', pid)
 
 
@@ -2280,11 +2485,14 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
             os.setgroups(groups)
         except OSError:
             return 'Could not set groups of effective user'
+
     try:
         os.setgid(gid)
     except OSError:
         return 'Could not set group id of effective user'
+
     os.setuid(uid)
+
     return None
 
 
@@ -2354,9 +2562,6 @@ def check_execv_args(filename, argv, st) -> None:
 # ../dispatchers.py
 
 
-log = logging.getLogger(__name__)
-
-
 class Dispatcher(abc.ABC):
 
     def __init__(self, process: AbstractSubprocess, channel: str, fd: int) -> None:
@@ -2513,16 +2718,16 @@ class OutputDispatcher(Dispatcher):
             # )
 
     def remove_logs(self):
-        for log in (self._normal_log, self._capture_log):
-            if log is not None:
-                for handler in log.handlers:
+        for l in (self._normal_log, self._capture_log):
+            if l is not None:
+                for handler in l.handlers:
                     handler.remove()  # type: ignore
                     handler.reopen()  # type: ignore
 
     def reopen_logs(self):
-        for log in (self._normal_log, self._capture_log):
-            if log is not None:
-                for handler in log.handlers:
+        for l in (self._normal_log, self._capture_log):
+            if l is not None:
+                for handler in l.handlers:
                     handler.reopen()  # type: ignore
 
     def _log(self, data):
@@ -2545,10 +2750,10 @@ class OutputDispatcher(Dispatcher):
 
             if self._channel == 'stdout':
                 if self._stdout_events_enabled:
-                    notify_event(ProcessLogStdoutEvent(self._process, self._process.pid, data))
+                    EVENT_CALLBACKS.notify(ProcessLogStdoutEvent(self._process, self._process.pid, data))
 
             elif self._stderr_events_enabled:
-                notify_event(ProcessLogStderrEvent(self._process, self._process.pid, data))
+                EVENT_CALLBACKS.notify(ProcessLogStderrEvent(self._process, self._process.pid, data))
 
     def record_output(self):
         if self._capture_log is None:
@@ -2599,7 +2804,7 @@ class OutputDispatcher(Dispatcher):
                 channel = self._channel
                 procname = self._process.config.name
                 event = self.event_type(self._process, self._process.pid, data)
-                notify_event(event)
+                EVENT_CALLBACKS.notify(event)
 
                 log.debug('%r %s emitted a comm event', procname, channel)
                 for handler in self._capture_log.handlers:
@@ -2660,9 +2865,6 @@ class InputDispatcher(Dispatcher):
 # ../process.py
 
 
-log = logging.getLogger(__name__)
-
-
 @functools.total_ordering
 class Subprocess(AbstractSubprocess):
     """A class to manage a subprocess."""
@@ -2815,7 +3017,7 @@ class Subprocess(AbstractSubprocess):
         event_class = self.event_map.get(new_state)
         if event_class is not None:
             event = event_class(self, old_state, expected)
-            notify_event(event)
+            EVENT_CALLBACKS.notify(event)
 
         return True
 
@@ -2932,6 +3134,7 @@ class Subprocess(AbstractSubprocess):
             os.dup2(self._pipes['child_stdout'], 2)
         else:
             os.dup2(self._pipes['child_stderr'], 2)
+        # FIXME: leave debugger fds
         for i in range(3, self.context.config.minfds):
             close_fd(i)
 
@@ -2967,7 +3170,7 @@ class Subprocess(AbstractSubprocess):
             cwd = self.config.directory
             try:
                 if cwd is not None:
-                    os.chdir(cwd)
+                    os.chdir(os.path.expanduser(cwd))
             except OSError as why:
                 code = errno.errorcode.get(why.args[0], why.args[0])
                 msg = f"couldn't chdir to {cwd}: {code}\n"
@@ -3023,7 +3226,7 @@ class Subprocess(AbstractSubprocess):
         return self.kill(self.config.stopsignal)
 
     def stop_report(self) -> None:
-        """ Log a 'waiting for x to stop' message with throttling. """
+        """Log a 'waiting for x to stop' message with throttling."""
         if self.state == ProcessStates.STOPPING:
             now = time.time()
 
@@ -3153,7 +3356,7 @@ class Subprocess(AbstractSubprocess):
         return None
 
     def finish(self, sts: int) -> None:
-        """ The process was reaped and we need to report and manage its state """
+        """The process was reaped and we need to report and manage its state."""
 
         self.drain()
 
@@ -3234,7 +3437,7 @@ class Subprocess(AbstractSubprocess):
         # system that this event was rejected so it can be processed again.
         if self.event is not None:
             # Note: this should only be true if we were in the BUSY state when finish() was called.
-            notify_event(EventRejectedEvent(self, self.event))  # type: ignore
+            EVENT_CALLBACKS.notify(EventRejectedEvent(self, self.event))  # type: ignore
             self.event = None
 
     def set_uid(self) -> ta.Optional[str]:
@@ -3397,10 +3600,11 @@ class ProcessGroup:
 
 
 ########################################
-# supervisor.py
+# ../supervisor.py
 
 
-log = logging.getLogger(__name__)
+def timeslice(period: int, when: float) -> int:
+    return int(when - (when % period))
 
 
 class Supervisor:
@@ -3415,6 +3619,8 @@ class Supervisor:
         self._stopping = False  # set after we detect that we are handling a stop request
         self._last_shutdown_report = 0.  # throttle for delayed process error reports at stop
 
+    #
+
     @property
     def context(self) -> ServerContext:
         return self._context
@@ -3422,47 +3628,14 @@ class Supervisor:
     def get_state(self) -> SupervisorState:
         return self._context.state
 
-    def main(self) -> None:
-        if not self._context.first:
-            # prevent crash on libdispatch-based systems, at least for the first request
-            self._context.cleanup_fds()
-
-        self._context.set_uid_or_exit()
-
-        if self._context.first:
-            self._context.set_rlimits_or_exit()
-
-        # this sets the options.logger object delay logger instantiation until after setuid
-        if not self._context.config.nocleanup:
-            # clean up old automatic logs
-            self._context.clear_auto_child_logdir()
-
-        self.run()
-
-    def run(self) -> None:
-        self._process_groups = {}  # clear
-        self._stop_groups = None  # clear
-
-        clear_events()
-
-        try:
-            for config in self._context.config.groups or []:
-                self.add_process_group(config)
-
-            self._context.set_signals()
-
-            if not self._context.config.nodaemon and self._context.first:
-                self._context.daemonize()
-
-            # writing pid file needs to come *after* daemonizing or pid will be wrong
-            self._context.write_pidfile()
-
-            self.runforever()
+    #
 
-        finally:
-            self._context.cleanup()
+    class DiffToActive(ta.NamedTuple):
+        added: ta.List[ProcessGroupConfig]
+        changed: ta.List[ProcessGroupConfig]
+        removed: ta.List[ProcessGroupConfig]
 
-    def diff_to_active(self):
+    def diff_to_active(self) -> DiffToActive:
         new = self._context.config.groups or []
         cur = [group.config for group in self._process_groups.values()]
 
@@ -3474,7 +3647,7 @@ class Supervisor:
 
         changed = [cand for cand in new if cand != curdict.get(cand.name, cand)]
 
-        return added, changed, removed
+        return Supervisor.DiffToActive(added, changed, removed)
 
     def add_process_group(self, config: ProcessGroupConfig) -> bool:
         name = config.name
@@ -3484,7 +3657,7 @@ class Supervisor:
         group = self._process_groups[name] = ProcessGroup(config, self._context)
         group.after_setuid()
 
-        notify_event(ProcessGroupAddedEvent(name))
+        EVENT_CALLBACKS.notify(ProcessGroupAddedEvent(name))
         return True
 
     def remove_process_group(self, name: str) -> bool:
@@ -3495,7 +3668,7 @@ class Supervisor:
 
         del self._process_groups[name]
 
-        notify_event(ProcessGroupRemovedEvent(name))
+        EVENT_CALLBACKS.notify(ProcessGroupRemovedEvent(name))
         return True
 
     def get_process_map(self) -> ta.Dict[int, Dispatcher]:
@@ -3524,6 +3697,72 @@ class Supervisor:
 
         return unstopped
 
+    #
+
+    def main(self) -> None:
+        self.setup()
+        self.run()
+
+    @cached_nullary
+    def setup(self) -> None:
+        if not self._context.first:
+            # prevent crash on libdispatch-based systems, at least for the first request
+            self._context.cleanup_fds()
+
+        self._context.set_uid_or_exit()
+
+        if self._context.first:
+            self._context.set_rlimits_or_exit()
+
+        # this sets the options.logger object delay logger instantiation until after setuid
+        if not self._context.config.nocleanup:
+            # clean up old automatic logs
+            self._context.clear_auto_child_logdir()
+
+    def run(
+            self,
+            *,
+            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
+    ) -> None:
+        self._process_groups = {}  # clear
+        self._stop_groups = None  # clear
+
+        EVENT_CALLBACKS.clear()
+
+        try:
+            for config in self._context.config.groups or []:
+                self.add_process_group(config)
+
+            self._context.set_signals()
+
+            if not self._context.config.nodaemon and self._context.first:
+                self._context.daemonize()
+
+            # writing pid file needs to come *after* daemonizing or pid will be wrong
+            self._context.write_pidfile()
+
+            EVENT_CALLBACKS.notify(SupervisorRunningEvent())
+
+            while True:
+                if callback is not None and not callback(self):
+                    break
+
+                self._run_once()
+
+        finally:
+            self._context.cleanup()
+
+    #
+
+    def _run_once(self) -> None:
+        self._poll()
+        self._reap()
+        self._handle_signal()
+        self._tick()
+
+        if self._context.state < SupervisorStates.RUNNING:
+            self._ordered_stop_groups_phase_2()
+
     def _ordered_stop_groups_phase_1(self) -> None:
         if self._stop_groups:
             # stop the last group (the one with the "highest" priority)
@@ -3540,110 +3779,77 @@ class Supervisor:
                 # down, so push it back on to the end of the stop group queue
                 self._stop_groups.append(group)
 
-    def runforever(self) -> None:
-        notify_event(SupervisorRunningEvent())
-        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-
-        while True:
-            combined_map = {}
-            combined_map.update(self.get_process_map())
+    def _poll(self) -> None:
+        combined_map = {}
+        combined_map.update(self.get_process_map())
 
-            pgroups = list(self._process_groups.values())
-            pgroups.sort()
+        pgroups = list(self._process_groups.values())
+        pgroups.sort()
 
-            if self._context.state < SupervisorStates.RUNNING:
-                if not self._stopping:
-                    # first time, set the stopping flag, do a notification and set stop_groups
-                    self._stopping = True
-                    self._stop_groups = pgroups[:]
-                    notify_event(SupervisorStoppingEvent())
+        if self._context.state < SupervisorStates.RUNNING:
+            if not self._stopping:
+                # first time, set the stopping flag, do a notification and set stop_groups
+                self._stopping = True
+                self._stop_groups = pgroups[:]
+                EVENT_CALLBACKS.notify(SupervisorStoppingEvent())
 
-                self._ordered_stop_groups_phase_1()
+            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
+            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
 
-            for fd, dispatcher in combined_map.items():
-                if dispatcher.readable():
-                    self._context.poller.register_readable(fd)
-                if dispatcher.writable():
-                    self._context.poller.register_writable(fd)
+        for fd, dispatcher in combined_map.items():
+            if dispatcher.readable():
+                self._context.poller.register_readable(fd)
+            if dispatcher.writable():
+                self._context.poller.register_writable(fd)
 
-            r, w = self._context.poller.poll(timeout)
+        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
+        r, w = self._context.poller.poll(timeout)
 
-            for fd in r:
-                if fd in combined_map:
-                    try:
-                        dispatcher = combined_map[fd]
-                        log.debug('read event caused by %r', dispatcher)
-                        dispatcher.handle_read_event()
-                        if not dispatcher.readable():
-                            self._context.poller.unregister_readable(fd)
-                    except ExitNow:
-                        raise
-                    except Exception:  # noqa
-                        combined_map[fd].handle_error()
-                else:
-                    # if the fd is not in combined_map, we should unregister it. otherwise, it will be polled every
-                    # time, which may cause 100% cpu usage
-                    log.debug('unexpected read event from fd %r', fd)
-                    try:
+        for fd in r:
+            if fd in combined_map:
+                try:
+                    dispatcher = combined_map[fd]
+                    log.debug('read event caused by %r', dispatcher)
+                    dispatcher.handle_read_event()
+                    if not dispatcher.readable():
                         self._context.poller.unregister_readable(fd)
-                    except Exception:  # noqa
-                        pass
+                except ExitNow:
+                    raise
+                except Exception:  # noqa
+                    combined_map[fd].handle_error()
+            else:
+                # if the fd is not in combined_map, we should unregister it. otherwise, it will be polled every
+                # time, which may cause 100% cpu usage
+                log.debug('unexpected read event from fd %r', fd)
+                try:
+                    self._context.poller.unregister_readable(fd)
+                except Exception:  # noqa
+                    pass
 
-            for fd in w:
-                if fd in combined_map:
-                    try:
-                        dispatcher = combined_map[fd]
-                        log.debug('write event caused by %r', dispatcher)
-                        dispatcher.handle_write_event()
-                        if not dispatcher.writable():
-                            self._context.poller.unregister_writable(fd)
-                    except ExitNow:
-                        raise
-                    except Exception:  # noqa
-                        combined_map[fd].handle_error()
-                else:
-                    log.debug('unexpected write event from fd %r', fd)
-                    try:
+        for fd in w:
+            if fd in combined_map:
+                try:
+                    dispatcher = combined_map[fd]
+                    log.debug('write event caused by %r', dispatcher)
+                    dispatcher.handle_write_event()
+                    if not dispatcher.writable():
                         self._context.poller.unregister_writable(fd)
-                    except Exception:  # noqa
-                        pass
-
-            for group in pgroups:
-                group.transition()
-
-            self._reap()
-            self._handle_signal()
-            self._tick()
-
-            if self._context.state < SupervisorStates.RUNNING:
-                self._ordered_stop_groups_phase_2()
-
-            if self._context.test:
-                break
-
-    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"""
-
-        if now is None:
-            # now won't be None in unit tests
-            now = time.time()
-
-        for event in TICK_EVENTS:
-            period = event.period  # type: ignore
-
-            last_tick = self._ticks.get(period)
-            if last_tick is None:
-                # we just started up
-                last_tick = self._ticks[period] = timeslice(period, now)
+                except ExitNow:
+                    raise
+                except Exception:  # noqa
+                    combined_map[fd].handle_error()
+            else:
+                log.debug('unexpected write event from fd %r', fd)
+                try:
+                    self._context.poller.unregister_writable(fd)
+                except Exception:  # noqa
+                    pass
 
-            this_tick = timeslice(period, now)
-            if this_tick != last_tick:
-                self._ticks[period] = this_tick
-                notify_event(event(this_tick, self))
+        for group in pgroups:
+            group.transition()
 
     def _reap(self, *, once: bool = False, depth: int = 0) -> None:
         if depth >= 100:
@@ -3693,50 +3899,77 @@ class Supervisor:
         else:
             log.debug('received %s indicating nothing', signame(sig))
 
+    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"""
+
+        if now is None:
+            # now won't be None in unit tests
+            now = time.time()
 
-def timeslice(period, when):
-    return int(when - (when % period))
+        for event in TICK_EVENTS:
+            period = event.period  # type: ignore
+
+            last_tick = self._ticks.get(period)
+            if last_tick is None:
+                # we just started up
+                last_tick = self._ticks[period] = timeslice(period, now)
+
+            this_tick = timeslice(period, now)
+            if this_tick != last_tick:
+                self._ticks[period] = this_tick
+                EVENT_CALLBACKS.notify(event(this_tick, self))
+
+
+########################################
+# main.py
 
 
-def main(args=None, test=False):
+def main(
+        argv: ta.Optional[ta.Sequence[str]] = None,
+        *,
+        no_logging: bool = False,
+) -> None:
     import argparse
 
     parser = argparse.ArgumentParser()
     parser.add_argument('config_file', metavar='config-file')
-    args = parser.parse_args()
+    parser.add_argument('--no-journald', action='store_true')
+    args = parser.parse_args(argv)
 
-    configure_standard_logging('INFO')
+    #
 
     if not (cf := args.config_file):
         raise RuntimeError('No config file specified')
 
+    if not no_logging:
+        configure_standard_logging(
+            'INFO',
+            handler_factory=journald_log_handler_factory if not args.no_journald else None,
+        )
+
+    #
+
     # if we hup, restart by making a new Supervisor()
-    first = True
-    while True:
+    for epoch in itertools.count():
         with open(cf) as f:
             config_src = f.read()
+
         config_dct = json.loads(config_src)
         config: ServerConfig = unmarshal_obj(config_dct, ServerConfig)
 
         context = ServerContext(
             config,
+            epoch=epoch,
         )
 
-        context.first = first
-        context.test = test
-        go(context)
-        # options.close_logger()
-        first = False
-        if test or (context.state < SupervisorStates.RESTARTING):
-            break
-
+        supervisor = Supervisor(context)
+        try:
+            supervisor.main()
+        except ExitNow:
+            pass
 
-def go(context):  # pragma: no cover
-    d = Supervisor(context)
-    try:
-        d.main()
-    except ExitNow:
-        pass
+        if context.state < SupervisorStates.RESTARTING:
+            break
 
 
 if __name__ == '__main__':