ominfra 0.0.0.dev225__tar.gz → 0.0.0.dev227__tar.gz

{ominfra-0.0.0.dev225/ominfra.egg-info → ominfra-0.0.0.dev227}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ominfra
-Version: 0.0.0.dev225
+Version: 0.0.0.dev227
 Summary: ominfra
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,8 +12,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev225
-Requires-Dist: omlish==0.0.0.dev225
+Requires-Dist: omdev==0.0.0.dev227
+Requires-Dist: omlish==0.0.0.dev227
 Provides-Extra: all
 Requires-Dist: paramiko~=3.5; extra == "all"
 Requires-Dist: asyncssh~=2.18; extra == "all"

{ominfra-0.0.0.dev225 → ominfra-0.0.0.dev227}/ominfra/clouds/aws/journald2aws/driver.py

@@ -107,7 +107,7 @@ class JournalctlToAwsDriver(ExitStacked):
 
     def _ensure_locked(self) -> None:
         if (pf := self._pidfile()) is not None:
-            pf.ensure_locked()
+            pf.acquire_lock()
 
     #
 

{ominfra-0.0.0.dev225 → ominfra-0.0.0.dev227}/ominfra/scripts/journald2aws.py

@@ -1953,6 +1953,7 @@ TODO:
    - 3) recheck current pid of flock holder == that pid
   - racy as to if it's a different actual process as initial check, just with same pid, but due to 'identity' / semantic
     meaning of the named pidfile the processes are considered equivalent
