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

ominfra/supervisor/dispatchers.py

@@ -1,13 +1,14 @@
 # ruff: noqa: UP006 UP007
-from .types import Dispatcher
-from .types import OutputDispatcher
+from omlish.lite.fdio.handlers import FdIoHandler
+
+from .types import ProcessOutputDispatcher
 from .utils.collections import KeyedCollection
 from .utils.ostypes import Fd
 
 
-class Dispatchers(KeyedCollection[Fd, Dispatcher]):
-    def _key(self, v: Dispatcher) -> Fd:
-        return v.fd
+class Dispatchers(KeyedCollection[Fd, FdIoHandler]):
+    def _key(self, v: FdIoHandler) -> Fd:
+        return Fd(v.fd())
 
     #
 
@@ -16,18 +17,18 @@ class Dispatchers(KeyedCollection[Fd, Dispatcher]):
             # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
             # dispatcher (eg. call handle_listener_state_change for event listener processes)
             if d.readable():
-                d.handle_read_event()
+                d.on_readable()
             if d.writable():
-                d.handle_write_event()
+                d.on_writable()
 
     #
 
     def remove_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.remove_logs()
 
     def reopen_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.reopen_logs()

ominfra/supervisor/dispatchersimpl.py

@@ -8,14 +8,15 @@ import typing as ta
 from omlish.lite.logs import log
 
 from .configs import ProcessConfig
+from .configs import ServerConfig
 from .events import EventCallbacks
 from .events import ProcessCommunicationEvent
 from .events import ProcessLogStderrEvent
 from .events import ProcessLogStdoutEvent
-from .types import Dispatcher
-from .types import InputDispatcher
-from .types import OutputDispatcher
 from .types import Process
+from .types import ProcessDispatcher
+from .types import ProcessInputDispatcher
+from .types import ProcessOutputDispatcher
 from .utils.diag import compact_traceback
 from .utils.fds import read_fd
 from .utils.ostypes import Fd
@@ -24,7 +25,7 @@ from .utils.strings import find_prefix_at_end
 from .utils.strings import strip_escapes
 
 
