omlish 0.0.0.dev242__py3-none-any.whl → 0.0.0.dev244__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev242'
-__revision__ = '0866b8cd6f11d42061b0949c01a15583a1a6b39d'
+__version__ = '0.0.0.dev244'
+__revision__ = 'e7768b1afd9f43a5f1534c2840691f48c0a89efb'
 
 
 #

omlish/asyncs/asyncio/sockets.py

@@ -0,0 +1,45 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio
+import typing as ta
+
+from ...lite.timeouts import Timeout
+from ...lite.timeouts import TimeoutLike
+
+
+async def asyncio_wait_until_can_connect(
+        host: ta.Any = None,
+        port: ta.Any = None,
+        *,
+        timeout: ta.Optional[TimeoutLike] = None,
+        on_fail: ta.Optional[ta.Callable[[BaseException], None]] = None,
+        sleep_s: float = .1,
+        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (Exception,),
+) -> None:
+    timeout = Timeout.of(timeout)
+
+    async def inner():
+        while True:
+            timeout()
+
+            try:
+                reader, writer = await asyncio.open_connection(host, port)
+
+            except asyncio.CancelledError:
+                raise
+
+            except exception as e:  # noqa
+                if on_fail is not None:
+                    on_fail(e)
+
+            else:
+                writer.close()
+                await asyncio.wait_for(writer.wait_closed(), timeout=timeout.or_(None))
+                break
+
+            await asyncio.sleep(min(sleep_s, timeout.remaining()))
+
+    if timeout() != float('inf'):
+        await asyncio.wait_for(inner(), timeout=timeout())
+    else:
+        await inner()

omlish/daemons/daemon.py

@@ -48,7 +48,9 @@ class Daemon:
 
         #
 
+        # TODO: None, defaults, figure out from spawn method
         reparent_process: bool = False
+
         launched_timeout_s: float = 5.
 
         #
@@ -126,7 +128,7 @@ class Daemon:
 
     #
 
-    def launch_no_wait(self) -> None:
+    def launch_no_wait(self) -> bool:
         launcher = Launcher(
             target=self._target,
             spawning=check.not_none(self._config.spawning),
@@ -136,7 +138,7 @@ class Daemon:
             launched_timeout_s=self._config.launched_timeout_s,
         )
 
-        launcher.launch()
+        return launcher.launch()
 
     def launch(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
         self.launch_no_wait()

omlish/daemons/launching.py

@@ -53,8 +53,10 @@ class Launcher:
             self,
             *,
             pidfile_manager: ta.ContextManager | None,
-            launched_callback: ta.Callable[[], None] | None = None,
+            callback: ta.Callable[[], None] | None = None,
     ) -> None:
+        callback_called = False
+
         try:
             if self._reparent_process:
                 log.info('Reparenting')
@@ -66,15 +68,16 @@ class Launcher:
                     pidfile = check.isinstance(es.enter_context(pidfile_manager), Pidfile)
                     pidfile.write()
 
-                if launched_callback is not None:
-                    launched_callback()
+                if callback is not None:
+                    callback_called = True
+                    callback()
 
                 runner = target_runner_for(self._target)
                 runner.run()
 
         finally:
-            if launched_callback is not None:
-                launched_callback()
+            if callback is not None and not callback_called:
+                callback()
 
     def launch(self) -> bool:
         with contextlib.ExitStack() as es:
@@ -110,8 +113,9 @@ class Launcher:
                 functools.partial(
                     self._inner_launch,
                     pidfile_manager=pidfile_manager,
-                    launched_callback=launched_event.set if launched_event is not None else None,
+                    callback=launched_event.set if launched_event is not None else None,
                 ),
+                target=self._target,
                 inherit_fds=inherit_fds,
             ))
 

omlish/daemons/reparent.py

@@ -2,7 +2,10 @@ import os
 import sys
 
 
-def reparent_process() -> None:
+def reparent_process(
+        *,
+        no_close_stdio: bool = False,
+) -> None:
     if (pid := os.fork()):  # noqa
         sys.exit(0)
         raise RuntimeError('Unreachable')  # noqa
@@ -12,5 +15,15 @@ def reparent_process() -> None:
     if (pid := os.fork()):  # noqa
         sys.exit(0)
 
+    if not no_close_stdio:
+        rn_fd = os.open('/dev/null', os.O_RDONLY)
+        os.dup2(rn_fd, 0)
+        os.close(rn_fd)
+
+        wn_fd = os.open('/dev/null', os.O_WRONLY)
+        os.dup2(wn_fd, 1)
+        os.dup2(wn_fd, 2)
+        os.close(wn_fd)
+
     sys.stdout.flush()
     sys.stderr.flush()

omlish/daemons/services.py

@@ -1,4 +1,5 @@
 import abc
+import threading
 import typing as ta
 
 from .. import cached
@@ -12,6 +13,7 @@ from .targets import TargetRunner
 from .targets import target_runner_for
 
 
+ServiceT = ta.TypeVar('ServiceT', bound='Service')
 ServiceConfigT = ta.TypeVar('ServiceConfigT', bound='Service.Config')
 
 
@@ -82,27 +84,53 @@ def _(target: ServiceConfigTarget) -> ServiceConfigTargetRunner:
 
 
 @dc.dataclass(frozen=True)
