ominfra 0.0.0.dev90__py3-none-any.whl → 0.0.0.dev92__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -5,11 +5,16 @@
 # @omlish-amalg-output ../supervisor/supervisor.py
 # ruff: noqa: N802 UP006 UP007 UP036
 import abc
+import base64
+import collections.abc
 import contextlib
 import dataclasses as dc
 import datetime
+import decimal
+import enum
 import errno
 import fcntl
+import fractions
 import functools
 import grp
 import json
@@ -29,7 +34,9 @@ import time
 import traceback
 import types
 import typing as ta
+import uuid
 import warnings
+import weakref  # noqa
 
 
 ########################################
@@ -76,9 +83,10 @@ def compact_traceback() -> ta.Tuple[
     types.TracebackType,
 ]:
     t, v, tb = sys.exc_info()
-    tbinfo = []
     if not tb:
         raise RuntimeError('No traceback')
+
+    tbinfo = []
     while tb:
         tbinfo.append((
             tb.tb_frame.f_code.co_filename,
@@ -116,6 +124,7 @@ def decode_wait_status(sts: int) -> ta.Tuple[int, str]:
     Return a tuple (exitstatus, message) where exitstatus is the exit status, or -1 if the process was killed by a
     signal; and message is a message telling what happened.  It is the caller's responsibility to display the message.
     """
+
     if os.WIFEXITED(sts):
         es = os.WEXITSTATUS(sts) & 0xffff
         msg = f'exit status {es}'
@@ -215,6 +224,7 @@ def real_exit(code: int) -> None:
 
 def get_path() -> ta.Sequence[str]:
     """Return a list corresponding to $PATH, or a default."""
+
     path = ['/bin', '/usr/bin', '/usr/local/bin']
     if 'PATH' in os.environ:
         p = os.environ['PATH']
@@ -231,8 +241,9 @@ ANSI_ESCAPE_BEGIN = b'\x1b['
 ANSI_TERMINATORS = (b'H', b'f', b'A', b'B', b'C', b'D', b'R', b's', b'u', b'J', b'K', b'h', b'l', b'p', b'm')
 
 
-def strip_escapes(s):
+def strip_escapes(s: bytes) -> bytes:
     """Remove all ANSI color escapes from the given string."""
+
     result = b''
     show = 1
     i = 0
@@ -400,15 +411,19 @@ SIGNUMS = [getattr(signal, k) for k in dir(signal) if k.startswith('SIG')]
 def signal_number(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}'
+
         num = getattr(signal, name, None)  # type: ignore
         if num is None:
             raise ValueError(f'value {value!r} is not a valid signal name')  # noqa
+
     if num not in SIGNUMS:
         raise ValueError(f'value {value!r} is not a valid signal number')
+
     return num
 
 
@@ -425,20 +440,22 @@ class RestartUnconditionally:
 
 
 class ProcessError(Exception):
-    """ Specialized exceptions used when attempting to start a process """
+    """Specialized exceptions used when attempting to start a process."""
 
 
 class BadCommandError(ProcessError):
-    """ Indicates the command could not be parsed properly. """
+    """Indicates the command could not be parsed properly."""
 
 
 class NotExecutableError(ProcessError):
-    """ Indicates that the filespec cannot be executed because its path
-    resolves to a file which is not executable, or which is a directory. """
+    """
+    Indicates that the filespec cannot be executed because its path resolves to a file which is not executable, or which
+    is a directory.
+    """
 
 
 class NotFoundError(ProcessError):
-    """ Indicates that the filespec cannot be executed because it could not be found """
+    """Indicates that the filespec cannot be executed because it could not be found."""
 
 
 class NoPermissionError(ProcessError):
@@ -773,61 +790,54 @@ json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON
 
 
 ########################################
-# ../configs.py
+# ../../../omlish/lite/reflect.py
 
 
-@dc.dataclass(frozen=True)
-class ServerConfig:
-    user: ta.Optional[str] = None
-    nodaemon: bool = False
-    umask: int = 0o22
-    directory: ta.Optional[str] = None
-    logfile: str = 'supervisord.log'
-    logfile_maxbytes: 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
-    nocleanup: bool = False
-    strip_ansi: bool = False
-    silent: bool = False
+_GENERIC_ALIAS_TYPES = (
+    ta._GenericAlias,  # type: ignore  # noqa
+    *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
+)
 
-    groups: ta.Optional[ta.Sequence['ProcessGroupConfig']] = None
 
-    @classmethod
-    def new(
-            cls,
-            umask: ta.Union[int, str] = 0o22,
-            directory: ta.Optional[str] = None,
-            logfile: str = 'supervisord.log',
-            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
-            loglevel: ta.Union[int, str] = logging.INFO,
-            pidfile: str = 'supervisord.pid',
-            child_logdir: ta.Optional[str] = None,
-            **kwargs: ta.Any,
-    ) -> 'ServerConfig':
-        return cls(
-            umask=octal_type(umask),
-            directory=existing_directory(directory) if directory is not None else None,
-            logfile=existing_dirpath(logfile),
-            logfile_maxbytes=byte_size(logfile_maxbytes),
-            loglevel=logging_level(loglevel),
-            pidfile=existing_dirpath(pidfile),
-            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
-            **kwargs,
-        )
+def is_generic_alias(obj, *, origin: ta.Any = None) -> bool:
+    return (
+        isinstance(obj, _GENERIC_ALIAS_TYPES) and
+        (origin is None or ta.get_origin(obj) is origin)
+    )
 
 
-@dc.dataclass(frozen=True)
-class ProcessGroupConfig:
-    name: str
+is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
+is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
 
-    priority: int = 999
 
-    processes: ta.Optional[ta.Sequence['ProcessConfig']] = None
+def is_optional_alias(spec: ta.Any) -> bool:
+    return (
+        isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
+        ta.get_origin(spec) is ta.Union and
+        len(ta.get_args(spec)) == 2 and
+        any(a in (None, type(None)) for a in ta.get_args(spec))
+    )
+
+
+def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
+    [it] = [it for it in ta.get_args(spec) if it not in (None, type(None))]
+    return it
+
+
+def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
+    seen = set()
+    todo = list(reversed(cls.__subclasses__()))
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+        yield cur
+        todo.extend(reversed(cur.__subclasses__()))
+
+
+########################################
+# ../configs.py
 
 
 @dc.dataclass(frozen=True)
@@ -867,13 +877,67 @@ class ProcessConfig:
 
     killasgroup: bool = False
 
-    exitcodes: ta.Iterable[int] = (0,)
+    exitcodes: ta.Sequence[int] = (0,)
 
     redirect_stderr: bool = False
 
     environment: ta.Optional[ta.Mapping[str, str]] = None
 
 
+@dc.dataclass(frozen=True)
+class ProcessGroupConfig:
+    name: str
+
+    priority: int = 999
+
+    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
+
+
+@dc.dataclass(frozen=True)
+class ServerConfig:
+    user: ta.Optional[str] = None
+    nodaemon: bool = False
+    umask: int = 0o22
+    directory: ta.Optional[str] = None
+    logfile: str = 'supervisord.log'
+    logfile_maxbytes: 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
+    nocleanup: bool = False
+    strip_ansi: bool = False
+    silent: bool = False
+
+    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
+
+    @classmethod
+    def new(
+            cls,
+            umask: ta.Union[int, str] = 0o22,
+            directory: ta.Optional[str] = None,
+            logfile: str = 'supervisord.log',
+            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
+            loglevel: ta.Union[int, str] = logging.INFO,
+            pidfile: str = 'supervisord.pid',
+            child_logdir: ta.Optional[str] = None,
+            **kwargs: ta.Any,
+    ) -> 'ServerConfig':
+        return cls(
+            umask=octal_type(umask),
+            directory=existing_directory(directory) if directory is not None else None,
+            logfile=existing_dirpath(logfile),
+            logfile_maxbytes=byte_size(logfile_maxbytes),
+            loglevel=logging_level(loglevel),
+            pidfile=existing_dirpath(pidfile),
+            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
+            **kwargs,
+        )
+
+
 ########################################
 # ../states.py
 
@@ -1214,6 +1278,309 @@ def configure_standard_logging(
         return StandardLogHandler(handler)
 
 
+########################################
+# ../../../omlish/lite/marshal.py
+"""
+TODO:
+ - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
+ - nonstrict toggle
+"""
+
+
+##
+
+
+class ObjMarshaler(abc.ABC):
+    @abc.abstractmethod
+    def marshal(self, o: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+
+class NopObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return o
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+@dc.dataclass()
+class ProxyObjMarshaler(ObjMarshaler):
+    m: ta.Optional[ObjMarshaler] = None
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return check_not_none(self.m).marshal(o)
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return check_not_none(self.m).unmarshal(o)
+
+
+@dc.dataclass(frozen=True)
+class CastObjMarshaler(ObjMarshaler):
+    ty: type
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return o
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty(o)
+
+
+class DynamicObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return marshal_obj(o)
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+@dc.dataclass(frozen=True)
+class Base64ObjMarshaler(ObjMarshaler):
+    ty: type
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return base64.b64encode(o).decode('ascii')
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty(base64.b64decode(o))
+
+
+@dc.dataclass(frozen=True)
+class EnumObjMarshaler(ObjMarshaler):
+    ty: type
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return o.name
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty.__members__[o]  # type: ignore
+
+
+@dc.dataclass(frozen=True)
+class OptionalObjMarshaler(ObjMarshaler):
+    item: ObjMarshaler
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        if o is None:
+            return None
+        return self.item.marshal(o)
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        if o is None:
+            return None
+        return self.item.unmarshal(o)
+
+
+@dc.dataclass(frozen=True)
+class MappingObjMarshaler(ObjMarshaler):
+    ty: type
+    km: ObjMarshaler
+    vm: ObjMarshaler
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return {self.km.marshal(k): self.vm.marshal(v) for k, v in o.items()}
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty((self.km.unmarshal(k), self.vm.unmarshal(v)) for k, v in o.items())
+
+
+@dc.dataclass(frozen=True)
+class IterableObjMarshaler(ObjMarshaler):
+    ty: type
+    item: ObjMarshaler
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return [self.item.marshal(e) for e in o]
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty(self.item.unmarshal(e) for e in o)
+
+
+@dc.dataclass(frozen=True)
+class DataclassObjMarshaler(ObjMarshaler):
+    ty: type
+    fs: ta.Mapping[str, ObjMarshaler]
+    nonstrict: bool = False
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return {k: m.marshal(getattr(o, k)) for k, m in self.fs.items()}
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty(**{k: self.fs[k].unmarshal(v) for k, v in o.items() if self.nonstrict or k in self.fs})
+
+
+@dc.dataclass(frozen=True)
+class PolymorphicObjMarshaler(ObjMarshaler):
+    class Impl(ta.NamedTuple):
+        ty: type
+        tag: str
+        m: ObjMarshaler
+
+    impls_by_ty: ta.Mapping[type, Impl]
+    impls_by_tag: ta.Mapping[str, Impl]
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        impl = self.impls_by_ty[type(o)]
+        return {impl.tag: impl.m.marshal(o)}
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        [(t, v)] = o.items()
+        impl = self.impls_by_tag[t]
+        return impl.m.unmarshal(v)
+
+
+@dc.dataclass(frozen=True)
+class DatetimeObjMarshaler(ObjMarshaler):
+    ty: type
+
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return o.isoformat()
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return self.ty.fromisoformat(o)  # type: ignore
+
+
+class DecimalObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return str(check_isinstance(o, decimal.Decimal))
+
+    def unmarshal(self, v: ta.Any) -> ta.Any:
+        return decimal.Decimal(check_isinstance(v, str))
+
+
+class FractionObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any) -> ta.Any:
+        fr = check_isinstance(o, fractions.Fraction)
+        return [fr.numerator, fr.denominator]
+
+    def unmarshal(self, v: ta.Any) -> ta.Any:
+        num, denom = check_isinstance(v, list)
+        return fractions.Fraction(num, denom)
+
+
+class UuidObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any) -> ta.Any:
+        return str(o)
+
+    def unmarshal(self, o: ta.Any) -> ta.Any:
+        return uuid.UUID(o)
+
+
+_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
+    **{t: NopObjMarshaler() for t in (type(None),)},
+    **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
+    **{t: Base64ObjMarshaler(t) for t in (bytes, bytearray)},
+    **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
+    **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
+
+    ta.Any: DynamicObjMarshaler(),
+
+    **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
+    decimal.Decimal: DecimalObjMarshaler(),
+    fractions.Fraction: FractionObjMarshaler(),
+    uuid.UUID: UuidObjMarshaler(),
+}
+
+_OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
+    **{t: t for t in (dict,)},
+    **{t: dict for t in (collections.abc.Mapping, collections.abc.MutableMapping)},
+}
+
+_OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
+    **{t: t for t in (list, tuple, set, frozenset)},
+    collections.abc.Set: frozenset,
+    collections.abc.MutableSet: set,
+    collections.abc.Sequence: tuple,
+    collections.abc.MutableSequence: list,
+}
+
+
+def register_opj_marshaler(ty: ta.Any, m: ObjMarshaler) -> None:
+    if ty in _OBJ_MARSHALERS:
+        raise KeyError(ty)
+    _OBJ_MARSHALERS[ty] = m
+
+
+def _make_obj_marshaler(ty: ta.Any) -> ObjMarshaler:
+    if isinstance(ty, type):
+        if abc.ABC in ty.__bases__:
+            impls = [  # type: ignore
+                PolymorphicObjMarshaler.Impl(
+                    ity,
+                    ity.__qualname__,
+                    get_obj_marshaler(ity),
+                )
+                for ity in deep_subclasses(ty)
+                if abc.ABC not in ity.__bases__
+            ]
+            return PolymorphicObjMarshaler(
+                {i.ty: i for i in impls},
+                {i.tag: i for i in impls},
+            )
+
+        if issubclass(ty, enum.Enum):
+            return EnumObjMarshaler(ty)
+
+        if dc.is_dataclass(ty):
+            return DataclassObjMarshaler(
+                ty,
+                {f.name: get_obj_marshaler(f.type) for f in dc.fields(ty)},
+            )
+
+    if is_generic_alias(ty):
+        try:
+            mt = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES[ta.get_origin(ty)]
+        except KeyError:
+            pass
+        else:
+            k, v = ta.get_args(ty)
+            return MappingObjMarshaler(mt, get_obj_marshaler(k), get_obj_marshaler(v))
+
+        try:
+            st = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES[ta.get_origin(ty)]
+        except KeyError:
+            pass
+        else:
+            [e] = ta.get_args(ty)
+            return IterableObjMarshaler(st, get_obj_marshaler(e))
+
+        if is_union_alias(ty):
+            return OptionalObjMarshaler(get_obj_marshaler(get_optional_alias_arg(ty)))
+
+    raise TypeError(ty)
+
+
+def get_obj_marshaler(ty: ta.Any) -> ObjMarshaler:
+    try:
+        return _OBJ_MARSHALERS[ty]
+    except KeyError:
+        pass
+
+    p = ProxyObjMarshaler()
+    _OBJ_MARSHALERS[ty] = p
+    try:
+        m = _make_obj_marshaler(ty)
+    except Exception:
+        del _OBJ_MARSHALERS[ty]
+        raise
+    else:
+        p.m = m
+        _OBJ_MARSHALERS[ty] = m
+        return m
+
+
+def marshal_obj(o: ta.Any, ty: ta.Any = None) -> ta.Any:
+    return get_obj_marshaler(ty if ty is not None else type(o)).marshal(o)
+
+
+def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
+    return get_obj_marshaler(ty).unmarshal(o)
+
+
 ########################################
 # ../events.py
 
@@ -1245,12 +1612,11 @@ notify_event = EVENT_CALLBACKS.notify
 clear_events = EVENT_CALLBACKS.clear
 
 
-class Event:
+class Event(abc.ABC):  # noqa
     """Abstract event type """
 
 
-class ProcessLogEvent(Event):
-    """Abstract"""
+class ProcessLogEvent(Event, abc.ABC):
     channel: ta.Optional[str] = None
 
     def __init__(self, process, pid, data):
@@ -1267,8 +1633,8 @@ class ProcessLogEvent(Event):
             data = as_string(self.data)
         except UnicodeDecodeError:
             data = f'Undecodable: {self.data!r}'
-        fmt = as_string('processname:%s groupname:%s pid:%s channel:%s\n%s')
-        result = fmt % (
+
+        result = 'processname:%s groupname:%s pid:%s channel:%s\n%s' % (  # noqa
             as_string(self.process.config.name),
             as_string(groupname),
             self.pid,
@@ -1286,8 +1652,7 @@ class ProcessLogStderrEvent(ProcessLogEvent):
     channel = 'stderr'
 
 
-class ProcessCommunicationEvent(Event):
-    """ Abstract """
+class ProcessCommunicationEvent(Event, abc.ABC):
     # event mode tokens
     BEGIN_TOKEN = b'<!--XSUPERVISOR:BEGIN-->'
     END_TOKEN = b'<!--XSUPERVISOR:END-->'
@@ -1651,6 +2016,7 @@ class ServerContext(AbstractServerContext):
         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.uid is None:
             if os.getuid() == 0:
                 warnings.warn(
@@ -1830,6 +2196,7 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
     and when spawning subprocesses.  Returns None on success or a string error message if privileges could not be
     dropped.
     """
+
     if user is None:
         return 'No user specified to setuid to!'
 
@@ -2022,7 +2389,9 @@ class OutputDispatcher(Dispatcher):
 
         `event_type` should be one of ProcessLogStdoutEvent or ProcessLogStderrEvent
         """
+
         super().__init__(process, event_type.channel, fd)
+
         self.event_type = event_type
 
         self.lc: ProcessConfig.Log = getattr(process.config, self._channel)
@@ -2036,25 +2405,30 @@ class OutputDispatcher(Dispatcher):
         self._output_buffer = b''  # data waiting to be logged
 
         # all code below is purely for minor speedups
+
         begin_token = self.event_type.BEGIN_TOKEN
         end_token = self.event_type.END_TOKEN
-        self.begin_token_data = (begin_token, len(begin_token))
-        self.end_token_data = (end_token, len(end_token))
-        self.main_log_level = logging.DEBUG
+        self._begin_token_data = (begin_token, len(begin_token))
+        self._end_token_data = (end_token, len(end_token))
+
+        self._main_log_level = logging.DEBUG
+
+        self._log_to_main_log = process.context.config.loglevel <= self._main_log_level
+
         config = self._process.config
-        self.log_to_main_log = process.context.config.loglevel <= self.main_log_level
-        self.stdout_events_enabled = config.stdout.events_enabled
-        self.stderr_events_enabled = config.stderr.events_enabled
+        self._stdout_events_enabled = config.stdout.events_enabled
+        self._stderr_events_enabled = config.stderr.events_enabled
 
-    _child_log: ta.Optional[logging.Logger]  # the current logger (normal_log or capture_log)
-    _normal_log: ta.Optional[logging.Logger]  # the "normal" (non-capture) logger
-    _capture_log: ta.Optional[logging.Logger]  # the logger used while we're in capture_mode
+    _child_log: ta.Optional[logging.Logger] = None  # the current logger (normal_log or capture_log)
+    _normal_log: ta.Optional[logging.Logger] = None  # the "normal" (non-capture) logger
+    _capture_log: ta.Optional[logging.Logger] = None  # the logger used while we're in capture_mode
 
     def _init_normal_log(self) -> None:
         """
         Configure the "normal" (non-capture) log for this channel of this process. Sets self.normal_log if logging is
         enabled.
         """
+
         config = self._process.config  # noqa
         channel = self._channel  # noqa
 
@@ -2075,7 +2449,7 @@ class OutputDispatcher(Dispatcher):
         #         maxbytes=maxbytes,
         #         backups=backups,
         #     )
-        #
+
         # if to_syslog:
         #     loggers.handle_syslog(
         #         self.normal_log,
@@ -2087,6 +2461,7 @@ class OutputDispatcher(Dispatcher):
         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:
             self._capture_log = logging.getLogger(__name__)
@@ -2113,9 +2488,11 @@ class OutputDispatcher(Dispatcher):
         if data:
             if self._process.context.config.strip_ansi:
                 data = strip_escapes(data)
+
             if self._child_log:
                 self._child_log.info(data)
-            if self.log_to_main_log:
+
+            if self._log_to_main_log:
                 if not isinstance(data, bytes):
                     text = data
                 else:
@@ -2123,11 +2500,13 @@ class OutputDispatcher(Dispatcher):
                         text = data.decode('utf-8')
                     except UnicodeDecodeError:
                         text = f'Undecodable: {data!r}'
-                log.log(self.main_log_level, '%r %s output:\n%s', self._process.config.name, self._channel, text)  # noqa
+                log.log(self._main_log_level, '%r %s output:\n%s', self._process.config.name, self._channel, text)  # noqa
+
             if self._channel == 'stdout':
-                if self.stdout_events_enabled:
+                if self._stdout_events_enabled:
                     notify_event(ProcessLogStdoutEvent(self._process, self._process.pid, data))
-            elif self.stderr_events_enabled:
+
+            elif self._stderr_events_enabled:
                 notify_event(ProcessLogStderrEvent(self._process, self._process.pid, data))
 
     def record_output(self):
@@ -2139,9 +2518,9 @@ class OutputDispatcher(Dispatcher):
             return
 
         if self._capture_mode:
-            token, tokenlen = self.end_token_data
+            token, tokenlen = self._end_token_data
         else:
-            token, tokenlen = self.begin_token_data
+            token, tokenlen = self._begin_token_data
 
         if len(self._output_buffer) <= tokenlen:
             return  # not enough data
@@ -2329,6 +2708,7 @@ class Subprocess(AbstractSubprocess):
         Internal: turn a program name into a file name, using $PATH, make sure it exists / is executable, raising a
         ProcessError if not
         """
+
         try:
             commandargs = shlex.split(self.config.command)
         except ValueError as e:
@@ -2712,8 +3092,12 @@ class Subprocess(AbstractSubprocess):
                 os.kill(self.pid, sig)
             except OSError as exc:
                 if exc.errno == errno.ESRCH:
-                    log.debug('unable to signal %s (pid %s), it probably just now exited '
-                              'on its own: %s', processname, self.pid, str(exc))
+                    log.debug(
+                        'unable to signal %s (pid %s), it probably just now exited on its own: %s',
+                        processname,
+                        self.pid,
+                        str(exc),
+                    )
                     # we could change the state here but we intentionally do not.  we will do it during normal SIGCHLD
                     # processing.
                     return None
@@ -2729,6 +3113,7 @@ class Subprocess(AbstractSubprocess):
 
     def finish(self, sts: int) -> None:
         """ The process was reaped and we need to report and manage its state """
+
         self.drain()
 
         es, msg = decode_wait_status(sts)
@@ -2745,9 +3130,11 @@ class Subprocess(AbstractSubprocess):
         else:
             too_quickly = False
             log.warning(
-                "process '%s' (%s) laststart time is in the future, don't "
-                "know how long process was running so assuming it did "
-                "not exit too quickly", processname, self.pid)
+                "process '%s' (%s) laststart time is in the future, don't know how long process was running so "
+                "assuming it did not exit too quickly",
+                processname,
+                self.pid,
+            )
 
         exit_expected = es in self.config.exitcodes
 
@@ -2844,7 +3231,7 @@ class Subprocess(AbstractSubprocess):
                     if self.config.autorestart is RestartUnconditionally:
                         # EXITED -> STARTING
                         self.spawn()
-                    elif self.exitstatus not in self.config.exitcodes:  # type: ignore
+                    elif self.exitstatus not in self.config.exitcodes:
                         # EXITED -> STARTING
                         self.spawn()
 
@@ -3271,39 +3658,24 @@ def timeslice(period, when):
 
 
 def main(args=None, test=False):
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('config_file', metavar='config-file')
+    args = parser.parse_args()
+
     configure_standard_logging('INFO')
 
+    if not (cf := args.config_file):
+        raise RuntimeError('No config file specified')
+
     # if we hup, restart by making a new Supervisor()
     first = True
     while True:
-        config = ServerConfig.new(
-            nodaemon=True,
-            groups=[
-                ProcessGroupConfig(
-                    name='default',
-                    processes=[
-                        ProcessConfig(
-                            name='sleep',
-                            command='sleep 600',
-                            stdout=ProcessConfig.Log(
-                                file='/dev/fd/1',
-                                maxbytes=0,
-                            ),
-                            redirect_stderr=True,
-                        ),
-                        ProcessConfig(
-                            name='ls',
-                            command='ls -al',
-                            stdout=ProcessConfig.Log(
-                                file='/dev/fd/1',
-                                maxbytes=0,
-                            ),
-                            redirect_stderr=True,
-                        ),
-                    ],
-                ),
-            ],
-        )
+        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,