-class BaseDispatcherImpl(Dispatcher, abc.ABC):
+class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def __init__(
             self,
             process: Process,
@@ -32,6 +33,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__()
 
@@ -39,6 +41,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         self._channel = channel  # 'stderr' or 'stdout'
         self._fd = fd
         self._event_callbacks = event_callbacks
+        self._server_config = server_config
 
         self._closed = False  # True if close() has been called
 
@@ -57,7 +60,6 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
     def channel(self) -> str:
         return self._channel
 
-    @property
     def fd(self) -> Fd:
         return self._fd
 
@@ -72,14 +74,14 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
             self._closed = True
 
-    def handle_error(self) -> None:
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:
         nil, t, v, tbinfo = compact_traceback()
 
         log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
         self.close()
 
 
-class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
+class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispatcher):
     """
     Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
 
@@ -95,12 +97,14 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             event_type.channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._event_type = event_type
@@ -124,11 +128,10 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
 
         self._main_log_level = logging.DEBUG
 
-        self._log_to_main_log = process.context.config.loglevel <= self._main_log_level
+        self._log_to_main_log = self._server_config.loglevel <= self._main_log_level
 
-        config = self._process.config
-        self._stdout_events_enabled = config.stdout.events_enabled
-        self._stderr_events_enabled = config.stderr.events_enabled
+        self._stdout_events_enabled = self._process.config.stdout.events_enabled
+        self._stderr_events_enabled = self._process.config.stderr.events_enabled
 
     _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
@@ -199,7 +202,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
         if not data:
             return
 
-        if self._process.context.config.strip_ansi:
+        if self._server_config.strip_ansi:
             data = strip_escapes(as_bytes(data))
 
         if self._child_log:
@@ -287,7 +290,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             return False
         return True
 
-    def handle_read_event(self) -> None:
+    def on_readable(self) -> None:
         data = read_fd(self._fd)
         self._output_buffer += data
         self.record_output()
@@ -297,7 +300,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self.close()
 
 
-class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
+class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatcher):
     def __init__(
             self,
             process: Process,
@@ -305,12 +308,14 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._input_buffer = b''
@@ -323,15 +328,12 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             return True
         return False
 
-    def readable(self) -> bool:
-        return False
-
     def flush(self) -> None:
         # other code depends on this raising EPIPE if the pipe is closed
         sent = os.write(self._fd, as_bytes(self._input_buffer))
         self._input_buffer = self._input_buffer[sent:]
 
-    def handle_write_event(self) -> None:
+    def on_writable(self) -> None:
         if self._input_buffer:
             try:
                 self.flush()

ominfra/supervisor/groups.py

@@ -2,15 +2,20 @@
 import typing as ta
 
 from .configs import ProcessGroupConfig
+from .dispatchers import Dispatchers
 from .events import EventCallbacks
 from .events import ProcessGroupAddedEvent
 from .events import ProcessGroupRemovedEvent
+from .types import HasDispatchers
 from .types import Process
 from .types import ProcessGroup
 from .utils.collections import KeyedCollectionAccessors
 
 
-class ProcessGroupManager(KeyedCollectionAccessors[str, ProcessGroup]):
+class ProcessGroupManager(
+    KeyedCollectionAccessors[str, ProcessGroup],
+    HasDispatchers,
+):
     def __init__(
             self,
             *,
@@ -34,6 +39,16 @@ class ProcessGroupManager(KeyedCollectionAccessors[str, ProcessGroup]):
 
     #
 
+    def get_dispatchers(self) -> Dispatchers:
+        return Dispatchers(
+            d
+            for g in self
+            for p in g
+            for d in p.get_dispatchers()
+        )
+
+    #
+
     def add(self, group: ProcessGroup) -> None:
         if (name := group.name) in self._by_name:
             raise KeyError(f'Process group already exists: {name}')

ominfra/supervisor/groupsimpl.py

@@ -61,7 +61,7 @@ class ProcessGroupImpl(ProcessGroup):
     #
 
     def get_unstopped_processes(self) -> ta.List[Process]:
-        return [x for x in self if not x.get_state().stopped]
+        return [x for x in self if not x.state.stopped]
 
     def stop_all(self) -> None:
         processes = list(self._by_name.values())
@@ -69,7 +69,7 @@ class ProcessGroupImpl(ProcessGroup):
         processes.reverse()  # stop in desc priority order
 
         for proc in processes:
-            state = proc.get_state()
+            state = proc.state
             if state == ProcessState.RUNNING:
                 # RUNNING -> STOPPING
                 proc.stop()

ominfra/supervisor/http.py

@@ -0,0 +1,130 @@
+# ruff: noqa: U006 UP007
+import json
+import socket
+import typing as ta
+
+from omlish.lite.check import check_not_none
+from omlish.lite.fdio.corohttp import CoroHttpServerConnectionFdIoHandler
+from omlish.lite.fdio.handlers import SocketFdIoHandler
+from omlish.lite.http.handlers import HttpHandler
+from omlish.lite.http.handlers import HttpHandlerRequest
+from omlish.lite.http.handlers import HttpHandlerResponse
+from omlish.lite.json import JSON_PRETTY_KWARGS
+from omlish.lite.socket import SocketAddress
+
+from .dispatchers import Dispatchers
+from .groups import ProcessGroupManager
+from .types import HasDispatchers
+
+
+##
+
+
+class SocketServerFdIoHandler(SocketFdIoHandler):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            on_connect: ta.Callable[[socket.socket, SocketAddress], None],
+    ) -> None:
+        sock = socket.create_server(addr)
+        sock.setblocking(False)
+
+        super().__init__(addr, sock)
+
+        self._on_connect = on_connect
+
+        sock.listen(1)
+
+    def readable(self) -> bool:
+        return True
+
+    def on_readable(self) -> None:
+        cli_sock, cli_addr = check_not_none(self._sock).accept()
+        cli_sock.setblocking(False)
+
+        self._on_connect(cli_sock, cli_addr)
+
+
+##
+
+
+class HttpServer(HasDispatchers):
+    class Address(ta.NamedTuple):
+        a: SocketAddress
+
+    class Handler(ta.NamedTuple):
+        h: HttpHandler
+
+    def __init__(
+            self,
+            handler: Handler,
+            addr: Address = Address(('localhost', 8000)),
+    ) -> None:
+        super().__init__()
+
+        self._handler = handler.h
+        self._addr = addr.a
+
+        self._server = SocketServerFdIoHandler(self._addr, self._on_connect)
+
+        self._conns: ta.List[CoroHttpServerConnectionFdIoHandler] = []
+
+    def get_dispatchers(self) -> Dispatchers:
+        l = []
+        for c in self._conns:
+            if not c.closed:
+                l.append(c)
+        self._conns = l
+        return Dispatchers([
+            self._server,
+            *l,
+        ])
+
+    def _on_connect(self, sock: socket.socket, addr: SocketAddress) -> None:
+        conn = CoroHttpServerConnectionFdIoHandler(
+            addr,
+            sock,
+            self._handler,
+        )
+
+        self._conns.append(conn)
+
+
+##
+
+
+class SupervisorHttpHandler:
+    def __init__(
+            self,
+            *,
+            groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
+
+        self._groups = groups
+
+    def handle(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        dct = {
+            'method': req.method,
+            'path': req.path,
+            'data': len(req.data or b''),
+            'groups': {
+                g.name: {
+                    'processes': {
+                        p.name: {
+                            'pid': p.pid,
+                        }
+                        for p in g
+                    },
+                }
+                for g in self._groups
+            },
+        }
+
+        return HttpHandlerResponse(
+            200,
+            data=json.dumps(dct, **JSON_PRETTY_KWARGS).encode('utf-8') + b'\n',
+            headers={
+                'Content-Type': 'application/json',
+            },
+        )

ominfra/supervisor/inject.py

@@ -1,20 +1,26 @@
 # ruff: noqa: UP006 UP007
+import dataclasses as dc
 import typing as ta
 
+from omlish.lite.fdio.kqueue import KqueueFdIoPoller  # noqa
+from omlish.lite.fdio.pollers import FdIoPoller
+from omlish.lite.fdio.pollers import PollFdIoPoller  # noqa
+from omlish.lite.fdio.pollers import SelectFdIoPoller
 from omlish.lite.inject import InjectorBindingOrBindings
 from omlish.lite.inject import InjectorBindings
 from omlish.lite.inject import inj
 
 from .configs import ServerConfig
-from .context import ServerContextImpl
-from .dispatchersimpl import InputDispatcherImpl
-from .dispatchersimpl import OutputDispatcherImpl
+from .dispatchersimpl import ProcessInputDispatcherImpl
+from .dispatchersimpl import ProcessOutputDispatcherImpl
 from .events import EventCallbacks
 from .groups import ProcessGroupManager
 from .groupsimpl import ProcessFactory
 from .groupsimpl import ProcessGroupImpl
-from .poller import Poller
-from .poller import get_poller_impl
+from .http import HttpServer
+from .http import SupervisorHttpHandler
+from .io import HasDispatchersList
+from .io import IoManager
 from .process import PidHistory
 from .processimpl import ProcessImpl
 from .processimpl import ProcessSpawningFactory
@@ -23,19 +29,32 @@ from .setup import DaemonizeListeners
 from .setup import SupervisorUser
 from .setupimpl import SupervisorSetup
 from .setupimpl import SupervisorSetupImpl
+from .signals import SignalHandler
 from .spawningimpl import InheritedFds
-from .spawningimpl import InputDispatcherFactory
-from .spawningimpl import OutputDispatcherFactory
+from .spawningimpl import ProcessInputDispatcherFactory
+from .spawningimpl import ProcessOutputDispatcherFactory
 from .spawningimpl import ProcessSpawningImpl
 from .supervisor import ProcessGroupFactory
-from .supervisor import SignalHandler
 from .supervisor import Supervisor
-from .types import ServerContext
+from .supervisor import SupervisorStateManagerImpl
+from .types import HasDispatchers
 from .types import ServerEpoch
+from .types import SupervisorStateManager
 from .utils.signals import SignalReceiver
 from .utils.users import get_user
 
 
+@dc.dataclass(frozen=True)
+class _FdIoPollerDaemonizeListener(DaemonizeListener):
+    _poller: FdIoPoller
+
+    def before_daemonize(self) -> None:
+        self._poller.close()
+
+    def after_daemonize(self) -> None:
+        self._poller.reopen()
+
+
 def bind_server(
         config: ServerConfig,
         *,
@@ -45,24 +64,30 @@ def bind_server(
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(config),
 
+        inj.bind_array(DaemonizeListener),
         inj.bind_array_type(DaemonizeListener, DaemonizeListeners),
 
         inj.bind(SupervisorSetupImpl, singleton=True),
         inj.bind(SupervisorSetup, to_key=SupervisorSetupImpl),
 
-        inj.bind(DaemonizeListener, array=True, to_key=Poller),
-
-        inj.bind(ServerContextImpl, singleton=True),
-        inj.bind(ServerContext, to_key=ServerContextImpl),
-
         inj.bind(EventCallbacks, singleton=True),
 
         inj.bind(SignalReceiver, singleton=True),
 
+        inj.bind(IoManager, singleton=True),
+        inj.bind_array(HasDispatchers),
+        inj.bind_array_type(HasDispatchers, HasDispatchersList),
+
         inj.bind(SignalHandler, singleton=True),
+
         inj.bind(ProcessGroupManager, singleton=True),
+        inj.bind(HasDispatchers, array=True, to_key=ProcessGroupManager),
+
         inj.bind(Supervisor, singleton=True),
 
+        inj.bind(SupervisorStateManagerImpl, singleton=True),
+        inj.bind(SupervisorStateManager, to_key=SupervisorStateManagerImpl),
+
         inj.bind(PidHistory()),
 
         inj.bind_factory(ProcessGroupImpl, ProcessGroupFactory),
@@ -70,8 +95,8 @@ def bind_server(
 
         inj.bind_factory(ProcessSpawningImpl, ProcessSpawningFactory),
 
-        inj.bind_factory(OutputDispatcherImpl, OutputDispatcherFactory),
-        inj.bind_factory(InputDispatcherImpl, InputDispatcherFactory),
+        inj.bind_factory(ProcessOutputDispatcherImpl, ProcessOutputDispatcherFactory),
+        inj.bind_factory(ProcessInputDispatcherImpl, ProcessInputDispatcherFactory),
     ]
 
     #
@@ -89,7 +114,26 @@ def bind_server(
 
     #
 
-    lst.append(inj.bind(get_poller_impl(), key=Poller, singleton=True))
+    poller_impl = next(filter(None, [
+        KqueueFdIoPoller,
+        PollFdIoPoller,
+        SelectFdIoPoller,
+    ]))
+    lst.append(inj.bind(poller_impl, key=FdIoPoller, singleton=True))
+    inj.bind(_FdIoPollerDaemonizeListener, array=True, singleton=True)
+
+    #
+
+    def _provide_http_handler(s: SupervisorHttpHandler) -> HttpServer.Handler:
+        return HttpServer.Handler(s.handle)
+
+    lst.extend([
+        inj.bind(HttpServer, singleton=True, eager=True),
+        inj.bind(HasDispatchers, array=True, to_key=HttpServer),
+
+        inj.bind(SupervisorHttpHandler, singleton=True),
+        inj.bind(_provide_http_handler),
+    ])
 
     #
 

ominfra/supervisor/io.py

@@ -0,0 +1,97 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.fdio.pollers import FdIoPoller
+from omlish.lite.logs import log
+
+from .dispatchers import Dispatchers
+from .types import ExitNow
+from .types import HasDispatchers
+from .utils.ostypes import Fd
+
+
+##
+
+
+HasDispatchersList = ta.NewType('HasDispatchersList', ta.Sequence[HasDispatchers])
+
+
+class IoManager(HasDispatchers):
+    def __init__(
+            self,
+            *,
+            poller: FdIoPoller,
+            has_dispatchers_list: HasDispatchersList,
+    ) -> None:
+        super().__init__()
+
+        self._poller = poller
+        self._has_dispatchers_list = has_dispatchers_list
+
+    def get_dispatchers(self) -> Dispatchers:
+        return Dispatchers(
+            d
+            for hd in self._has_dispatchers_list
+            for d in hd.get_dispatchers()
+        )
+
+    def poll(self) -> None:
+        dispatchers = self.get_dispatchers()
+
+        self._poller.update(
+            {fd for fd, d in dispatchers.items() if d.readable()},
+            {fd for fd, d in dispatchers.items() if d.writable()},
+        )
+
+        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
+        log.info(f'Polling: {timeout=}')  # noqa
+        polled = self._poller.poll(timeout)
+        log.info(f'Polled: {polled=}')  # noqa
+        if polled.msg is not None:
+            log.error(polled.msg)
+        if polled.exc is not None:
+            log.error('Poll exception: %r', polled.exc)
+
+        for r in polled.r:
+            fd = Fd(r)
+            if fd in dispatchers:
+                dispatcher = dispatchers[fd]
+                try:
+                    log.debug('read event caused by %r', dispatcher)
+                    dispatcher.on_readable()
+                    if not dispatcher.readable():
+                        self._poller.unregister_readable(fd)
+                except ExitNow:
+                    raise
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
+            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._poller.unregister_readable(fd)
+                except Exception:  # noqa
+                    pass
+
+        for w in polled.w:
+            fd = Fd(w)
+            if fd in dispatchers:
+                dispatcher = dispatchers[fd]
+                try:
+                    log.debug('write event caused by %r', dispatcher)
+                    dispatcher.on_writable()
+                    if not dispatcher.writable():
+                        self._poller.unregister_writable(fd)
+                except ExitNow:
+                    raise
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
+            else:
+                log.debug('unexpected write event from fd %r', fd)
+                try:
+                    self._poller.unregister_writable(fd)
+                except Exception:  # noqa
+                    pass

ominfra/supervisor/main.py

@@ -37,17 +37,17 @@ from omlish.lite.http.coroserver import CoroHttpServer
 from omlish.lite.inject import inj
 from omlish.lite.journald import journald_log_handler_factory
 from omlish.lite.logs import configure_standard_logging
+from omlish.lite.runtime import is_debugger_attached
 
 from ..configs import read_config_file
 from .configs import ServerConfig
 from .configs import prepare_server_config
-from .context import ServerContextImpl
-from .context import ServerEpoch
 from .inject import bind_server
 from .spawningimpl import InheritedFds
 from .states import SupervisorState
-from .supervisor import ExitNow
 from .supervisor import Supervisor
+from .types import ExitNow
+from .types import ServerEpoch
 from .utils.fds import get_open_fds
 
 
@@ -79,7 +79,7 @@ def main(
     if not no_logging:
         configure_standard_logging(
             'INFO',
-            handler_factory=journald_log_handler_factory if not args.no_journald else None,
+            handler_factory=journald_log_handler_factory if not (args.no_journald or is_debugger_attached()) else None,
         )
 
     #
@@ -102,7 +102,6 @@ def main(
             inherited_fds=inherited_fds,
         ))
 
-        context = injector[ServerContextImpl]
         supervisor = injector[Supervisor]
 
         try:
@@ -110,7 +109,7 @@ def main(
         except ExitNow:
             pass
 
-        if context.state < SupervisorState.RESTARTING:
+        if supervisor.state < SupervisorState.RESTARTING:
             break