-class ServiceDaemon(lang.Final):
-    service: Service | Service.Config
+class ServiceDaemon(lang.Final, ta.Generic[ServiceT, ServiceConfigT]):
+    service: ServiceT | ServiceConfigT
 
     @cached.function
-    def service_(self) -> Service:
-        if isinstance(self.service, Service):
-            return self.service
-        elif isinstance(self.service, Service.Config):
-            return Service.from_config(self.service)
-        else:
-            raise TypeError(self.service)
+    def service_config(self) -> ServiceConfigT:
+        with self._lock:
+            if isinstance(self.service, Service):
+                return self.service.config
+            elif isinstance(self.service, Service.Config):
+                return self.service
+            else:
+                raise TypeError(self.service)
+
+    @cached.function
+    def service_(self) -> ServiceT:
+        with self._lock:
+            if isinstance(self.service, Service):
+                return self.service  # type: ignore[return-value]
+            elif isinstance(self.service, Service.Config):
+                return Service.from_config(self.service)  # type: ignore[return-value]
+            else:
+                raise TypeError(self.service)
 
     #
 
     daemon: Daemon | Daemon.Config = Daemon.Config()
 
+    @cached.function
+    def daemon_config(self) -> Daemon.Config:
+        with self._lock:
+            if isinstance(self.daemon, Daemon):
+                return self.daemon.config
+            elif isinstance(self.daemon, Daemon.Config):
+                return self.daemon
+            else:
+                raise TypeError(self.daemon)
+
     @cached.function
     def daemon_(self) -> Daemon:
-        if isinstance(self.daemon, Daemon):
-            return self.daemon
-        elif isinstance(self.daemon, Daemon.Config):
-            return Daemon(Target.of(self.service_()), self.daemon)
-        else:
-            raise TypeError(self.daemon)
+        with self._lock:
+            if isinstance(self.daemon, Daemon):
+                return self.daemon
+            elif isinstance(self.daemon, Daemon.Config):
+                return Daemon(Target.of(self.service_()), self.daemon)
+            else:
+                raise TypeError(self.daemon)
+
+    #
+
+    _lock: threading.RLock = dc.field(default_factory=lambda: threading.RLock(), init=False)

omlish/daemons/spawning.py

@@ -1,4 +1,5 @@
 import abc
+import enum
 import functools
 import os
 import sys
@@ -9,6 +10,7 @@ from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from ..diag import pydevd
+from .targets import Target
 
 
 if ta.TYPE_CHECKING:
@@ -37,6 +39,8 @@ class Spawn(dc.Frozen, final=True):
 
     _: dc.KW_ONLY
 
+    target: Target | None = None
+
     inherit_fds: ta.Collection[int] | None = None
 
 
@@ -59,10 +63,29 @@ def spawner_for(spawning: Spawning) -> Spawner:
 
 
 class MultiprocessingSpawning(Spawning, kw_only=True):
+    class StartMethod(enum.Enum):
+        SPAWN = enum.auto()
+        FORK = enum.auto()
+        # TODO: FORK_SERVER
+
     # Defaults to 'fork' if under pydevd, else 'spawn'
-    start_method: str | None = None
+    start_method: StartMethod | None = None
+
+    #
+
+    # Note: Per multiprocessing docs, `no_linger=True` processes (corresponding to `Process(daemon=True)`) cannot spawn
+    # subprocesses, and thus will fail if `Daemon.Config.reparent_process` is set.
+    no_linger: bool = False
 
-    non_daemon: bool = False
+    #
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class EntrypointArgs:
+        spawning: 'MultiprocessingSpawning'
+        spawn: Spawn
+        start_method: 'MultiprocessingSpawning.StartMethod'
+
+    entrypoint: ta.Callable[[EntrypointArgs], None] | None = None
 
 
 class MultiprocessingSpawner(Spawner):
@@ -72,20 +95,26 @@ class MultiprocessingSpawner(Spawner):
         self._spawning = spawning
         self._process: ta.Optional['mp.process.BaseProcess'] = None  # noqa
 
+    @lang.cached_function
+    def _determine_start_method(self) -> 'MultiprocessingSpawning.StartMethod':
+        if (start_method := self._spawning.start_method) is not None:
+            return start_method
+
+        # Unfortunately, pydevd forces the use of the 'fork' start_method, which cannot be mixed with 'spawn':
+        #   https://github.com/python/cpython/blob/a7427f2db937adb4c787754deb4c337f1894fe86/Lib/multiprocessing/spawn.py#L102  # noqa
+        if pydevd.is_running():
+            return MultiprocessingSpawning.StartMethod.FORK
+
+        return MultiprocessingSpawning.StartMethod.SPAWN
+
     def _process_cls(self, spawn: Spawn) -> type['mp.process.BaseProcess']:
-        if (start_method := self._spawning.start_method) is None:
-            # Unfortunately, pydevd forces the use of the 'fork' start_method, which cannot be mixed with 'spawn':
-            #   https://github.com/python/cpython/blob/a7427f2db937adb4c787754deb4c337f1894fe86/Lib/multiprocessing/spawn.py#L102  # noqa
-            if pydevd.is_running():
-                start_method = 'fork'
-            else:
-                start_method = 'spawn'
+        start_method = self._determine_start_method()
 
         ctx: 'mp.context.BaseContext'  # noqa
-        if start_method == 'fork':
-            ctx = mp.get_context(check.non_empty_str(start_method))
+        if start_method == MultiprocessingSpawning.StartMethod.FORK:
+            ctx = mp.get_context(check.non_empty_str('fork'))
 
