omlish 0.0.0.dev224__py3-none-any.whl → 0.0.0.dev226__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev224'
-__revision__ = '0980d15b9ba0f06f68cf7bdb68fbc8626696075f'
+__version__ = '0.0.0.dev226'
+__revision__ = '1f3419dac98e9db37df48a9a952f780d17bf31ed'
 
 
 #

omlish/asyncs/asyncio/subprocesses.py

@@ -10,9 +10,10 @@ import sys
 import typing as ta
 
 from ...lite.check import check
-from ...subprocesses import AbstractAsyncSubprocesses
-from ...subprocesses import SubprocessRun
-from ...subprocesses import SubprocessRunOutput
+from ...lite.timeouts import TimeoutLike
+from ...subprocesses.async_ import AbstractAsyncSubprocesses
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunOutput
 from .timeouts import asyncio_maybe_timeout
 
 
@@ -130,7 +131,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)
 
@@ -143,7 +144,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
 
@@ -154,22 +155,22 @@ 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]:
-        fac: ta.Any
-        if shell:
-            fac = functools.partial(
-                asyncio.create_subprocess_shell,
-                check.single(cmd),
-            )
-        else:
-            fac = functools.partial(
-                asyncio.create_subprocess_exec,
-                *cmd,
-            )
-
         with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa
+            fac: ta.Any
+            if shell:
+                fac = functools.partial(
+                    asyncio.create_subprocess_shell,
+                    check.single(cmd),
+                )
+            else:
+                fac = functools.partial(
+                    asyncio.create_subprocess_exec,
+                    *cmd,
+                )
+
             proc: asyncio.subprocess.Process = await fac(**kwargs)
             try:
                 yield proc

omlish/asyncs/asyncio/timeouts.py

@@ -3,14 +3,17 @@
 import asyncio
 import typing as ta
 
+from ...lite.timeouts import Timeout
+from ...lite.timeouts import TimeoutLike
+
 
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
 
 def asyncio_maybe_timeout(
         fut: AwaitableT,
-        timeout: ta.Optional[float] = None,
+        timeout: ta.Optional[TimeoutLike] = None,
 ) -> AwaitableT:
     if timeout is not None:
-        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+        fut = asyncio.wait_for(fut, Timeout.of(timeout)())  # type: ignore
     return fut

omlish/asyncs/asyncs.py

@@ -55,7 +55,6 @@ async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs)
 
 
 class SyncableIterable(ta.Generic[T]):
-
     def __init__(self, obj) -> None:
         super().__init__()
         self._obj = obj

omlish/bootstrap/sys.py

@@ -23,13 +23,13 @@ if ta.TYPE_CHECKING:
     from .. import libc
     from ..formats import dotenv
     from ..logs import all as logs
-    from ..os import pidfile
+    from ..os.pidfiles import pidfile
 
 else:
     libc = lang.proxy_import('..libc', __package__)
     logs = lang.proxy_import('..logs', __package__)
     dotenv = lang.proxy_import('..formats.dotenv', __package__)
-    pidfile = lang.proxy_import('..os.pidfile', __package__)
+    pidfile = lang.proxy_import('..os.pidfiles.pidfile', __package__)
 
 
 ##

omlish/dataclasses/impl/metaclass.py

@@ -188,8 +188,13 @@ class Data(
     metaclass=DataMeta,
 ):
     def __init__(self, *args, **kwargs):
+        # Typechecking barrier
         super().__init__(*args, **kwargs)
 
+    def __init_subclass__(cls, **kwargs):
+        # Typechecking barrier
+        super().__init_subclass__(**kwargs)
+
     def __post_init__(self, *args, **kwargs) -> None:
         try:
             spi = super().__post_init__  # type: ignore  # noqa

omlish/diag/lslocks.py

