omlish 0.0.0.dev230__py3-none-any.whl → 0.0.0.dev232__py3-none-any.whl

omlish/.manifests.json

@@ -307,6 +307,18 @@
       }
     }
   },
+  {
+    "module": ".os.pidfiles.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omlish/os/pidfiles/__main__.py",
+    "line": 1,
+    "value": {
+      "$omdev.cli.types.CliModule": {
+        "cmd_name": "pidfiles",
+        "mod_name": "omlish.os.pidfiles.__main__"
+      }
+    }
+  },
   {
     "module": ".secrets.pwgen",
     "attr": "_CLI_MODULE",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev230'
-__revision__ = 'ed2672ad6a2fb4718c57e281c5ce91fdc7998a6f'
+__version__ = '0.0.0.dev232'
+__revision__ = '2f0435f277c869f9ecf426be2aeaf08eeb9792de'
 
 
 #
@@ -37,7 +37,7 @@ class Project(ProjectBase):
 
             'greenlet ~= 3.1',
 
-            'trio ~= 0.27',
+            'trio ~= 0.29',
             'trio-asyncio ~= 0.15',
         ],
 
@@ -56,7 +56,7 @@ class Project(ProjectBase):
             'asttokens ~= 3.0',
             'executing ~= 2.2',
 
-            'psutil ~= 6.0',
+            'psutil ~= 7.0',
         ],
 
         'formats': [

omlish/daemons/daemon.py

@@ -0,0 +1,126 @@
+"""
+TODO:
+ - OK.. this is useful for non-system-daemons too... which have no pidfile..
+ - split out pidfile concern to.. identity?
+ - async[io] support, really just waiting
+ - helpers for http, json, etc
+ - heartbeat? status checks? heartbeat file?
+ - zmq
+ - cli, cfg reload
+ - bootstrap
+  - rsrc limit
+  - logs
+ - https://github.com/Homebrew/homebrew-services
+ - deathpacts
+ - timebomb
+ - pickle protocol, revision / venv check, multiprocessing manager support
+"""
+import logging
+import os.path
+import time
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from ..os.pidfiles.pidfile import Pidfile
+from .launching import Launcher
+from .spawning import Spawning
+from .targets import Target
+from .waiting import Wait
+from .waiting import waiter_for
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+class Daemon:
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Config:
+        target: Target
+        spawning: Spawning
+
+        #
+
+        pid_file: str | None = None
+
+        #
+
+        reparent_process: bool = False
+        launched_timeout_s: float = 5.
+
+        #
+
+        wait: Wait | None = None
+
+        wait_timeout: lang.TimeoutLike = 10.
+        wait_sleep_s: float = .1
+
+        #
+
+        def __post_init__(self) -> None:
+            check.isinstance(self.pid_file, (str, None))
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+
+        self._config = config
+
+    @property
+    def config(self) -> Config:
+        return self._config
+
+    #
+
+    @property
+    def has_pidfile(self) -> bool:
+        return self._config.pid_file is not None
+
+    def _non_inheritable_pidfile(self) -> Pidfile:
+        check.state(self.has_pidfile)
+        return Pidfile(
+            check.non_empty_str(self._config.pid_file),
+            inheritable=False,
+        )
+
+    def is_running(self) -> bool:
+        check.state(self.has_pidfile)
+
+        if not os.path.isfile(check.non_empty_str(self._config.pid_file)):
+            return False
+
+        with self._non_inheritable_pidfile() as pf:
+            return not pf.try_acquire_lock()
+
+    #
+
+    def wait_sync(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
+        if self._config.wait is None:
+            return
+
+        timeout = lang.Timeout.of(timeout, self._config.wait_timeout)
+        waiter = waiter_for(self._config.wait)
+        while not waiter.do_wait():
+            timeout()
+            time.sleep(self._config.wait_sleep_s or 0.)
+
+    #
+
+    def launch_no_wait(self) -> None:
+        launcher = Launcher(
+            target=self._config.target,
+            spawning=self._config.spawning,
+
+            pid_file=self._config.pid_file,
+            reparent_process=self._config.reparent_process,
+            launched_timeout_s=self._config.launched_timeout_s,
+        )
+
+        launcher.launch()
+
+    def launch(self, timeout: lang.TimeoutLike = lang.Timeout.Default) -> None:
+        self.launch_no_wait()
+
+        self.wait_sync(timeout)

omlish/daemons/launching.py

@@ -0,0 +1,121 @@
+"""
+TODO:
+ - Config? dedupe defaults with Daemon
+ - ExitStacked? hold ref to Spawner, which holds refs to thread/proc - which will likely outlive it, but still
+"""
+import contextlib
+import functools
+import logging
+import threading
+import typing as ta
+
+from .. import check
+from .. import lang
+from ..os.pidfiles.manager import open_inheritable_pidfile
+from ..os.pidfiles.pidfile import Pidfile
+from .reparent import reparent_process
+from .spawning import InProcessSpawner
+from .spawning import Spawn
+from .spawning import Spawner
+from .spawning import Spawning
+from .spawning import spawner_for
+from .targets import Target
+from .targets import target_runner_for
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+class Launcher:
+    def __init__(
+            self,
+            *,
+            target: Target,
+            spawning: Spawning,
+
+            pid_file: str | None = None,
+            reparent_process: bool = False,  # noqa
+            launched_timeout_s: float = 5.,
+    ) -> None:
+        super().__init__()
+
+        self._target = target
+        self._spawning = spawning
+
+        self._pid_file = pid_file
+        self._reparent_process = reparent_process
+        self._launched_timeout_s = launched_timeout_s
+
+    def _inner_launch(
+            self,
+            *,
+            pidfile_manager: ta.ContextManager | None,
+            launched_callback: ta.Callable[[], None] | None = None,
+    ) -> None:
+        try:
+            if self._reparent_process:
+                log.info('Reparenting')
+                reparent_process()
+
+            with contextlib.ExitStack() as es:
+                pidfile: Pidfile | None = None  # noqa
+                if pidfile_manager is not None:
+                    pidfile = check.isinstance(es.enter_context(pidfile_manager), Pidfile)
+                    pidfile.write()
+
+                if launched_callback is not None:
+                    launched_callback()
+
+                runner = target_runner_for(self._target)
+                runner.run()
+
+        finally:
+            if launched_callback is not None:
+                launched_callback()
+
+    def launch(self) -> bool:
+        with contextlib.ExitStack() as es:
+            spawner: Spawner = es.enter_context(spawner_for(self._spawning))
+
+            #
+
+            inherit_fds: set[int] = set()
+            launched_event: threading.Event | None = None
+
+            pidfile: Pidfile | None = None  # noqa
+            pidfile_manager: ta.ContextManager | None = None
+
+            if (pid_file := self._pid_file) is not None:
+                if not isinstance(spawner, InProcessSpawner):
+                    pidfile = es.enter_context(open_inheritable_pidfile(pid_file))
+                    pidfile_manager = lang.NopContextManager(pidfile)
+
+                else:
+                    check.state(not self._reparent_process)
+                    pidfile = es.enter_context(Pidfile(pid_file))
+                    pidfile_manager = pidfile.dup()
+                    launched_event = threading.Event()
+
+                if not pidfile.try_acquire_lock():
+                    return False
+
+                inherit_fds.add(check.isinstance(pidfile.fileno(), int))
+
+            #
+
+            spawner.spawn(Spawn(
+                functools.partial(
+                    self._inner_launch,
+                    pidfile_manager=pidfile_manager,
+                    launched_callback=launched_event.set if launched_event is not None else None,
+                ),
+                inherit_fds=inherit_fds,
+            ))
+
+            if launched_event is not None:
+                check.state(launched_event.wait(timeout=self._launched_timeout_s))
+
+            return True

omlish/daemons/reparent.py

@@ -0,0 +1,16 @@
+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/daemons/spawning.py

@@ -0,0 +1,166 @@
+import abc
+import functools
+import os
+import sys
+import threading
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from ..diag import pydevd
+
+
+if ta.TYPE_CHECKING:
+    import multiprocessing as mp
+    import multiprocessing.context
+    import multiprocessing.process  # noqa
+
+    from ..multiprocessing import spawn as omp_spawn
+
+else:
+    mp = lang.proxy_import('multiprocessing', extras=['context', 'process'])
+    subprocess = lang.proxy_import('subprocess')
+
+    omp_spawn = lang.proxy_import('..multiprocessing.spawn', __package__)
+
+
+##
+
+
+class Spawning(dc.Case):
+    pass
+
+
+class Spawn(dc.Frozen, final=True):
+    fn: ta.Callable[[], None]
+
+    _: dc.KW_ONLY
+
+    inherit_fds: ta.Collection[int] | None = None
+
+
+class Spawner(lang.ContextManaged, abc.ABC):
+    @abc.abstractmethod
+    def spawn(self, spawn: Spawn) -> None:
+        raise NotImplementedError
+
+
+class InProcessSpawner(Spawner, abc.ABC):
+    pass
+
+
+@functools.singledispatch
+def spawner_for(spawning: Spawning) -> Spawner:
+    raise TypeError(spawning)
+
+
+##
+
+
+class MultiprocessingSpawning(Spawning, kw_only=True):
+    # Defaults to 'fork' if under pydevd, else 'spawn'
+    start_method: str | None = None
+
+    non_daemon: bool = False
+
+
+class MultiprocessingSpawner(Spawner):
+    def __init__(self, spawning: MultiprocessingSpawning) -> None:
+        super().__init__()
+
+        self._spawning = spawning
+        self._process: ta.Optional['mp.process.BaseProcess'] = None  # noqa
+
+    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'
+
+        ctx: 'mp.context.BaseContext'  # noqa
+        if start_method == 'fork':
+            ctx = mp.get_context(check.non_empty_str(start_method))
+
+        elif start_method == 'spawn':
+            ctx = omp_spawn.ExtrasSpawnContext(omp_spawn.SpawnExtras(
+                pass_fds=frozenset(spawn.inherit_fds) if spawn.inherit_fds is not None else None,
+            ))
+
+        else:
+            raise ValueError(start_method)
+
+        return ctx.Process  # type: ignore
+
+    def spawn(self, spawn: Spawn) -> None:
+        check.none(self._process)
+        self._process = self._process_cls(spawn)(
+            target=spawn.fn,
+            daemon=not self._spawning.non_daemon,
+        )
+        self._process.start()
+
+
+@spawner_for.register
+def _(spawning: MultiprocessingSpawning) -> MultiprocessingSpawner:
+    return MultiprocessingSpawner(spawning)
+
+
+##
+
+
+class ForkSpawning(Spawning):
+    pass
+
+
+class ForkSpawner(Spawner, dc.Frozen):
+    spawning: ForkSpawning
+
+    def spawn(self, spawn: Spawn) -> None:
+        if (pid := os.fork()):  # noqa
+            return
+
+        try:
+            spawn.fn()
+        except BaseException:  # noqa
+            sys.exit(1)
+        else:
+            sys.exit(0)
+
+        raise RuntimeError('Unreachable')  # noqa
+
+
+@spawner_for.register
+def _(spawning: ForkSpawning) -> ForkSpawner:
+    return ForkSpawner(spawning)
+
+
+##
+
+
+class ThreadSpawning(Spawning, kw_only=True):
+    non_daemon: bool = False
+
+
+class ThreadSpawner(InProcessSpawner):
+    def __init__(self, spawning: ThreadSpawning) -> None:
+        super().__init__()
+
+        self._spawning = spawning
+        self._thread: threading.Thread | None = None
+
+    def spawn(self, spawn: Spawn) -> None:
+        check.none(self._thread)
+        self._thread = threading.Thread(
+            target=spawn.fn,
+            daemon=not self._spawning.non_daemon,
+        )
+        self._thread.start()
+
+
+@spawner_for.register
+def _(spawning: ThreadSpawning) -> ThreadSpawner:
+    return ThreadSpawner(spawning)

omlish/daemons/targets.py

@@ -0,0 +1,89 @@
+import abc
+import functools
+import os
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import runpy
+else:
+    runpy = lang.proxy_import('runpy')
+
+
+##
+
+
+class Target(dc.Case):
+    pass
+
+
+class TargetRunner(abc.ABC):
+    @abc.abstractmethod
+    def run(self) -> None:
+        raise NotImplementedError
+
+
+@functools.singledispatch
+def target_runner_for(target: Target) -> TargetRunner:
+    raise TypeError(target)
+
+
+##
+
+
+class FnTarget(Target):
+    fn: ta.Callable[[], None]
+
+
+class FnTargetRunner(TargetRunner, dc.Frozen):
+    target: FnTarget
+
+    def run(self) -> None:
+        self.target.fn()
+
+
+@target_runner_for.register
+def _(target: FnTarget) -> FnTargetRunner:
+    return FnTargetRunner(target)
+
+
+##
+
+
+class NameTarget(Target):
+    name: str
+
+
+class NameTargetRunner(TargetRunner, dc.Frozen):
+    target: NameTarget
+
+    def run(self) -> None:
+        name = self.target.name
+        if lang.can_import(name):
+            runpy._run_module_as_main(name)  # type: ignore  # noqa
+        else:
+            obj = lang.import_attr(self.target.name)
+            obj()
+
+
+##
+
+
+class ExecTarget(Target):
+    cmd: ta.Sequence[str] = dc.xfield(coerce=check.of_not_isinstance(str))
+
+
+class ExecTargetRunner(TargetRunner, dc.Frozen):
+    target: ExecTarget
+
+    def run(self) -> None:
+        os.execl(*self.target.cmd)
+
+
+@target_runner_for.register
+def _(target: ExecTarget) -> ExecTargetRunner:
+    return ExecTargetRunner(target)

omlish/daemons/waiting.py

@@ -0,0 +1,95 @@
+import abc
+import functools
+import socket
+import typing as ta
+
+from .. import dataclasses as dc
+
+
+##
+
+
+class Wait(dc.Case):
+    pass
+
+
+class Waiter(abc.ABC):
+    @abc.abstractmethod
+    def do_wait(self) -> bool:
+        raise NotImplementedError
+
+
+@functools.singledispatch
+def waiter_for(wait: Wait) -> Waiter:
+    raise TypeError(wait)
+
+
+##
+
+
+class SequentialWait(Wait):
+    waits: ta.Sequence[Wait]
+
+
+class SequentialWaiter(Waiter):
+    def __init__(self, waiters: ta.Sequence[Waiter]) -> None:
+        super().__init__()
+
+        self._waiters = waiters
+        self._idx = 0
+
+    def do_wait(self) -> bool:
+        while self._idx < len(self._waiters):
+            if not self._waiters[self._idx].do_wait():
+                return False
+            self._idx += 1
+        return True
+
+
+@waiter_for.register
+def _(wait: SequentialWait) -> SequentialWaiter:
+    return SequentialWaiter([waiter_for(c) for c in wait.waits])
+
+
+##
+
+
+class FnWait(Wait):
+    fn: ta.Callable[[], bool]
+
+
+class FnWaiter(Waiter, dc.Frozen):
+    wait: FnWait
+
+    def do_wait(self) -> bool:
+        return self.wait.fn()
+
+
+@waiter_for.register
+def _(wait: FnWait) -> FnWaiter:
+    return FnWaiter(wait)
+
+
+##
+
+
+class ConnectWait(Wait):
+    address: ta.Any
+
+
+class ConnectWaiter(Waiter, dc.Frozen):
+    wait: ConnectWait
+
+    def do_wait(self) -> bool:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.connect(self.wait.address)
+            except ConnectionRefusedError:
+                return False
+            else:
+                return True
+
+
+@waiter_for.register
+def _(wait: ConnectWait) -> ConnectWaiter:
+    return ConnectWaiter(wait)

omlish/lang/__init__.py

@@ -61,9 +61,7 @@ from .contextmanagers import (  # noqa
     DefaultLockable,
     ExitStacked,
     Lockable,
-    NOP_CONTEXT_MANAGED,
     NOP_CONTEXT_MANAGER,
-    NopContextManaged,
     NopContextManager,
     Timer,
     a_defer,

omlish/lang/contextmanagers.py

@@ -18,6 +18,11 @@ T = ta.TypeVar('T')
 ##
 
 
+class _NOT_SET:  # noqa
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+
 class ContextManaged:
     def __enter__(self) -> ta.Self:
         return self
@@ -31,21 +36,21 @@ class ContextManaged:
         return None
 
 
-class NopContextManaged(ContextManaged):
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        raise TypeError
-
+class NopContextManager(ContextManaged):
+    def __init__(self, /, value: ta.Any = _NOT_SET) -> None:
+        super().__init__()
 
-NOP_CONTEXT_MANAGED = NopContextManaged()
+        self._value = value
 
+    def __enter__(self):
+        if (value := self._value) is _NOT_SET:
+            return self
+        else:
+            return value
 
-class NopContextManager:
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
-    def __call__(self, *args, **kwargs):
-        return NOP_CONTEXT_MANAGED
-
 
 NOP_CONTEXT_MANAGER = NopContextManager()
 
@@ -350,7 +355,7 @@ def default_lock(value: DefaultLockable, default: DefaultLockable = None) -> Loc
         return lambda: lock
 
     elif value is False or value is None:
-        return NOP_CONTEXT_MANAGER
+        return lambda: NOP_CONTEXT_MANAGER
 
     elif callable(value):
         return value

omlish/lang/functions.py

@@ -190,6 +190,16 @@ class Args:
         self.args = args
         self.kwargs = kwargs
 
+    def update(self, *args: ta.Any, **kwargs: ta.Any) -> 'Args':
+        return Args(
+            *self.args,
+            *args,
+            **{
+                **self.kwargs,
+                **kwargs,
+            },
+        )
+
     def __call__(self, fn: ta.Callable[..., T]) -> T:
         return fn(*self.args, **self.kwargs)
 

omlish/libc.py

@@ -62,7 +62,6 @@ libc.free.argtypes = [ct.c_void_p]
 
 
 class Malloc:
-
     def __init__(self, sz: int) -> None:
         super().__init__()
 
@@ -174,7 +173,6 @@ if LINUX:
 
 
 class Mmap:
-
     def __init__(
             self,
             length: int,
@@ -537,14 +535,14 @@ elif DARWIN:
 
 
 if LINUX:
-    def gettid():
+    def gettid() -> int:
         syscalls = {
             'i386': 224,  # unistd_32.h: #define __NR_gettid 224
             'x86_64': 186,  # unistd_64.h: #define __NR_gettid 186
             'aarch64': 178,  # asm-generic/unistd.h: #define __NR_gettid 178
         }
         try:
-            tid = ct.CDLL('libc.so.6').syscall(syscalls[platform.machine()])
+            tid = libc.syscall(syscalls[platform.machine()])
         except Exception:  # noqa
             tid = -1
         return tid

omlish/lite/timeouts.py

@@ -8,7 +8,7 @@ import time
 import typing as ta
 
 
-TimeoutLike = ta.Union['Timeout', 'Timeout.Default', ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
+TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.Default'], ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
 
 
 ##

omlish/os/pidfiles/__main__.py

@@ -0,0 +1,11 @@
+# @omlish-manifest
+_CLI_MODULE = {'$omdev.cli.types.CliModule': {
+    'cmd_name': 'pidfiles',
+    'mod_name': __name__,
+}}
+
+
+if __name__ == '__main__':
+    from .cli import _main  # noqa
+
+    _main()

omlish/os/pidfiles/cli.py

@@ -0,0 +1,88 @@
+"""
+TODO:
+ - F_SETLK mode
+"""
+import os
+import typing as ta
+
+from ... import lang
+from ...argparse import all as ap
+from ..pidfiles.pidfile import Pidfile
+from ..pidfiles.pinning import PidfilePinner
+from ..signals import parse_signal
+
+
+class Cli(ap.Cli):
+    _PIDFILE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('pid-file'),
+        ap.arg('--create', action='store_true'),
+    ]
+
+    def _pidfile_args(self) -> lang.Args:
+        return lang.Args(
+            self.args.pid_file,
+            inheritable=False,
+            no_create=not self._args.create,
+        )
+
+    def _args_pidfile(self) -> Pidfile:
+        return self._pidfile_args()(Pidfile)
+
+    #
+
+    @ap.cmd(*_PIDFILE_ARGS)
+    def read_no_verify(self) -> None:
+        with self._args_pidfile() as pidfile:
+            print(pidfile.read())
+
+    @ap.cmd(*_PIDFILE_ARGS)
+    def lock(self) -> None:
+        with self._args_pidfile() as pidfile:
+            pidfile.acquire_lock()
+            print(os.getpid())
+            input()
+
+    #
+
+    _PIDFILE_PINNER_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        *_PIDFILE_ARGS,
+        ap.arg('--timeout', type=float),
+    ]
+
+    def _pidfile_pinner_args(self) -> lang.Args:
+        return self._pidfile_args().update(
+            timeout=self._args.timeout,
+        )
+
+    def _args_pidfile_pinner(self) -> ta.ContextManager[int]:
+        return self._pidfile_pinner_args()(PidfilePinner.default_impl()().pin_pidfile_owner)
+
+    #
+
+    @ap.cmd(*_PIDFILE_PINNER_ARGS)
+    def read(self) -> None:
+        with self._args_pidfile_pinner() as pid:
+            print(pid)
+
+    @ap.cmd(*_PIDFILE_PINNER_ARGS)
+    def pin(self) -> None:
+        with self._args_pidfile_pinner() as pid:
+            print(pid)
+            input()
+
+    @ap.cmd(
+        *_PIDFILE_PINNER_ARGS,
+        ap.arg('signal'),
+    )
+    def kill(self) -> None:
+        sig = parse_signal(self._args.signal)
+        with self._args_pidfile_pinner() as pid:
+            os.kill(pid, sig)
+
+
+def _main() -> None:
+    Cli().cli_run_and_exit()
+
+
+if __name__ == '__main__':
+    _main()

omlish/os/pidfiles/pidfile.py

@@ -27,11 +27,13 @@ class Pidfile:
             path: str,
             *,
             inheritable: bool = True,
+            no_create: bool = False,
     ) -> None:
         super().__init__()
 
         self._path = path
         self._inheritable = inheritable
+        self._no_create = no_create
 
     @property
     def path(self) -> str:
@@ -56,8 +58,28 @@ class Pidfile:
 
     #
 
+    _fd_to_dup: int
+
+    def dup(self) -> 'Pidfile':
+        fd = self._f.fileno()
+        dup = Pidfile(
+            self._path,
+            inheritable=self._inheritable,
+        )
+        dup._fd_to_dup = fd  # noqa
+        return dup
+
+    #
+
     def __enter__(self) -> 'Pidfile':
-        fd = os.open(self._path, os.O_RDWR | os.O_CREAT, 0o600)
+        if hasattr(self, '_fd_to_dup'):
+            fd = os.dup(self._fd_to_dup)
+            del self._fd_to_dup
+        else:
+            ofl = os.O_RDWR
+            if not self._no_create:
+                ofl |= os.O_CREAT
+            fd = os.open(self._path, ofl, 0o600)
 
         try:
             if self._inheritable:

omlish/os/pidfiles/pinning.py

@@ -27,6 +27,7 @@ import typing as ta
 
 from ...diag.lslocks import LslocksCommand
 from ...diag.lsof import LsofCommand
+from ...lite.check import check
 from ...lite.timeouts import Timeout
 from ...lite.timeouts import TimeoutLike
 from ...subprocesses.sync import subprocesses  # noqa
@@ -64,13 +65,21 @@ class PidfilePinner(abc.ABC):
             path: str,
             *,
             timeout: ta.Optional[TimeoutLike] = None,
+            inheritable: bool = False,  # Present to match Pidfile kwargs for convenience, but enforced to be False.
+            **kwargs: ta.Any,
     ) -> ta.Iterator[int]:
+        check.arg(not inheritable)
+
         timeout = Timeout.of(timeout)
 
         if not os.path.isfile(path):
             raise self.NoOwnerError
 
-        with Pidfile(path, inheritable=False) as pf:
+        with Pidfile(
+                path,
+                inheritable=False,
+                **kwargs,
+        ) as pf:
             try:
                 with self._pin_pidfile_owner(pf, timeout) as pid:
                     yield pid

omlish/os/signals.py

@@ -0,0 +1,15 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import signal
+
+
+def parse_signal(s: str) -> int:
+    try:
+        return int(s)
+    except ValueError:
+        pass
+
+    s = s.upper()
+    if not s.startswith('SIG'):
+        s = 'SIG' + s
+    return signal.Signals[s]  # noqa

{omlish-0.0.0.dev230.dist-info → omlish-0.0.0.dev232.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev230
+Version: 0.0.0.dev232
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -16,7 +16,7 @@ Provides-Extra: all
 Requires-Dist: anyio~=4.8; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: greenlet~=3.1; extra == "all"
-Requires-Dist: trio~=0.27; extra == "all"
+Requires-Dist: trio~=0.29; extra == "all"
 Requires-Dist: trio-asyncio~=0.15; extra == "all"
 Requires-Dist: lz4~=4.4; extra == "all"
 Requires-Dist: python-snappy~=0.7; extra == "all"
@@ -24,7 +24,7 @@ Requires-Dist: zstandard~=0.23; extra == "all"
 Requires-Dist: brotli~=1.1; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
 Requires-Dist: executing~=2.2; extra == "all"
-Requires-Dist: psutil~=6.0; extra == "all"
+Requires-Dist: psutil~=7.0; extra == "all"
 Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: ujson~=5.10; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
@@ -54,7 +54,7 @@ Provides-Extra: async
 Requires-Dist: anyio~=4.8; extra == "async"
 Requires-Dist: sniffio~=1.3; extra == "async"
 Requires-Dist: greenlet~=3.1; extra == "async"
-Requires-Dist: trio~=0.27; extra == "async"
+Requires-Dist: trio~=0.29; extra == "async"
 Requires-Dist: trio-asyncio~=0.15; extra == "async"
 Provides-Extra: compress
 Requires-Dist: lz4~=4.4; extra == "compress"
@@ -64,7 +64,7 @@ Requires-Dist: brotli~=1.1; extra == "compress"
 Provides-Extra: diag
 Requires-Dist: asttokens~=3.0; extra == "diag"
 Requires-Dist: executing~=2.2; extra == "diag"
-Requires-Dist: psutil~=6.0; extra == "diag"
+Requires-Dist: psutil~=7.0; extra == "diag"
 Provides-Extra: formats
 Requires-Dist: orjson~=3.10; extra == "formats"
 Requires-Dist: ujson~=5.10; extra == "formats"

{omlish-0.0.0.dev230.dist-info → omlish-0.0.0.dev232.dist-info}/RECORD

@@ -1,5 +1,5 @@
-omlish/.manifests.json,sha256=YGmAnUBszmosQQ_7Hh2wwtDiYdYZ4unNKYzOtALuels,7968
-omlish/__about__.py,sha256=5Ic1ejTV8SWSaVGgOg2_WDgpVTfT-KBLADFDeHHanA4,3380
+omlish/.manifests.json,sha256=vQTAIvR8OblSq-uP2GUfnbei0RnmAnM5j0T1-OToh9E,8253
+omlish/__about__.py,sha256=-wogzlxSt20e8KuTBCH4MRnaUQhIUXLRZdyQ82uUp4E,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -7,7 +7,7 @@ omlish/check.py,sha256=THqm6jD1a0skAO5EC8SOVg58yq96Vk5wcuruBkCYxyU,2016
 omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=9uUjJuVIbCBL3g14fyzAp-9gH935MFofvlfOGwcBIaM,4913
 omlish/dynamic.py,sha256=kIZokHHid8a0pIAPXMNiXrVJvJJyBnY49WP1a2m-HUQ,6525
-omlish/libc.py,sha256=20YdP3Sh45d-c13OMV0Od6FEAIxqKvU3d5kCOIW9xCQ,15650
+omlish/libc.py,sha256=8K4c66YV1ziJerl5poAAYCmsV-VSsHkT3EHhPW04ufg,15639
 omlish/outcome.py,sha256=ABIE0zjjTyTNtn-ZqQ_9_mUzLiBQ3sDAyqc9JVD8N2k,7852
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/shlex.py,sha256=bsW2XUD8GiMTUTDefJejZ5AyqT1pTgWMPD0BMoF02jE,248
@@ -175,6 +175,13 @@ omlish/configs/processing/matching.py,sha256=R64RxpPB1uX5Ztvvk2dQ2xi_xwlaxkxQgZw
 omlish/configs/processing/names.py,sha256=weHmaTclzgM9lUn3aBtw-kwZ3mc2N-CZlFg3Kd_UsKo,1093
 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=lnMgGrPeZ3pjhuXPU-7DX2XGEdNG0kP6HAejCQPSGtk,2976
+omlish/daemons/launching.py,sha256=mhtkuAO16STcznUl3rrX9pacfrKbPQRCP2AllKL4B70,3664
+omlish/daemons/reparent.py,sha256=UaG2X6VJHJPOlUwHPNRH3aWGgF0Fg771jjO9IRPLlyY,280
+omlish/daemons/spawning.py,sha256=cx00xeqSrfhlFbjCtKqaBHvMuHwB9hdjuKNHzAAo_dw,4030
+omlish/daemons/targets.py,sha256=scq6BYgzi0H2apfgD74U0D8_msQuYAel3Qiij74YWVo,1501
+omlish/daemons/waiting.py,sha256=RfgD1L33QQVbD2431dkKZGE4w6DUcGvYeRXXi8puAP4,1676
 omlish/dataclasses/__init__.py,sha256=D7I6ZJjEFeLN2re8oOZ_7JKWiG2plrPnaUFq3iEXYmQ,1553
 omlish/dataclasses/utils.py,sha256=N2seT8cJtfOv-41D7F3E-q4us-FCTQmnxxPv3dt1OcI,3796
 omlish/dataclasses/impl/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
@@ -385,15 +392,15 @@ 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=_DddR5PNgjqr51AB5DPUq0iKVqJrKz55WMJnBm97LL0,4127
+omlish/lang/__init__.py,sha256=bE8ra_QM5M4k8v3qFtreTjQswaZClIOaqXt9fE43MD0,4079
 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=V-XRwj1Em17Pr92i9mSYeeElQs9pmfM_B4jTF732qIg,10400
+omlish/lang/contextmanagers.py,sha256=Mrn8NJ3pP0Zxi-IoGqSjZDdWUctsyee2vrZ2FtZvNmo,10529
 omlish/lang/datetimes.py,sha256=ehI_DhQRM-bDxAavnp470XcekbbXc4Gdw9y1KpHDJT0,223
 omlish/lang/descriptors.py,sha256=njkYDS1gn5p4-3v1jr-s_srauC7tvvt571RjE7Q4LXE,6616
 omlish/lang/exceptions.py,sha256=qJBo3NU1mOWWm-NhQUHCY5feYXR3arZVyEHinLsmRH4,47
-omlish/lang/functions.py,sha256=t9nsnWwhsibG0w908VMx-_pRM5tZfruE3faPxrCWTbI,4160
+omlish/lang/functions.py,sha256=0ql9EXA_gEEhvUVzMJCjVhEnVtHecsLKmfmAXuQqeGY,4388
 omlish/lang/generators.py,sha256=5LX17j-Ej3QXhwBgZvRTm_dq3n9veC4IOUcVmvSu2vU,5243
 omlish/lang/imports.py,sha256=FMPz1lIDmuoapM88uabXeZbeJX1uCT8pkHeukC3X4qc,10129
 omlish/lang/iterables.py,sha256=HOjcxOwyI5bBApDLsxRAGGhTTmw7fdZl2kEckxRVl-0,1994
@@ -434,7 +441,7 @@ omlish/lite/resources.py,sha256=YNSmX1Ohck1aoWRs55a-o5ChVbFJIQhtbqE-XwF55Oc,326
 omlish/lite/runtime.py,sha256=XQo408zxTdJdppUZqOWHyeUR50VlCpNIExNGHz4U6O4,459
 omlish/lite/secrets.py,sha256=3Mz3V2jf__XU9qNHcH56sBSw95L3U2UPL24bjvobG0c,816
 omlish/lite/strings.py,sha256=QGxT1Yh4oI8ycsfeobxnjEhvDob_GiAKLeIhZwo1j24,1986
-omlish/lite/timeouts.py,sha256=wZ6PP1D3B8jpAI7-cQm7wkGTh2sE366XIn6FSMH6DZ4,4959
+omlish/lite/timeouts.py,sha256=lhXo0zwpLM7nr2-AliBRui2BO9jh7B8ALxetwOq6hYI,4968
 omlish/lite/timing.py,sha256=aVu3hEDB_jyTF_ryZI7iU-xg4q8CNwqpp9Apfru_iwY,196
 omlish/lite/types.py,sha256=fP5EMyBdEp2LmDxcHjUDtwAMdR06ISr9lKOL7smWfHM,140
 omlish/lite/typing.py,sha256=U3-JaEnkDSYxK4tsu_MzUn3RP6qALBe5FXQXpD-licE,1090
@@ -512,6 +519,7 @@ omlish/os/forkhooks.py,sha256=yjodOvs90ClXskv5oBIJbHn0Y7dzajLmZmOpRMKbyxM,5656
 omlish/os/journald.py,sha256=2nI8Res1poXkbLc31--MPUlzYMESnCcPUkIxDOCjZW0,3903
 omlish/os/linux.py,sha256=whJ6scwMKSFBdXiVhJW0BCpJV4jOGMr-a_a3Bhwz6Ls,18938
 omlish/os/paths.py,sha256=hqPiyg_eYaRoIVPdAeX4oeLEV4Kpln_XsH0tHvbOf8Q,844
+omlish/os/signals.py,sha256=FtzkovLb58N3vNdfxflUeXWFCqqKzseCjk5kBdWT-ds,267
 omlish/os/sizes.py,sha256=ohkALLvqSqBX4iR-7DMKJ4pfOCRdZXV8htH4QywUNM0,152
 omlish/os/temp.py,sha256=P97KiVeNB7rfGn4tlgU5ro86JUxAsiphLMlxsjQgfB0,1198
 omlish/os/deathpacts/__init__.py,sha256=IFJkHVWff-VhBbQX38th1RlmjUF2ptKh5TPIzP9Ei2M,229
@@ -519,9 +527,11 @@ omlish/os/deathpacts/base.py,sha256=EGN3BWSXPv0s9kl_QLrWE31hTybDHCmsLc_w3U2VyHc,
 omlish/os/deathpacts/heartbeatfile.py,sha256=OybdvhM2kxBTuoJWOJJ5LcX-0lg3jTOvvD2HUunxDWU,1731
 omlish/os/deathpacts/pipe.py,sha256=ZH-l-fIKyurocCehqOgvaYRurxIEMWe8D7l2dsJeGws,3214
 omlish/os/pidfiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/os/pidfiles/__main__.py,sha256=AF8TwjK4xgHVnoLAP9dIWgKvT0vGhHJlfDW0tKZ7tx4,200
+omlish/os/pidfiles/cli.py,sha256=2SSsP4O3VdpsDIMAkWgWSjh_YNIPzCD9l5LNN2qrIjo,2074
 omlish/os/pidfiles/manager.py,sha256=qSEwNaWT1KOAnU0KxliwvU_uowme5jyf1FyIPsGwnTY,2391
-omlish/os/pidfiles/pidfile.py,sha256=WmZt_c8fvztPgZQnYHhcQCKWgHqAEsaI3Ggz6Wqgkc8,3748
-omlish/os/pidfiles/pinning.py,sha256=_AwYjJc1UGX7mdCOk4mItJJcsOJo3RW2ebBOm2noW5Y,6359
+omlish/os/pidfiles/pidfile.py,sha256=yy14NCjvsCdXzlJjZzkw4vbzjt_FXEaUS5SbYT3dGY0,4277
+omlish/os/pidfiles/pinning.py,sha256=v9RlJ4BnJZcaZZXiiRqbmzLluaSOkeeEb_WrbKEClBQ,6643
 omlish/reflect/__init__.py,sha256=Er2yBHibVO16hFNA1szQF2_f43Y3HRCBWtS-fjsOIYc,798
 omlish/reflect/inspect.py,sha256=WCo2YpBYauKw6k758FLlZ_H4Q05rgVPs96fEv9w6zHQ,1538
 omlish/reflect/ops.py,sha256=RJ6jzrM4ieFsXzWyNXWV43O_WgzEaUvlHSc5N2ezW2A,2044
@@ -695,9 +705,9 @@ omlish/text/indent.py,sha256=YjtJEBYWuk8--b9JU_T6q4yxV85_TR7VEVr5ViRCFwk,1336
 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.dev230.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev230.dist-info/METADATA,sha256=9A2Cqst8XnecLQcMoWK5ElLcgfKuHa_CQqsM5YCaeUc,4176
-omlish-0.0.0.dev230.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-omlish-0.0.0.dev230.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev230.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev230.dist-info/RECORD,,
+omlish-0.0.0.dev232.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev232.dist-info/METADATA,sha256=q9xYAS00xDATKtVjZBhWNKwkSnMAIV0By4EIl_2vqFs,4176
+omlish-0.0.0.dev232.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+omlish-0.0.0.dev232.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev232.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev232.dist-info/RECORD,,