-        elif start_method == 'spawn':
+        elif start_method == MultiprocessingSpawning.StartMethod.SPAWN:
             ctx = omp_spawn.ExtrasSpawnContext(omp_spawn.SpawnExtras(
                 pass_fds=frozenset(spawn.inherit_fds) if spawn.inherit_fds is not None else None,
             ))
@@ -97,9 +126,20 @@ class MultiprocessingSpawner(Spawner):
 
     def spawn(self, spawn: Spawn) -> None:
         check.none(self._process)
+
+        target: ta.Callable[[], None]
+        if (ep := self._spawning.entrypoint) is not None:
+            target = functools.partial(ep, MultiprocessingSpawning.EntrypointArgs(
+                spawning=self._spawning,
+                spawn=spawn,
+                start_method=self._determine_start_method(),
+            ))
+        else:
+            target = spawn.fn
+
         self._process = self._process_cls(spawn)(
-            target=spawn.fn,
-            daemon=not self._spawning.non_daemon,
+            target=target,
+            daemon=self._spawning.no_linger,
         )
         self._process.start()
 
@@ -142,7 +182,7 @@ def _(spawning: ForkSpawning) -> ForkSpawner:
 
 
 class ThreadSpawning(Spawning, kw_only=True):
-    non_daemon: bool = False
+    linger: bool = False
 
 
 class ThreadSpawner(InProcessSpawner):
@@ -156,7 +196,7 @@ class ThreadSpawner(InProcessSpawner):
         check.none(self._thread)
         self._thread = threading.Thread(
             target=spawn.fn,
-            daemon=not self._spawning.non_daemon,
+            daemon=not self._spawning.linger,
         )
         self._thread.start()
 

omlish/http/coro/simple.py

@@ -43,6 +43,7 @@ def make_simple_http_server(
         ignore_ssl_errors: bool = False,
         executor: ta.Optional[cf.Executor] = None,
         use_threads: bool = False,
+        **kwargs: ta.Any,
 ) -> ta.Iterator[SocketServer]:
     check.arg(not (executor is not None and use_threads))
 