@@ -0,0 +1,64 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+https://github.com/util-linux/util-linux/blob/a4436c7bf07f98a6381c7dfa2ab3f9a415f9c479/misc-utils/lslocks.c
+"""
+import dataclasses as dc
+import json
+import typing as ta
+
+from ..lite.check import check
+from ..lite.marshal import OBJ_MARSHALER_FIELD_KEY
+from ..lite.marshal import unmarshal_obj
+from ..subprocesses.run import SubprocessRun
+from ..subprocesses.run import SubprocessRunnable
+from ..subprocesses.run import SubprocessRunOutput
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LsLocksItem:
+    """https://manpages.ubuntu.com/manpages/lunar/man8/lslocks.8.html"""
+
+    command: str
+    pid: int
+    type: str  # POSIX | FLOCK | OFDLCK
+    size: ta.Optional[int]
+    mode: str  # READ | WRITE
+    mandatory: bool = dc.field(metadata={OBJ_MARSHALER_FIELD_KEY: 'm'})
+    start: int
+    end: int
+    path: str
+    blocker: ta.Optional[int] = None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LsLocksCommand(SubprocessRunnable):
+    pid: ta.Optional[int] = None
+    no_inaccessible: bool = False
+
+    def make_run(self) -> SubprocessRun:
+        return SubprocessRun.of(
+            'lslocks',
+            '--json',
+            '--bytes',
+            '--notruncate',
+            *(['--pid', str(self.pid)] if self.pid is not None else []),
+            *(['--noinaccessible'] if self.no_inaccessible else []),
+
+            check=True,
+            stdout='pipe',
+            stderr='devnull',
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> ta.List[LsLocksItem]:
+        buf = check.not_none(output.stdout).decode().strip()
+        if not buf:
+            return []
+        obj = json.loads(buf)
+        return unmarshal_obj(obj['locks'], ta.List[LsLocksItem])

omlish/diag/lsof.py

@@ -0,0 +1,264 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+https://man7.org/linux/man-pages/man8/lsof.8.html
+
+Included in the process set are fields that identify the command, the process group IDentification (PGID) number, the
+task (thread) ID (TID), and the user ID (UID) number or login name.
+"""
+import dataclasses as dc
+import enum
+import typing as ta
+
+from ..lite.check import check
+from ..lite.dataclasses import dataclass_repr_omit_falsey
+from ..lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
+from ..subprocesses.run import SubprocessRun
+from ..subprocesses.run import SubprocessRunnable
+from ..subprocesses.run import SubprocessRunOutput
+
+
+##
+
+
+# FIXME: ??
+# https://unix.stackexchange.com/a/86011
+class LsofItemMode(enum.Enum):
+    SOLARIS_NFS_LOCK = 'N'
+    READ_LOCK_PARTIAL = 'r'
+    READ_LOCK_FULL = 'R'
+    WRITE_LOCK_PARTIAL = 'w'
+    WRITE_LOCK_FULL = 'W'
+    READ_WRITE_LOCK = 'u'
+    UNKNOWN_LOCK_TYPE = 'U'
+    XENIX_LOCK_PARTIAL = 'x'
+    XENIX_LOCK_FULL = 'X'
+
+
+@dc.dataclass(frozen=True)
+class _LsofFieldMeta:
+    prefix: str
+    process: bool = False
+    variadic: bool = False
+
+    @classmethod
+    def make(cls, *args, **kwargs):
+        return {
+            cls: cls(*args, **kwargs),
+            OBJ_MARSHALER_OMIT_IF_NONE: True,
+        }
+
+
+@dc.dataclass(frozen=True)
+class LsofItem:
+    __repr__ = dataclass_repr_omit_falsey
+
+    class _PREFIX:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _PROCESS:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    pid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('p', process=True))
+    pgid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('g', process=True))
+    ppid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('R', process=True))
+    cmd: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('c', process=True))
+
+    uid: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('u', process=True))
+    login_name: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('L', process=True))
+
+    # FD is the File Descriptor number of the file or:
+    #   cwd  current working directory;
+    #   Lnn  library references (AIX);
+    #   ctty character tty;
+    #   DEL  deleted file;
+    #   err  FD information error (see NAME column);
+    #   fp.  Fileport (Darwin);
+    #   jld  jail directory (FreeBSD);
+    #   ltx  shared library text (code and data);
+    #   Mxx  hex memory-mapped type number xx.
+    #   m86  DOS Merge mapped file;
+    #   mem  memory-mapped file;
+    #   mmap memory-mapped device;
+    #   NOFD for a Linux /proc/<PID>/fd directory that can't be opened -- the directory path appears in the NAME column,
+    #     followed by an error message;
+    #   pd   parent directory;
+    #   Rnn  unknown pregion number (HP-UX);
+    #   rtd  root directory;
+    #   twd  per task current working directory;
+    #   txt  program text (code and data);
+    #   v86  VP/ix mapped file;
+    #
+    # FD is followed by one of these characters, describing the mode under which the file is open:
+    #   r for read access;
+    #   w for write access;
+    #   u for read and write access;
+    #   space if mode unknown and no lock
+    #   character follows;
+    #   `-' if mode unknown and lock
+    #   character follows.
+    #
+    # The mode character is followed by one of these lock characters, describing the type of lock applied to the file:
+    #   N for a Solaris NFS lock of unknown type;
+    #   r for read lock on part of the file;
+    #   R for a read lock on the entire file;
+    #   w for a write lock on part of the file;
+    #   W for a write lock on the entire file;
+    #   u for a read and write lock of any length;
+    #   U for a lock of unknown type;
+    #   x for an SCO OpenServer Xenix lock on part of the file;
+    #   X for an SCO OpenServer Xenix lock on the entire file;
+    #   space if there is no lock.
+    #
+    fd: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('f'))
+
+    inode: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('i'))
+    name: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('n'))
+
+    # r = read; w = write; u = read/write
+    access: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('a'))
+
+    # r/R = read; w/W = write; u = read/write
+    lock: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('l'))
+
+    file_flags: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('G'))
+    file_type: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('t'))
+    file_size: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('s'))
+    file_offset: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('o'))  # as 0t<dec> or 0x<hex>
+
+    device_character_code: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('d'))
+    device_number: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('D'))  # as 0x<hex>
+    raw_device_number: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('r'))  # as 0x<hex>
+
+    share_count: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('C'))
+    link_count: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('k'))
+
+    stream_info: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('S'))
+    protocol_name: ta.Optional[str] = dc.field(default=None, metadata=_LsofFieldMeta.make('P'))
+
+    tcp_tpi_info: ta.Optional[ta.Sequence[str]] = dc.field(
+        default=None,
+        metadata=_LsofFieldMeta.make('T', variadic=True),
+    )
+
+    # 'K':  'task_id',  # unknown field
+    # 'M':  'task_command_name',  # unknown field
+
+    _FIELDS_BY_PREFIX: ta.ClassVar[ta.Mapping[str, dc.Field]]
+    _DEFAULT_PREFIXES: ta.ClassVar[str]
+
+    @classmethod
+    def from_prefixes(cls, dct: ta.Mapping[str, ta.Any]) -> 'LsofItem':
+        print(dct)
+        kw: ta.Dict[str, ta.Any] = {
+            fld.name: val
+            for pfx, val in dct.items()
+            if (fld := cls._FIELDS_BY_PREFIX.get(pfx)) is not None
+        }
+
+        return cls(**kw)
+
+    @classmethod
+    def from_prefix_lines(cls, lines: ta.Iterable[str]) -> ta.List['LsofItem']:
+        proc_dct: ta.Dict[str, ta.Any] = {}
+        file_dct: ta.Dict[str, ta.Any] = {}
+        out: ta.List[LsofItem] = []
+
+        def emit() -> None:
+            if file_dct:
+                out.append(cls.from_prefixes({**proc_dct, **file_dct}))
+
+        for line in lines:
+            pfx, val = line[0], line[1:]
+            try:
+                fld = cls._FIELDS_BY_PREFIX[pfx]
+            except KeyError:
+                continue
+            meta: _LsofFieldMeta = fld.metadata[_LsofFieldMeta]
+
+            if pfx == 'p':
+                emit()
+                proc_dct = {}
+                file_dct = {}
+            elif pfx == 'f':
+                emit()
+                file_dct = {}
+
+            if meta.process:
+                dct = proc_dct
+            else:
+                dct = file_dct
+
+            if meta.variadic:
+                dct.setdefault(pfx, []).append(val)
+            else:
+                if pfx in dct:
+                    raise KeyError(pfx)
+                dct[pfx] = val
+
+        emit()
+
+        return out
+
+
+LsofItem._FIELDS_BY_PREFIX = {  # noqa
+    meta.prefix: fld
+    for fld in dc.fields(LsofItem)  # noqa
+    if (meta := fld.metadata.get(_LsofFieldMeta)) is not None  # noqa
+}
+
+LsofItem._DEFAULT_PREFIXES = ''.join(LsofItem._FIELDS_BY_PREFIX)  # noqa
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LsofCommand(SubprocessRunnable[ta.List[LsofItem]]):
+    pid: ta.Optional[int] = None
+    file: ta.Optional[str] = None
+
+    prefixes: ta.Optional[ta.Sequence[str]] = None
+
+    def make_run(self) -> SubprocessRun:
+        if (prefixes := self.prefixes) is None:
+            prefixes = LsofItem._DEFAULT_PREFIXES  # noqa
+
+        return SubprocessRun.of(
+            'lsof',
+            '-F', ''.join(prefixes),
+            *(['-p', str(self.pid)] if self.pid is not None else []),
+            *([self.file] if self.file is not None else []),
+
+            stdout='pipe',
+            stderr='devnull',
+            check=True,
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> ta.List[LsofItem]:
+        lines = [s for l in check.not_none(output.stdout).decode().splitlines() if (s := l.strip())]
+        return LsofItem.from_prefix_lines(lines)
+
+
+if __name__ == '__main__':
+    def _main() -> None:
+        argparse = __import__('argparse')
+        parser = argparse.ArgumentParser()
+        parser.add_argument('--pid', '-p', type=int)
+        parser.add_argument('file', nargs='?')
+        args = parser.parse_args()
+
+        importlib = __import__('importlib')
+        subprocesses = importlib.import_module('..subprocesses.sync', package=__package__).subprocesses
+        items = LsofCommand(
+            pid=args.pid,
+            file=args.file,
+        ).run(subprocesses)
+
+        json = __import__('json')
+        marshal_obj = importlib.import_module('..lite.marshal', package=__package__).marshal_obj
+        print(json.dumps(marshal_obj(items), indent=2))
+
+    _main()

omlish/diag/ps.py

@@ -1,8 +1,15 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import os
-import subprocess
+import typing as ta
 
-from .. import lang
+from ..lite.check import check
+from ..lite.timeouts import Timeout
+from ..subprocesses.run import SubprocessRun
+from ..subprocesses.run import SubprocessRunnable
+from ..subprocesses.run import SubprocessRunOutput
+from ..subprocesses.sync import subprocesses
 
 
 @dc.dataclass(frozen=True)
@@ -12,23 +19,36 @@ class PsItem:
     cmd: str
 
 
-def get_ps_item(pid: int, timeout: lang.Timeout | None = None) -> PsItem:
-    timeout = lang.timeout(timeout)
-    out = subprocess.check_output(
-        ['ps', '-o', 'pid=,ppid=,command=', str(int(pid))],
-        timeout=timeout.or_(None),
-    ).decode().strip()
-    opid, _, rest = out.partition(' ')
-    ppid, _, cmd = rest.strip().partition(' ')
-    return PsItem(
-        int(opid),
-        int(ppid),
-        cmd.strip(),
-    )
+@dc.dataclass(frozen=True)
+class PsCommand(SubprocessRunnable):
+    pid: ta.Optional[int] = None
+
+    def make_run(self) -> SubprocessRun:
+        return SubprocessRun.of(
+            'ps',
+            '-o', 'pid=,ppid=,command=',
+            *([str(int(self.pid))] if self.pid is not None else []),
+
+            check=True,
+            stdout='pipe',
+            stderr='devnull',
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> PsItem:
+        opid, ppid, cmd = check.not_none(output.stdout).decode().split(maxsplit=2)
+        return PsItem(
+            int(opid),
+            int(ppid),
+            cmd.strip(),
+        )
+
 
+def get_ps_item(pid: int, timeout: ta.Optional[Timeout] = None) -> PsItem:
+    return PsCommand(pid).run(subprocesses, timeout=timeout)
 
-def get_ps_lineage(pid: int, timeout: lang.Timeout | None = None) -> list[PsItem]:
-    timeout = lang.timeout(timeout)
+
+def get_ps_lineage(pid: int, timeout: ta.Optional[Timeout] = None) -> ta.List[PsItem]:
+    timeout = Timeout.of(timeout)
     ret: list[PsItem] = []
     while True:
         cur = get_ps_item(pid, timeout)
@@ -39,9 +59,8 @@ def get_ps_lineage(pid: int, timeout: lang.Timeout | None = None) -> list[PsItem
     return ret
 
 
-def _main() -> None:
-    print(get_ps_lineage(os.getpid()))
-
-
 if __name__ == '__main__':
+    def _main() -> None:
+        print(get_ps_lineage(os.getpid()))
+
     _main()

omlish/http/coro/server.py

@@ -65,8 +65,6 @@ import typing as ta
 
 from ...lite.check import check
 from ...sockets.addresses import SocketAddress
-from ...sockets.handlers import SocketHandler_
-from ...sockets.io import SocketIoPair
 from ..handlers import HttpHandler
 from ..handlers import HttpHandlerRequest
 from ..handlers import HttpHandlerResponseData
@@ -423,6 +421,9 @@ class CoroHttpServer:
     def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], None]:
         return self._coro_run_handler(self._coro_handle_one())
 
+    class Close(Exception):  # noqa
+        pass
+
     def _coro_run_handler(
             self,
             gen: ta.Generator[
@@ -462,7 +463,7 @@ class CoroHttpServer:
 
                 try:
                     o = gen.send(i)
-                except EOFError:
+                except self.Close:
                     return
                 except StopIteration:
                     break
@@ -491,7 +492,7 @@ class CoroHttpServer:
                 break
 
         if isinstance(parsed, EmptyParsedHttpResult):
-            raise EOFError  # noqa
+            raise self.Close
 
         if isinstance(parsed, ParseHttpRequestError):
             err = self._build_error(
@@ -581,53 +582,3 @@ class CoroHttpServer:
             handler_response.close()
 
             raise
-
-
-##
-
-
-class CoroHttpServerSocketHandler(SocketHandler_):
-    def __init__(
-            self,
-            server_factory: CoroHttpServerFactory,
-            *,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
-    ) -> None:
-        super().__init__()
-
-        self._server_factory = server_factory
-        self._log_handler = log_handler
-
-    def __call__(self, client_address: SocketAddress, fp: SocketIoPair) -> None:
-        server = self._server_factory(client_address)
-
-        gen = server.coro_handle()
-
-        o = next(gen)
-        while True:
-            if isinstance(o, CoroHttpServer.AnyLogIo):
-                i = None
-                if self._log_handler is not None:
-                    self._log_handler(server, o)
-
-            elif isinstance(o, CoroHttpServer.ReadIo):
-                i = fp.r.read(o.sz)
-
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
-                i = fp.r.readline(o.sz)
-
-            elif isinstance(o, CoroHttpServer.WriteIo):
-                i = None
-                fp.w.write(o.data)
-                fp.w.flush()
-
-            else:
-                raise TypeError(o)
-
-            try:
-                if i is not None:
-                    o = gen.send(i)
-                else:
-                    o = next(gen)
-            except StopIteration:
-                break

omlish/http/coro/simple.py

@@ -21,7 +21,7 @@ from ..parsing import HttpRequestParser
 from ..versions import HttpProtocolVersion
 from ..versions import HttpProtocolVersions
 from .server import CoroHttpServer
-from .server import CoroHttpServerSocketHandler
+from .sockets import CoroHttpServerSocketHandler
 
 
 if ta.TYPE_CHECKING: