omlish 0.0.0.dev243__tar.gz → 0.0.0.dev244__tar.gz

{omlish-0.0.0.dev243/omlish.egg-info → omlish-0.0.0.dev244}/PKG-INFO

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

{omlish-0.0.0.dev243 → omlish-0.0.0.dev244}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev243'
-__revision__ = '97467f9facc16b72c3dac69aba18c543dce228b1'
+__version__ = '0.0.0.dev244'
+__revision__ = 'e7768b1afd9f43a5f1534c2840691f48c0a89efb'
 
 
 #

{omlish-0.0.0.dev243 → omlish-0.0.0.dev244}/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-0.0.0.dev243 → omlish-0.0.0.dev244}/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-0.0.0.dev244/omlish/daemons/reparent.py

@@ -0,0 +1,29 @@
+import os
+import sys
+
+
+def reparent_process(
+        *,
+        no_close_stdio: bool = False,
+) -> None:
+    if (pid := os.fork()):  # noqa
+        sys.exit(0)
+        raise RuntimeError('Unreachable')  # noqa
+
+    os.setsid()
+
+    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-0.0.0.dev243 → omlish-0.0.0.dev244}/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-0.0.0.dev243 → omlish-0.0.0.dev244}/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-0.0.0.dev243 → omlish-0.0.0.dev244}/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-0.0.0.dev244/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.dev243 → omlish-0.0.0.dev244/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev243 → omlish-0.0.0.dev244}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev243'
+version = '0.0.0.dev244'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev243/omlish/daemons/reparent.py

@@ -1,16 +0,0 @@
-import os
-import sys
-
-
-def reparent_process() -> None:
-    if (pid := os.fork()):  # noqa
-        sys.exit(0)
-        raise RuntimeError('Unreachable')  # noqa
-
-    os.setsid()
-
-    if (pid := os.fork()):  # noqa
-        sys.exit(0)
-
-    sys.stdout.flush()
-    sys.stderr.flush()

omlish-0.0.0.dev243/omlish/sockets/wait.py

@@ -1,39 +0,0 @@
-# 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_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], ...]] = (Exception,),
-        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()
-
-        try:
-            conn = socket.create_connection(address, timeout=timeout.or_(None))
-
-        except exception as e:  # noqa
-            if on_fail is not None:
-                on_fail(e)
-
-        else:
-            conn.close()
-            break
-
-        cancel_event.wait(min(sleep_s, timeout.remaining()))