@@ -107,6 +108,7 @@ def make_simple_http_server(
         server = es.enter_context(SocketServer(
             SocketBinder.of(bind),
             server_handler,
+            **kwargs,
         ))
 
         yield server

omlish/lang/__init__.py

@@ -54,18 +54,15 @@ from .cmp import (  # noqa
 
 from .contextmanagers import (  # noqa
     AsyncContextManager,
-    AsyncExitStacked,
     ContextManaged,
     ContextManager,
     ContextWrapped,
     DefaultLockable,
-    ExitStacked,
     Lockable,
     NOP_CONTEXT_MANAGER,
     NopContextManager,
     Timer,
     a_defer,
-    attr_setting,
     breakpoint_on_exception,
     context_var_setting,
     context_wrapped,
@@ -232,6 +229,12 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.contextmanagers import (  # noqa
+    attr_setting,
+    AsyncExitStacked,
+    ExitStacked,
+)
+
 from ..lite.imports import (  # noqa
     import_attr,
     import_module,

omlish/lang/contextmanagers.py

@@ -170,103 +170,6 @@ def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T
         var.reset(token)
 
 
-@contextlib.contextmanager
-def attr_setting(obj, attr, val, *, default=None):  # noqa
-    not_set = object()
-    orig = getattr(obj, attr, not_set)
-    try:
-        setattr(obj, attr, val)
-        if orig is not not_set:
-            yield orig
-        else:
-            yield default
-    finally:
-        if orig is not_set:
-            delattr(obj, attr)
-        else:
-            setattr(obj, attr, orig)
-
-
-##
-
-
-class ExitStacked:
-    @property
-    def _exit_stack(self) -> contextlib.ExitStack:
-        try:
-            return self.__exit_stack  # type: ignore
-        except AttributeError:
-            es = self.__exit_stack = contextlib.ExitStack()
-            return es
-
-    def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
-        return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
-
-    def __enter__(self) -> ta.Self:
-        try:
-            superfn = super().__enter__  # type: ignore
-        except AttributeError:
-            ret = self
-        else:
-            ret = superfn()
-        self._exit_stack.__enter__()
-        return ret
-
-    def __exit__(
-            self,
-            exc_type: type[BaseException] | None,
-            exc_val: BaseException | None,
-            exc_tb: types.TracebackType | None,
-    ) -> bool | None:
-        self._exit_stack.__exit__(exc_type, exc_val, exc_tb)
-        try:
-            superfn = super().__exit__  # type: ignore
-        except AttributeError:
-            return None
-        else:
-            return superfn(exc_type, exc_val, exc_tb)
-
-
-class AsyncExitStacked:
-    @property
-    def _exit_stack(self) -> contextlib.AsyncExitStack:
-        try:
-            return self.__exit_stack  # type: ignore
-        except AttributeError:
-            es = self.__exit_stack = contextlib.AsyncExitStack()
-            return es
-
-    async def _enter_async_context(self, context_manager: ta.AsyncContextManager[T]) -> T:
-        return await self._exit_stack.enter_async_context(ta.cast(ta.AsyncContextManager, context_manager))
-
-    def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
-        return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
-
-    async def __aenter__(self) -> ta.Self:
-        try:
-            superfn = super().__aenter__  # type: ignore
-        except AttributeError:
-            ret = self
-        else:
-            ret = await superfn()
-        await self._exit_stack.__aenter__()
-        return ret
-
-    async def __aexit__(
-            self,
-            exc_type: type[BaseException] | None,
-            exc_val: BaseException | None,
-            exc_tb: types.TracebackType | None,
-    ) -> bool | None:
-        await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
-        try:
-            superfn = super().__aexit__  # type: ignore
-        except AttributeError:
-            return None
-        else:
-            return await superfn(exc_type, exc_val, exc_tb)
-
-
 ##
 
 

omlish/lite/contextmanagers.py

@@ -1,5 +1,6 @@
 # ruff: noqa: UP007
 import contextlib
+import sys
 import typing as ta
 
 from .check import check
@@ -14,20 +15,64 @@ AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
 
 
 class ExitStacked:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__enter__', '__exit__'):
+            for b in cls.__bases__:
+                if b is ExitStacked:
+                    continue
+                try:
+                    fn = getattr(b, a)
+                except AttributeError:
+                    pass
+                else:
+                    if fn is not getattr(ExitStacked, a):
+                        raise TypeError(f'ExitStacked subclass {cls} must not not override {a} via {b}')
+
     _exit_stack: ta.Optional[contextlib.ExitStack] = None
 
-    def __enter__(self: ExitStackedT) -> ExitStackedT:
-        check.state(self._exit_stack is None)
-        es = self._exit_stack = contextlib.ExitStack()
-        es.__enter__()
-        return self
+    @contextlib.contextmanager
+    def _exit_stacked_init_wrapper(self) -> ta.Iterator[None]:
+        """
+        Overridable wrapper around __enter__ which deliberately does not have access to an _exit_stack yet. Intended for
+        things like wrapping __enter__ in a lock.
+        """
+
+        yield
 
+    @ta.final
+    def __enter__(self: ExitStackedT) -> ExitStackedT:
+        """
+        Final because any contexts entered during this init must be exited if any exception is thrown, and user
+        overriding would likely interfere with that. Override `_enter_contexts` for such init.
+        """
+
+        with self._exit_stacked_init_wrapper():
+            check.state(self._exit_stack is None)
+            es = self._exit_stack = contextlib.ExitStack()
+            es.__enter__()
+            try:
+                self._enter_contexts()
+            except Exception:  # noqa
+                es.__exit__(*sys.exc_info())
+                raise
+            return self
+
+    @ta.final
     def __exit__(self, exc_type, exc_val, exc_tb):
         if (es := self._exit_stack) is None:
             return None
-        self._exit_contexts()
+        try:
+            self._exit_contexts()
+        except Exception:  # noqa
+            es.__exit__(*sys.exc_info())
+            raise
         return es.__exit__(exc_type, exc_val, exc_tb)
 
+    def _enter_contexts(self) -> None:
+        pass
+
     def _exit_contexts(self) -> None:
         pass
 
@@ -37,20 +82,54 @@ class ExitStacked:
 
 
 class AsyncExitStacked:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__aenter__', '__aexit__'):
+            for b in cls.__bases__:
+                if b is AsyncExitStacked:
+                    continue
+                try:
+                    fn = getattr(b, a)
+                except AttributeError:
+                    pass
+                else:
+                    if fn is not getattr(AsyncExitStacked, a):
+                        raise TypeError(f'AsyncExitStacked subclass {cls} must not not override {a} via {b}')
+
     _exit_stack: ta.Optional[contextlib.AsyncExitStack] = None
 
-    async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
-        check.state(self._exit_stack is None)
-        es = self._exit_stack = contextlib.AsyncExitStack()
-        await es.__aenter__()
-        return self
+    @contextlib.asynccontextmanager
+    async def _async_exit_stacked_init_wrapper(self) -> ta.AsyncGenerator[None, None]:
+        yield
 
+    @ta.final
+    async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
+        async with self._async_exit_stacked_init_wrapper():
+            check.state(self._exit_stack is None)
+            es = self._exit_stack = contextlib.AsyncExitStack()
+            await es.__aenter__()
+            try:
+                await self._async_enter_contexts()
+            except Exception:  # noqa
+                await es.__aexit__(*sys.exc_info())
+                raise
+            return self
+
+    @ta.final
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         if (es := self._exit_stack) is None:
             return None
-        await self._async_exit_contexts()
+        try:
+            await self._async_exit_contexts()
+        except Exception:  # noqa
+            await es.__aexit__(*sys.exc_info())
+            raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)
 
+    async def _async_enter_contexts(self) -> None:
+        pass
+
     async def _async_exit_contexts(self) -> None:
         pass
 

omlish/logs/protocol.py

@@ -23,25 +23,25 @@ class Logging(ta.Protocol):
 
     #
 
-    def debug(self, msg: str, *args, **kwargs) -> None:
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def info(self, msg: str, *args, **kwargs) -> None:
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def warning(self, msg: str, *args, **kwargs) -> None:
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def error(self, msg: str, *args, **kwargs) -> None:
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def exception(self, msg: str, *args, exc_info=True, **kwargs) -> None:
+    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs) -> None:
         ...
 
-    def critical(self, msg: str, *args, **kwargs) -> None:
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
-    def log(self, level: LogLevel, msg: str, *args, **kwargs) -> None:
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         ...
 
 
@@ -66,30 +66,30 @@ class AbstractLogging(abc.ABC):
 
     #
 
-    def debug(self, msg: str, *args, **kwargs) -> None:
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.DEBUG):
             self.log(logging.DEBUG, msg, args, **kwargs)
 
-    def info(self, msg: str, *args, **kwargs) -> None:
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.INFO):
             self.log(logging.INFO, msg, args, **kwargs)
 