+  - read_checked(), contextmanager
 """
 
 
@@ -1971,6 +1972,14 @@ class Pidfile:
         self._path = path
         self._inheritable = inheritable
 
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @property
+    def inheritable(self) -> bool:
+        return self._inheritable
+
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self._path!r})'
 
@@ -2014,6 +2023,7 @@ class Pidfile:
         state = self.__dict__.copy()
 
         if '_f' in state:
+            # self._inheritable may be decoupled from actual file inheritability - for example when using the manager.
             if os.get_inheritable(fd := state.pop('_f').fileno()):
                 state['__fd'] = fd
 
@@ -2038,7 +2048,7 @@ class Pidfile:
         del self._f
         return True
 
-    def try_lock(self) -> bool:
+    def try_acquire_lock(self) -> bool:
         try:
             fcntl.flock(self._f, fcntl.LOCK_EX | fcntl.LOCK_NB)
             return True
@@ -2046,14 +2056,29 @@ class Pidfile:
         except OSError:
             return False
 
-    def ensure_locked(self) -> None:
-        if not self.try_lock():
-            raise RuntimeError('Could not get lock')
+    #
+
+    class Error(Exception):
+        pass
+
+    class LockedError(Error):
+        pass
+
+    def acquire_lock(self) -> None:
+        if not self.try_acquire_lock():
+            raise self.LockedError
+
+    class NotLockedError(Error):
+        pass
+
+    def ensure_cannot_lock(self) -> None:
+        if self.try_acquire_lock():
+            raise self.NotLockedError
 
     #
 
     def write(self, pid: ta.Optional[int] = None) -> None:
-        self.ensure_locked()
+        self.acquire_lock()
 
         if pid is None:
             pid = os.getpid()
@@ -2064,21 +2089,26 @@ class Pidfile:
         self._f.flush()
 
     def clear(self) -> None:
-        self.ensure_locked()
+        self.acquire_lock()
 
         self._f.seek(0)
         self._f.truncate()
 
-    def read(self) -> int:
-        if self.try_lock():
-            raise RuntimeError('Got lock')
+    #
+
+    def read(self) -> ta.Optional[int]:
+        self.ensure_cannot_lock()
 
         self._f.seek(0)
-        return int(self._f.read())  # FIXME: could be empty or hold old value, race w proc start
+        buf = self._f.read()
+        if not buf:
+            return None
+        return int(buf)
 
     def kill(self, sig: int = signal.SIGTERM) -> None:
-        pid = self.read()
-        os.kill(pid, sig)  # FIXME: Still racy - pidfd_send_signal?
+        if (pid := self.read()) is None:
+            raise self.Error(f'Pidfile locked but empty')
+        os.kill(pid, sig)
 
 
 ########################################
@@ -5034,7 +5064,7 @@ class JournalctlToAwsDriver(ExitStacked):
 
     def _ensure_locked(self) -> None:
         if (pf := self._pidfile()) is not None:
-            pf.ensure_locked()
+            pf.acquire_lock()
 
     #
 

{ominfra-0.0.0.dev225 → ominfra-0.0.0.dev227}/ominfra/scripts/manage.py

@@ -77,9 +77,6 @@ VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]
 # deploy/paths/types.py
 DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
 
-# ../../omlish/asyncs/asyncio/timeouts.py
-AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
-
 # ../../omlish/configs/types.py
 ConfigMap = ta.Mapping[str, ta.Any]
 
@@ -103,6 +100,9 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
+# ../../omlish/lite/timeouts.py
+TimeoutLike = ta.Union['Timeout', 'Timeout.Default', ta.Iterable['TimeoutLike'], float]  # ta.TypeAlias
+
 # ../../omlish/lite/typing.py
 A0 = ta.TypeVar('A0')
 A1 = ta.TypeVar('A1')
@@ -120,6 +120,9 @@ CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 # ../../omlish/argparse/cli.py
 ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
+# ../../omlish/asyncs/asyncio/timeouts.py
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
 # ../../omlish/configs/formats.py
 ConfigDataT = ta.TypeVar('ConfigDataT', bound='ConfigData')
 
@@ -1204,19 +1207,6 @@ async def asyncio_open_stream_writer(
     )
 
 
-########################################
-# ../../../omlish/asyncs/asyncio/timeouts.py
-
-
-def asyncio_maybe_timeout(
-        fut: AwaitableT,
-        timeout: ta.Optional[float] = None,
-) -> AwaitableT:
-    if timeout is not None:
-        fut = asyncio.wait_for(fut, timeout)  # type: ignore
-    return fut
-
-
 ########################################
 # ../../../omlish/configs/types.py
 
@@ -3067,6 +3057,205 @@ def format_num_bytes(num_bytes: int) -> str:
     return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
+########################################
+# ../../../omlish/lite/timeouts.py
+"""
+TODO:
+ - Event (/ Predicate)
+"""
+
+
+##
+
+
+class Timeout(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def can_expire(self) -> bool:
+        """Indicates whether or not this timeout will ever expire."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def expired(self) -> bool:
+        """Return whether or not this timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remaining(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires. May be negative and/or infinite."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __call__(self) -> float:
+        """Returns the time (in seconds) remaining until the timeout expires, or raises if the timeout has expired."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_(self, o: ta.Any) -> ta.Any:
+        """Evaluates time remaining via remaining() if this timeout can expire, otherwise returns `o`."""
+
+        raise NotImplementedError
+
+    #
+
+    @classmethod
+    def _now(cls) -> float:
+        return time.time()
+
+    #
+
+    class Default:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Optional[TimeoutLike],
+            default: ta.Union[TimeoutLike, ta.Type[_NOT_SPECIFIED]] = _NOT_SPECIFIED,
+    ) -> 'Timeout':
+        if obj is None:
+            return InfiniteTimeout()
+
+        elif isinstance(obj, Timeout):
+            return obj
+
+        elif isinstance(obj, (float, int)):
+            return DeadlineTimeout(cls._now() + obj)
+
+        elif isinstance(obj, ta.Iterable):
+            return CompositeTimeout(*[Timeout.of(c) for c in obj])
+
+        elif obj is Timeout.Default:
+            if default is Timeout._NOT_SPECIFIED or default is Timeout.Default:
+                raise RuntimeError('Must specify a default timeout')
+
+            else:
+                return Timeout.of(default)  # type: ignore[arg-type]
+
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def of_deadline(cls, deadline: float) -> 'DeadlineTimeout':
+        return DeadlineTimeout(deadline)
+
+    @classmethod
+    def of_predicate(cls, expired_fn: ta.Callable[[], bool]) -> 'PredicateTimeout':
+        return PredicateTimeout(expired_fn)
+
+
+class DeadlineTimeout(Timeout):
+    def __init__(
+            self,
+            deadline: float,
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.deadline = deadline
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return not (self.remaining() > 0)
+
+    def remaining(self) -> float:
+        return self.deadline - self._now()
+
+    def __call__(self) -> float:
+        if (rem := self.remaining()) > 0:
+            return rem
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
+class InfiniteTimeout(Timeout):
+    @property
+    def can_expire(self) -> bool:
+        return False
+
+    def expired(self) -> bool:
+        return False
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        return float('inf')
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+class CompositeTimeout(Timeout):
+    def __init__(self, *children: Timeout) -> None:
+        super().__init__()
+
+        self.children = children
+
+    @property
+    def can_expire(self) -> bool:
+        return any(c.can_expire for c in self.children)
+
+    def expired(self) -> bool:
+        return any(c.expired() for c in self.children)
+
+    def remaining(self) -> float:
+        return min(c.remaining() for c in self.children)
+
+    def __call__(self) -> float:
+        return min(c() for c in self.children)
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        if self.can_expire:
+            return self()
+        return o
+
+
+class PredicateTimeout(Timeout):
+    def __init__(
+            self,
+            expired_fn: ta.Callable[[], bool],
+            exc: ta.Union[ta.Type[BaseException], BaseException] = TimeoutError,
+    ) -> None:
+        super().__init__()
+
+        self.expired_fn = expired_fn
+        self.exc = exc
+
+    @property
+    def can_expire(self) -> bool:
+        return True
+
+    def expired(self) -> bool:
+        return self.expired_fn()
+
+    def remaining(self) -> float:
+        return float('inf')
+
+    def __call__(self) -> float:
+        if not self.expired_fn():
+            return float('inf')
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
 ########################################
 # ../../../omlish/lite/typing.py
 
@@ -5016,6 +5205,19 @@ class ArgparseCli:
             return fn()
 
 
+########################################
+# ../../../omlish/asyncs/asyncio/timeouts.py
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[TimeoutLike] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, Timeout.of(timeout)())  # type: ignore
+    return fut
+
+
 ########################################
 # ../../../omlish/configs/formats.py
 """
@@ -7323,17 +7525,43 @@ class SubprocessRunOutput(ta.Generic[T]):
 class SubprocessRun:
     cmd: ta.Sequence[str]
     input: ta.Any = None
-    timeout: ta.Optional[float] = None
+    timeout: ta.Optional[TimeoutLike] = None
     check: bool = False
     capture_output: ta.Optional[bool] = None
     kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None
 
+    #
+
+    _FIELD_NAMES: ta.ClassVar[ta.FrozenSet[str]]
+
+    def replace(self, **kwargs: ta.Any) -> 'SubprocessRun':
+        if not kwargs:
+            return self
+
+        field_kws = {}
+        extra_kws = {}
+        for k, v in kwargs.items():
+            if k in self._FIELD_NAMES:
+                field_kws[k] = v
+            else:
+                extra_kws[k] = v
+
+        return dc.replace(self, **{
+            **dict(kwargs={
+                **(self.kwargs or {}),
+                **extra_kws,
+            }),
+            **field_kws,  # passing a kwarg named 'kwargs' intentionally clobbers
+        })
+
+    #
+
     @classmethod
     def of(
             cls,
             *cmd: str,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             check: bool = False,  # noqa
             capture_output: ta.Optional[bool] = None,
             **kwargs: ta.Any,
@@ -7354,20 +7582,25 @@ class SubprocessRun:
     def run(
             self,
             subprocesses: ta.Optional[ta.Any] = None,  # AbstractSubprocesses
+            **kwargs: ta.Any,
     ) -> SubprocessRunOutput:
         if subprocesses is None:
             subprocesses = self._DEFAULT_SUBPROCESSES
-        return check.not_none(subprocesses).run_(self)  # type: ignore[attr-defined]
+        return check.not_none(subprocesses).run_(self.replace(**kwargs))  # type: ignore[attr-defined]
 
     _DEFAULT_ASYNC_SUBPROCESSES: ta.ClassVar[ta.Optional[ta.Any]] = None  # AbstractAsyncSubprocesses
 
     async def async_run(
             self,
             async_subprocesses: ta.Optional[ta.Any] = None,  # AbstractAsyncSubprocesses
+            **kwargs: ta.Any,
     ) -> SubprocessRunOutput:
         if async_subprocesses is None:
             async_subprocesses = self._DEFAULT_ASYNC_SUBPROCESSES
-        return await check.not_none(async_subprocesses).run_(self)  # type: ignore[attr-defined]
+        return await check.not_none(async_subprocesses).run_(self.replace(**kwargs))  # type: ignore[attr-defined]
+
+
+SubprocessRun._FIELD_NAMES = frozenset(fld.name for fld in dc.fields(SubprocessRun))  # noqa
 
 
 ##
@@ -7384,11 +7617,19 @@ class SubprocessRunnable(abc.ABC, ta.Generic[T]):
 
     #
 
-    def run(self, subprocesses: ta.Optional[ta.Any] = None) -> T:  # AbstractSubprocesses
-        return self.handle_run_output(self.make_run().run(subprocesses))
+    def run(
+            self,
+            subprocesses: ta.Optional[ta.Any] = None,  # AbstractSubprocesses
+            **kwargs: ta.Any,
+    ) -> T:
+        return self.handle_run_output(self.make_run().run(subprocesses, **kwargs))
 
-    async def async_run(self, async_subprocesses: ta.Optional[ta.Any] = None) -> T:  # AbstractAsyncSubprocesses
-        return self.handle_run_output(await self.make_run().async_run(async_subprocesses))
+    async def async_run(
+            self,
+            async_subprocesses: ta.Optional[ta.Any] = None,  # AbstractAsyncSubprocesses
+            **kwargs: ta.Any,
+    ) -> T:
+        return self.handle_run_output(await self.make_run().async_run(async_subprocesses, **kwargs))
 
 
 ########################################
@@ -9194,6 +9435,11 @@ class BaseSubprocesses(abc.ABC):  # noqa
 
         #
 
+        if 'timeout' in kwargs:
+            kwargs['timeout'] = Timeout.of(kwargs['timeout']).or_(None)
+
+        #
+
         return cmd, dict(
             env=env,
             shell=shell,
@@ -9828,7 +10074,7 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             self,
             *cmd: str,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             check: bool = False,
             capture_output: ta.Optional[bool] = None,
             **kwargs: ta.Any,
@@ -9905,6 +10151,11 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
 
 ########################################
 # ../../../omlish/subprocesses/sync.py
+"""
+TODO:
+ - popen
+ - route check_calls through run_?
+"""
 
 
 ##
@@ -9919,7 +10170,7 @@ class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
             self,
             *cmd: str,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             check: bool = False,
             capture_output: ta.Optional[bool] = None,
             **kwargs: ta.Any,
@@ -10320,7 +10571,7 @@ class AsyncioProcessCommunicator:
     async def communicate(
             self,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
     ) -> Communication:
         return await asyncio_maybe_timeout(self._communicate(input), timeout)
 
@@ -10333,7 +10584,7 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
             self,
             proc: asyncio.subprocess.Process,
             input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
     ) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
         return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
 
@@ -10344,7 +10595,7 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
             self,
             *cmd: str,
             shell: bool = False,
-            timeout: ta.Optional[float] = None,
+            timeout: ta.Optional[TimeoutLike] = None,
             **kwargs: ta.Any,
     ) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
         with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa

{ominfra-0.0.0.dev225 → ominfra-0.0.0.dev227/ominfra.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ominfra
-Version: 0.0.0.dev225
+Version: 0.0.0.dev227
 Summary: ominfra
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,8 +12,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev225
-Requires-Dist: omlish==0.0.0.dev225
+Requires-Dist: omdev==0.0.0.dev227
+Requires-Dist: omlish==0.0.0.dev227
 Provides-Extra: all
 Requires-Dist: paramiko~=3.5; extra == "all"
 Requires-Dist: asyncssh~=2.18; extra == "all"

{ominfra-0.0.0.dev225 → ominfra-0.0.0.dev227}/ominfra.egg-info/requires.txt

@@ -1,5 +1,5 @@
-omdev==0.0.0.dev225
-omlish==0.0.0.dev225
+omdev==0.0.0.dev227
+omlish==0.0.0.dev227
 
 [all]
 paramiko~=3.5

{ominfra-0.0.0.dev225 → ominfra-0.0.0.dev227}/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.dev225'
+version = '0.0.0.dev227'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',
@@ -22,8 +22,8 @@ classifiers = [
 ]
 description = 'ominfra'
 dependencies = [
-    'omdev == 0.0.0.dev225',
-    'omlish == 0.0.0.dev225',
+    'omdev == 0.0.0.dev227',
+    'omlish == 0.0.0.dev227',
 ]
 
 [project.optional-dependencies]