-    def warning(self, msg: str, *args, **kwargs) -> None:
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.WARNING):
             self.log(logging.WARNING, msg, args, **kwargs)
 
-    def error(self, msg: str, *args, **kwargs) -> None:
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.ERROR):
             self.log(logging.ERROR, msg, args, **kwargs)
 
-    def exception(self, msg: str, *args, exc_info=True, **kwargs) -> None:
+    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs: ta.Any) -> None:
         self.error(msg, *args, exc_info=exc_info, **kwargs)
 
-    def critical(self, msg: str, *args, **kwargs) -> None:
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if self.is_enabled_for(logging.CRITICAL):
             self.log(logging.CRITICAL, msg, args, **kwargs)
 
-    def log(self, level: LogLevel, msg: str, *args, **kwargs) -> None:
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if not isinstance(level, int):
             raise TypeError('Level must be an integer.')
         if self.is_enabled_for(level):

omlish/sockets/server/server.py

@@ -2,11 +2,14 @@
 # ruff: noqa: UP006 UP007
 import abc
 import contextlib
+import enum
 import logging
 import selectors
 import threading
 import typing as ta
 
+from ...lite.contextmanagers import ExitStacked
+from ...lite.contextmanagers import defer
 from ..addresses import SocketAndAddress
 from ..bind import SocketBinder
 from ..io import close_socket_immediately
@@ -76,58 +79,88 @@ class SocketServer(abc.ABC):
 
     #
 
-    @contextlib.contextmanager
-    def _listen_context(self) -> ta.Iterator[SelectorProtocol]:
-        with contextlib.ExitStack() as es:
-            es.enter_context(self._lock)
-            es.enter_context(self._binder)
+    class PollResult(enum.Enum):
+        TIMEOUT = enum.auto()
+        CONNECTION = enum.auto()
+        ERROR = enum.auto()
+        SHUTDOWN = enum.auto()
 
-            self._binder.listen()
+    class PollContext(ExitStacked, abc.ABC):
+        @abc.abstractmethod
+        def poll(self, timeout: ta.Optional[float] = None) -> 'SocketServer.PollResult':
+            raise NotImplementedError
 
-            self._is_shutdown.clear()
-            try:
-                # XXX: Consider using another file descriptor or connecting to the socket to wake this up instead of
-                # polling. Polling reduces our responsiveness to a shutdown request and wastes cpu at all other times.
-                with self.Selector() as selector:
-                    selector.register(self._binder.fileno(), selectors.EVENT_READ)
+    class _PollContext(PollContext):
+        def __init__(self, server: 'SocketServer') -> None:
+            super().__init__()
 
-                    yield selector
+            self._server = server
 
-            finally:
-                self._is_shutdown.set()
+        _selector: ta.Any = None
 
-    @contextlib.contextmanager
-    def loop_context(self, poll_interval: ta.Optional[float] = None) -> ta.Iterator[ta.Iterator[bool]]:
-        if poll_interval is None:
-            poll_interval = self._poll_interval
+        def _enter_contexts(self) -> None:
+            self._enter_context(self._server._lock)  # noqa: SLF001
+            self._enter_context(self._server._binder)  # noqa: SLF001
 
-        with self._listen_context() as selector:
-            def loop():
-                while not self._should_shutdown:
-                    ready = selector.select(poll_interval)
+            self._server._binder.listen()  # noqa: SLF001
+
+            self._server._is_shutdown.clear()  # noqa: SLF001
+            self._enter_context(defer(self._server._is_shutdown.set))  # noqa
+
+            # XXX: Consider using another file descriptor or connecting to the socket to wake this up instead of
+            # polling. Polling reduces our responsiveness to a shutdown request and wastes cpu at all other times.
+            self._selector = self._enter_context(self._server.Selector())
+            self._selector.register(self._server._binder.fileno(), selectors.EVENT_READ)  # noqa: SLF001
 
-                    # bpo-35017: shutdown() called during select(), exit immediately.
-                    if self._should_shutdown:
-                        break  # type: ignore[unreachable]
+        def poll(self, timeout: ta.Optional[float] = None) -> 'SocketServer.PollResult':
+            if self._server._should_shutdown:  # noqa: SLF001
+                return SocketServer.PollResult.SHUTDOWN
 
-                    if ready:
-                        try:
-                            conn = self._binder.accept()
+            ready = self._selector.select(timeout)
 
-                        except OSError as exc:
-                            self._handle_error(exc)
+            # bpo-35017: shutdown() called during select(), exit immediately.
+            if self._server._should_shutdown:  # noqa: SLF001
+                return SocketServer.PollResult.SHUTDOWN  # type: ignore[unreachable]
 
-                            return
+            if not ready:
+                return SocketServer.PollResult.TIMEOUT
 
-                        try:
-                            self._handler(conn)
+            try:
+                conn = self._server._binder.accept()  # noqa: SLF001
+
+            except OSError as exc:
+                self._server._handle_error(exc)  # noqa: SLF001
 
-                        except Exception as exc:  # noqa
-                            self._handle_error(exc, conn)
+                return SocketServer.PollResult.ERROR
 
-                            close_socket_immediately(conn.socket)
+            try:
+                self._server._handler(conn)  # noqa: SLF001
 
-                    yield bool(ready)
+            except Exception as exc:  # noqa
+                self._server._handle_error(exc, conn)  # noqa: SLF001
+
+                close_socket_immediately(conn.socket)
+
+            return SocketServer.PollResult.CONNECTION
+
+    def poll_context(self) -> PollContext:
+        return self._PollContext(self)
+
+    #
+
+    @contextlib.contextmanager
+    def loop_context(self, poll_interval: ta.Optional[float] = None) -> ta.Iterator[ta.Iterator[bool]]:
+        if poll_interval is None:
+            poll_interval = self._poll_interval
+
+        with self.poll_context() as pc:
+            def loop():
+                while True:
+                    res = pc.poll(poll_interval)
+                    if res in (SocketServer.PollResult.ERROR, SocketServer.PollResult.SHUTDOWN):
+                        return
+                    else:
+                        yield res == SocketServer.PollResult.CONNECTION
 
             yield loop()
 

omlish/sockets/wait.py

@@ -0,0 +1,61 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import socket
+import threading
+import typing as ta
+
+from ..lite.timeouts import Timeout
+from ..lite.timeouts import TimeoutLike
+
+
+##
+
+
+def socket_can_connect(
+        address: ta.Any,
+        *,
+        timeout: ta.Optional[TimeoutLike] = None,
+        on_fail: ta.Optional[ta.Callable[[BaseException], None]] = None,
+        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (ConnectionRefusedError,),
+) -> bool:
+    timeout = Timeout.of(timeout)
+
+    try:
+        conn = socket.create_connection(address, timeout=timeout.or_(None))
+
+    except exception as e:  # noqa
+        if on_fail is not None:
+            on_fail(e)
+        return False
+
+    else:
+        conn.close()
+        return True
+
+
+def socket_wait_until_can_connect(
+        address: ta.Any,
+        *,
+        timeout: ta.Optional[TimeoutLike] = None,
+        on_fail: ta.Optional[ta.Callable[[BaseException], None]] = None,
+        sleep_s: float = .1,
+        exception: ta.Union[ta.Type[BaseException], ta.Tuple[ta.Type[BaseException], ...]] = (ConnectionRefusedError,),
+        cancel_event: ta.Optional[threading.Event] = None,
+) -> None:
+    timeout = Timeout.of(timeout)
+
+    if cancel_event is None:
+        cancel_event = threading.Event()
+
+    while not cancel_event.is_set():
+        timeout()
+
+        if socket_can_connect(
+            address,
+            timeout=timeout,
+            on_fail=on_fail,
+            exception=exception,
+        ):
+            break
+
+        cancel_event.wait(min(sleep_s, timeout.remaining()))

{omlish-0.0.0.dev242.dist-info → omlish-0.0.0.dev244.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev242
+Version: 0.0.0.dev244
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev242.dist-info → omlish-0.0.0.dev244.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=vQTAIvR8OblSq-uP2GUfnbei0RnmAnM5j0T1-OToh9E,8253
-omlish/__about__.py,sha256=v3KofXu74aLHjSY2AMiIiv61EfsLsoedesWKEUsNxWA,3380
+omlish/__about__.py,sha256=I6B5uZQiJsqsRd0Vxt8abjKC5YXkiwOJFtBfeWlVYAM,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -101,6 +101,7 @@ omlish/asyncs/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 omlish/asyncs/asyncio/all.py,sha256=EksCHjRQKobiGrxuDW72IaH53WJMs7rdj_ZDBI3iKcg,315
 omlish/asyncs/asyncio/asyncio.py,sha256=mDjYNm1cylUhQ8slWXwdPoXasuWfafjzu78GHt2Mdig,2437
 omlish/asyncs/asyncio/channels.py,sha256=ZbmsEmdK1fV96liHdcVpRqA2dAMkXJt4Q3rFAg3YOIw,1074
+omlish/asyncs/asyncio/sockets.py,sha256=Ni5O80fNAccSMAGrlSkZ923Nawxi3FHoXrKj4nr0xlU,1266
 omlish/asyncs/asyncio/streams.py,sha256=Uc9PCWSfBqrK2kdVtfjjQU1eaYTWYmZm8QISDj2xiuw,1004
 omlish/asyncs/asyncio/subprocesses.py,sha256=f30-wi-3n9R5dftm4CMrzp23EEa4GX283bORixm1_UU,6931
 omlish/asyncs/asyncio/timeouts.py,sha256=hokhi7jZSAtBv0ME3qL1cO5eshNA9ViEH7BLafNCBpQ,454
@@ -179,11 +180,11 @@ omlish/configs/processing/names.py,sha256=weHmaTclzgM9lUn3aBtw-kwZ3mc2N-CZlFg3Kd
 omlish/configs/processing/rewriting.py,sha256=v7PfHtuTn5v_5Y6Au7oMN2Z0nxAMy1iYyO5CXnTvZhs,4226
 omlish/configs/processing/strings.py,sha256=qFS2oh6z02IaM_q4lTKLdufzkJqAJ6J-Qjrz5S-QJoM,826
 omlish/daemons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/daemons/daemon.py,sha256=ykdbCPbpxKrdZVZc892SnedTdftTAYt_YdDpYchKcUE,3410
-omlish/daemons/launching.py,sha256=mhtkuAO16STcznUl3rrX9pacfrKbPQRCP2AllKL4B70,3664
-omlish/daemons/reparent.py,sha256=UaG2X6VJHJPOlUwHPNRH3aWGgF0Fg771jjO9IRPLlyY,280
-omlish/daemons/services.py,sha256=UAzzdP4jG0-piVzz6CsSTPIjTGt4VFXtbzP7KczMCho,2354
-omlish/daemons/spawning.py,sha256=cx00xeqSrfhlFbjCtKqaBHvMuHwB9hdjuKNHzAAo_dw,4030
+omlish/daemons/daemon.py,sha256=3Wkvu8M_EaCKSpKI5UN5OayRXV0oVdF62tBss9_hlr0,3479
+omlish/daemons/launching.py,sha256=sNOYW939IGI4ZlLQ0bKxzXj6EyeOiwV7Upqhd5XfoHc,3747
+omlish/daemons/reparent.py,sha256=7uJ9oPGt9Ud7uA8bDl_SHcuqjcsmXa3kkjp9jf29wOw,585
+omlish/daemons/services.py,sha256=jIlGWhiWoqQlm_OFeffkSs9jjr-icDF1-I-SNMEgg9Y,3406
+omlish/daemons/spawning.py,sha256=psR73zOYjMKTqNpx1bMib8uU9wAZz62tw5TaWHrTdyY,5337
 omlish/daemons/targets.py,sha256=00KmtlknMhQ5PyyVAhWl3rpeTMPym0GxvHHq6mYPZ7c,3051
 omlish/daemons/waiting.py,sha256=RfgD1L33QQVbD2431dkKZGE4w6DUcGvYeRXXi8puAP4,1676
 omlish/dataclasses/__init__.py,sha256=b7EZCIfHnEHCHWwgD3YXxkdsU-uYd9iD4hM36RgpI1g,1598
@@ -332,7 +333,7 @@ omlish/http/wsgi.py,sha256=czZsVUX-l2YTlMrUjKN49wRoP4rVpS0qpeBn4O5BoMY,948
 omlish/http/coro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/coro/fdio.py,sha256=bd9K4EYVWbXV3e3npDPXI9DuDAruJiyDmrgFpgNcjzY,4035
 omlish/http/coro/server.py,sha256=30FTcJG8kuFeThf0HJYpTzMZN-giLTBP7wr5Wl3b9X0,18285
-omlish/http/coro/simple.py,sha256=_ZKFlfLda9Gatd3bNBNGJpITNQl4tuTAbL3P-Mr5j5w,3152
+omlish/http/coro/simple.py,sha256=inWA_ss6Nz5Rqmy4dL9_SGah4anYoDecDTRQqVIGYeY,3200
 omlish/http/coro/sockets.py,sha256=rtpZZ-XCOfC5tXr4Fmo1HSn-8f5nxfIOlJaPUkQeDyU,1654
 omlish/inject/__init__.py,sha256=n0RC9UDGsBQQ39cST39-XJqJPq2M0tnnh9yJubW9azo,1891
 omlish/inject/binder.py,sha256=DAbc8TZi5w8Mna0TUtq0mT4jeDVA7i7SlBtOFrh2swc,4185
@@ -398,11 +399,11 @@ omlish/iterators/iterators.py,sha256=ghI4dO6WPyyFOLTIIMaHQ_IOy2xXaFpGPqveZ5YGIBU
 omlish/iterators/recipes.py,sha256=53mkexitMhkwXQZbL6DrhpT0WePQ_56uXd5Jaw3DfzI,467
 omlish/iterators/tools.py,sha256=Pi4ybXytUXVZ3xwK89xpPImQfYYId9p1vIFQvVqVLqA,2551
 omlish/iterators/unique.py,sha256=0jAX3kwzVfRNhe0Tmh7kVP_Q2WBIn8POo_O-rgFV0rQ,1390
-omlish/lang/__init__.py,sha256=2jxO7QWT0uOvdYdmBFgnqmVh-6I7DofsapgUl3wu1fY,4145
+omlish/lang/__init__.py,sha256=T_hx_ygi-IqmeDPQ-uto2U4ZuAUDs-agOSAsF6WWLVI,4193
 omlish/lang/cached.py,sha256=tQaqMu1LID0q4NSTk5vPXsgxIBWSFAmjs5AhQoEHoCQ,7833
 omlish/lang/clsdct.py,sha256=sJYadm-fwzti-gsi98knR5qQUxriBmOqQE_qz3RopNk,1743
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
-omlish/lang/contextmanagers.py,sha256=Mrn8NJ3pP0Zxi-IoGqSjZDdWUctsyee2vrZ2FtZvNmo,10529
+omlish/lang/contextmanagers.py,sha256=UPH6daYwSP9cH5AfSVsJyEHk1UURMGhVPM5ZRhp_Hvw,7576
 omlish/lang/datetimes.py,sha256=ehI_DhQRM-bDxAavnp470XcekbbXc4Gdw9y1KpHDJT0,223
 omlish/lang/descriptors.py,sha256=mZ2h9zJ__MMpw8hByjRbAiONcwfVb6GD0btNnVi8C5w,6573
 omlish/lang/exceptions.py,sha256=qJBo3NU1mOWWm-NhQUHCY5feYXR3arZVyEHinLsmRH4,47
@@ -434,7 +435,7 @@ omlish/lite/__init__.py,sha256=ISLhM4q0LR1XXTCaHdZOZxBRyIsoZqYm4u0bf1BPcVk,148
 omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=OLwtE2x6nlbGx4vS3Rda7zMHpgqzDSLJminTAX2lqLA,13529
 omlish/lite/configs.py,sha256=Ev_19sbII67pTWzInYjYqa9VyTiZBvyjhZqyG8TtufE,908
-omlish/lite/contextmanagers.py,sha256=ciaMl0D3QDHToM7M28-kwZ-Q48LtwgCxiud3nekgutA,2863
+omlish/lite/contextmanagers.py,sha256=XSCwr9GpPBJxXR9Vr07M4A_BH3uLpZettyoSE5KqJu8,5566
 omlish/lite/dataclasses.py,sha256=t1G5-xOuvE6o6w9RyqHzLT9wHD0HkqBh5P8HUZWxGzs,1912
 omlish/lite/imports.py,sha256=o9WWrNrWg0hKeMvaj91giaovED_9VFanN2MyEHBGekY,1346
 omlish/lite/inject.py,sha256=-tTsOqqef-Ix5Tgl2DP_JAsNWJQDFUptERl3lk14Uzs,29007
@@ -462,7 +463,7 @@ omlish/logs/filters.py,sha256=2noFRyBez3y519fpfsDSt1vo8wX-85b8sMXZi5o_xyE,208
 omlish/logs/handlers.py,sha256=zgSnKQA5q9Fu7T0Nkd7twog9H1Wg9-bDCzz4_F1TOBo,319
 omlish/logs/json.py,sha256=zyqMWpZY3lk4WRk4wgmataBomGX9S3iDsydiM1sS-lI,1366
 omlish/logs/noisy.py,sha256=Ubc-eTH6ZbGYsLfUUi69JAotwuUwzb-SJBeGo_0dIZI,348
-omlish/logs/protocol.py,sha256=NzyCeNBN-fyKpJinhECfjUQSd5MxZLiYbuLCTtW6QUU,4500
+omlish/logs/protocol.py,sha256=dfAR0_5kLEAkx0nhuWBhWMTVjWjhEl2uL-MxejrW1lk,4732
 omlish/logs/proxy.py,sha256=A-ROPUUAlF397qTbEqhel6YhQMstNuXL3Xmts7w9dAo,2347
 omlish/logs/standard.py,sha256=FbKdF2Z4Na5i2TNwKn0avLJXyICe2JKsPufjvKCHGn0,3162
 omlish/logs/timing.py,sha256=XrFUHIPT4EHDujLKbGs9fGFMmoM3NEP8xPRaESJr7bQ,1513
@@ -565,9 +566,10 @@ omlish/sockets/bind.py,sha256=J1SfFFFnVf3H5nqESDX2NGEY8DmjyIMUXZciZM33zQY,8003
 omlish/sockets/handlers.py,sha256=Gj6xZoo4vommge8XvkehYw3B7O4aql2P4qzZIIa0p24,462
 omlish/sockets/io.py,sha256=lfhTkB7NnAIx9kuQhAkwgsEUXY78Mp1_WtYrIQNS_k8,1408
 omlish/sockets/ports.py,sha256=Wm4mRFFz5MdD8KbdaEfT1c4PbJnsuK_iyJlZJE_-8jo,1402
+omlish/sockets/wait.py,sha256=aznyOzGa9oNBc31xnyk1S7TylO8hGx7vFyOVsdY3zFE,1585
 omlish/sockets/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/sockets/server/handlers.py,sha256=PPsb1X5oU9dN8jfztaMGsRiqWTyEANT-1aSLbS6bUVg,3867
-omlish/sockets/server/server.py,sha256=mZmHPkCRPitous56_7FJdAsDLZag2wDqjj-LaYM8_Fg,4943
+omlish/sockets/server/server.py,sha256=FkaishIxJuU4it9tTI7wzlGqJYzFGXzDrd_HgV0jAmU,6253
 omlish/sockets/server/ssl.py,sha256=VE0GpdA-gYsN2m9_uvfDwWmXtIbRQqJomVdpGJO8o2M,1061
 omlish/sockets/server/threading.py,sha256=YmW3Ym_p5j_F4SIH9BgRHIObywjq1HS39j9CGWIcMAY,2856
 omlish/specs/__init__.py,sha256=zZwF8yXTEkSstYtORkDhVLK-_hWU8WOJCuBpognb_NY,118
@@ -727,9 +729,9 @@ omlish/text/mangle.py,sha256=kfzFLfvepH-chl1P89_mdc5vC4FSqyPA2aVtgzuB8IY,1133
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=JkNZpyR2tv2CNcTaWJJhpQ9E4F0yPR8P_YfDbZfMtwQ,6182
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev242.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev242.dist-info/METADATA,sha256=f11RfSbCLw8fvLQKc--nQePc_WBXEXJ_ljN3zB8QuvM,4176
-omlish-0.0.0.dev242.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-omlish-0.0.0.dev242.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev242.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev242.dist-info/RECORD,,
+omlish-0.0.0.dev244.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev244.dist-info/METADATA,sha256=7T41OvUEW2aOLkXNGyFicYfwqbooZHctPFTfjF0XpnQ,4176
+omlish-0.0.0.dev244.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+omlish-0.0.0.dev244.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev244.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev244.dist-info/RECORD,,