loopback-singleton 0.1.1__tar.gz → 0.2.1__tar.gz

{loopback_singleton-0.1.1/src/loopback_singleton.egg-info → loopback_singleton-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopback-singleton
-Version: 0.1.1
+Version: 0.2.1
 Summary: Process-external local singleton via loopback daemon
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/TovarnovM/loopback_singleton
@@ -16,6 +16,7 @@ Requires-Dist: ruff>=0.4; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Dynamic: license-file
 
 # loopback-singleton
@@ -31,7 +32,7 @@ Current release: `0.1.1`.
 ### What works today
 
 - Local singleton daemon auto-start on first use.
-- Safe-ish concurrent startup with file locking to reduce duplicate daemons.
+- Concurrent startup coordination with file locking to reduce duplicate daemons.
 - Authenticated handshake (shared token in runtime dir) between client and daemon.
 - Sequential method execution on the singleton object (single executor queue).
 - Idle TTL auto-shutdown for daemon cleanup.
@@ -85,7 +86,7 @@ with svc.proxy() as obj:
     print(obj.inc())
 ```
 
-### API overview
+## API overview
 
 ```python
 local_singleton(
@@ -125,10 +126,9 @@ svc.shutdown()
 4. Daemon binds ephemeral loopback TCP port, writes runtime metadata, and serves requests.
 5. Each `CALL` request is executed sequentially against one in-memory object instance.
 
+## Lifecycle and robustness scenarios
 
-### Lifecycle and robustness scenarios
-
-#### Scenario A — Oversized payload fails fast, daemon remains healthy
+### Scenario A — Oversized payload fails fast, daemon remains healthy
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -138,11 +138,11 @@ with svc.proxy() as p:
 
 Large frames are capped (16 MiB by default). Oversized frames are rejected with a clear protocol/connection error, and the daemon keeps serving other clients.
 
-#### Scenario B — Idle shutdown survives stuck clients
+### Scenario B — Idle shutdown survives stuck clients
 
 Daemon client handlers use bounded socket read timeouts, so an idle/stuck TCP client cannot block daemon shutdown forever.
 
-#### Scenario C — Private methods are denied by daemon
+### Scenario C — Private methods are denied by daemon
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -152,7 +152,7 @@ with svc.proxy() as p:
 
 Even if a client bypasses proxy-side checks, daemon-side policy rejects `CALL` for methods starting with `_`.
 
-#### Scenario D — Warm-up without creating a proxy
+### Scenario D — Warm-up without creating a proxy
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -161,7 +161,7 @@ svc.ensure_started()
 
 This starts (or verifies) the daemon and completes handshake without creating a `Proxy`.
 
-#### Scenario E — Health check and deterministic shutdown
+### Scenario E — Health check and deterministic shutdown
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -209,9 +209,10 @@ If startup repeatedly fails due to stale metadata, stop clients and remove the d
 
 ## Development
 
-Run tests:
+Run checks and tests:
 
 ```bash
+ruff check .
 pytest -q
 ```
 

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1}/README.md

@@ -11,7 +11,7 @@ Current release: `0.1.1`.
 ### What works today
 
 - Local singleton daemon auto-start on first use.
-- Safe-ish concurrent startup with file locking to reduce duplicate daemons.
+- Concurrent startup coordination with file locking to reduce duplicate daemons.
 - Authenticated handshake (shared token in runtime dir) between client and daemon.
 - Sequential method execution on the singleton object (single executor queue).
 - Idle TTL auto-shutdown for daemon cleanup.
@@ -65,7 +65,7 @@ with svc.proxy() as obj:
     print(obj.inc())
 ```
 
-### API overview
+## API overview
 
 ```python
 local_singleton(
@@ -105,10 +105,9 @@ svc.shutdown()
 4. Daemon binds ephemeral loopback TCP port, writes runtime metadata, and serves requests.
 5. Each `CALL` request is executed sequentially against one in-memory object instance.
 
+## Lifecycle and robustness scenarios
 
-### Lifecycle and robustness scenarios
-
-#### Scenario A — Oversized payload fails fast, daemon remains healthy
+### Scenario A — Oversized payload fails fast, daemon remains healthy
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -118,11 +117,11 @@ with svc.proxy() as p:
 
 Large frames are capped (16 MiB by default). Oversized frames are rejected with a clear protocol/connection error, and the daemon keeps serving other clients.
 
-#### Scenario B — Idle shutdown survives stuck clients
+### Scenario B — Idle shutdown survives stuck clients
 
 Daemon client handlers use bounded socket read timeouts, so an idle/stuck TCP client cannot block daemon shutdown forever.
 
-#### Scenario C — Private methods are denied by daemon
+### Scenario C — Private methods are denied by daemon
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -132,7 +131,7 @@ with svc.proxy() as p:
 
 Even if a client bypasses proxy-side checks, daemon-side policy rejects `CALL` for methods starting with `_`.
 
-#### Scenario D — Warm-up without creating a proxy
+### Scenario D — Warm-up without creating a proxy
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -141,7 +140,7 @@ svc.ensure_started()
 
 This starts (or verifies) the daemon and completes handshake without creating a `Proxy`.
 
-#### Scenario E — Health check and deterministic shutdown
+### Scenario E — Health check and deterministic shutdown
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -189,9 +188,10 @@ If startup repeatedly fails due to stale metadata, stop clients and remove the d
 
 ## Development
 
-Run tests:
+Run checks and tests:
 
 ```bash
+ruff check .
 pytest -q
 ```
 

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loopback-singleton"
-version = "0.1.1"
+version = "0.2.1"
 description = "Process-external local singleton via loopback daemon"
 readme = "README.md"
 license = "MIT"
@@ -20,6 +20,7 @@ dev = [
   "build",
   "twine",
   "setuptools",
+  "pytest-cov",
 ]
 
 [tool.setuptools]

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1}/src/loopback_singleton/daemon.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import importlib
 import queue
+import select
 import socket
 import threading
 import time
@@ -15,7 +16,7 @@ from typing import Any
 from .errors import ProtocolError
 from .runtime import get_runtime_paths, remove_runtime, write_runtime
 from .serialization import get_serializer
-from .transport import recv_message, send_message
+from .transport import recv_message, recv_message_timeout, send_message
 from .version import PROTOCOL_VERSION
 
 
@@ -28,6 +29,7 @@ class ExecItem:
 
 
 CLIENT_RECV_TIMEOUT = 0.5
+MAX_STALLED_PARTIAL_WINDOWS = 3
 
 
 def _resolve_factory(factory_import: str):
@@ -111,15 +113,30 @@ def run_daemon(name: str, factory: str, idle_ttl: float, serializer_name: str, s
 
     def handle_client(conn: socket.socket) -> None:
         nonlocal ever_connected
+
+        def _socket_may_have_buffered_data() -> bool:
+            try:
+                readable, _, _ = select.select([conn], [], [], 0)
+            except OSError:
+                return True
+            return bool(readable)
+
         mark_connected(+1)
         conn.settimeout(CLIENT_RECV_TIMEOUT)
         try:
+            stalled_partial_windows = 0
             while not shutting_down.is_set():
-                try:
-                    hello = recv_message(conn, serializer)
-                    break
-                except socket.timeout:
+                hello = recv_message_timeout(conn, serializer, CLIENT_RECV_TIMEOUT)
+                if hello is None:
+                    if _socket_may_have_buffered_data():
+                        stalled_partial_windows += 1
+                        if stalled_partial_windows >= MAX_STALLED_PARTIAL_WINDOWS:
+                            return
+                    else:
+                        stalled_partial_windows = 0
                     continue
+                stalled_partial_windows = 0
+                break
             else:
                 return
 
@@ -129,11 +146,18 @@ def run_daemon(name: str, factory: str, idle_ttl: float, serializer_name: str, s
             with active_lock:
                 ever_connected = True
             send_message(conn, ("OK", runtime_info["pid"], {"serializer": serializer_name}), serializer)
+            stalled_partial_windows = 0
             while not shutting_down.is_set():
-                try:
-                    msg = recv_message(conn, serializer)
-                except socket.timeout:
+                msg = recv_message_timeout(conn, serializer, CLIENT_RECV_TIMEOUT)
+                if msg is None:
+                    if _socket_may_have_buffered_data():
+                        stalled_partial_windows += 1
+                        if stalled_partial_windows >= MAX_STALLED_PARTIAL_WINDOWS:
+                            return
+                    else:
+                        stalled_partial_windows = 0
                     continue
+                stalled_partial_windows = 0
                 kind = msg[0]
                 if kind == "PING":
                     with active_lock:

loopback_singleton-0.2.1/src/loopback_singleton/transport.py

@@ -0,0 +1,148 @@
+"""TCP framing and message transport."""
+
+from __future__ import annotations
+
+import socket
+import struct
+import time
+import select
+from typing import Any
+
+from .errors import ProtocolError
+from .serialization import PickleSerializer
+
+_LEN_STRUCT = struct.Struct("!I")
+MAX_FRAME_BYTES = 16 * 1024 * 1024
+
+_HAS_POLL = hasattr(select, "poll") and hasattr(select, "POLLHUP") and hasattr(select, "POLLERR")
+if _HAS_POLL:
+    _POLL_HUP_FLAGS = select.POLLHUP | select.POLLERR
+    if hasattr(select, "POLLRDHUP"):
+        _POLL_HUP_FLAGS |= select.POLLRDHUP
+else:
+    _POLL_HUP_FLAGS = 0
+
+_PARTIAL_FRAME_WAIT_INTERVAL = 0.01
+
+
+def _recv_exact(sock: socket.socket, n: int) -> bytes:
+    chunks = bytearray()
+    while len(chunks) < n:
+        chunk = sock.recv(n - len(chunks))
+        if not chunk:
+            raise ConnectionError("Socket closed while receiving")
+        chunks.extend(chunk)
+    return bytes(chunks)
+
+
+def send_message(sock: socket.socket, obj: Any, serializer: PickleSerializer) -> None:
+    payload = serializer.dumps(obj)
+    sock.sendall(_LEN_STRUCT.pack(len(payload)))
+    sock.sendall(payload)
+
+
+def recv_message(sock: socket.socket, serializer: PickleSerializer) -> Any:
+    raw_len = _recv_exact(sock, _LEN_STRUCT.size)
+    (payload_len,) = _LEN_STRUCT.unpack(raw_len)
+    if payload_len < 0:
+        raise ProtocolError(f"Invalid frame length: {payload_len}")
+    if payload_len > MAX_FRAME_BYTES:
+        raise ProtocolError(
+            f"Frame too large: {payload_len} bytes exceeds max {MAX_FRAME_BYTES} bytes"
+        )
+    payload = _recv_exact(sock, payload_len)
+    return serializer.loads(payload)
+
+
+def recv_message_timeout(
+    sock: socket.socket, serializer: PickleSerializer, timeout: float
+) -> Any | None:
+    """Receive a full framed message within timeout without consuming partial frames.
+
+    Returns None if no complete frame becomes available before timeout.
+    """
+
+    deadline = time.monotonic() + timeout
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return None
+
+        try:
+            readable, _, _ = select.select([sock], [], [], remaining)
+        except OSError as exc:
+            raise ConnectionError("Socket closed while receiving") from exc
+        if not readable:
+            return None
+
+        try:
+            raw_len = sock.recv(_LEN_STRUCT.size, socket.MSG_PEEK)
+        except socket.timeout:
+            continue
+        if not raw_len:
+            raise ConnectionError("Socket closed while receiving")
+        if len(raw_len) < _LEN_STRUCT.size:
+            if _peer_disconnected(sock):
+                raise ConnectionError("Socket closed while receiving")
+            time.sleep(min(_PARTIAL_FRAME_WAIT_INTERVAL, remaining))
+            continue
+
+        (payload_len,) = _LEN_STRUCT.unpack(raw_len)
+        if payload_len < 0:
+            raise ProtocolError(f"Invalid frame length: {payload_len}")
+        if payload_len > MAX_FRAME_BYTES:
+            raise ProtocolError(
+                f"Frame too large: {payload_len} bytes exceeds max {MAX_FRAME_BYTES} bytes"
+            )
+
+        frame_len = _LEN_STRUCT.size + payload_len
+        try:
+            frame = sock.recv(frame_len, socket.MSG_PEEK)
+        except socket.timeout:
+            continue
+        if not frame:
+            raise ConnectionError("Socket closed while receiving")
+        if len(frame) < frame_len:
+            if _peer_disconnected(sock):
+                raise ConnectionError("Socket closed while receiving")
+            time.sleep(min(_PARTIAL_FRAME_WAIT_INTERVAL, remaining))
+            continue
+
+        return recv_message(sock, serializer)
+
+
+def _peer_disconnected(sock: socket.socket) -> bool:
+    if _HAS_POLL:
+        try:
+            poller = select.poll()
+            poller.register(sock, _POLL_HUP_FLAGS)
+            return any(event & _POLL_HUP_FLAGS for _, event in poller.poll(0))
+        except OSError:
+            return True
+
+    # Windows and other platforms may not expose poll/POLLHUP.
+    # Fall back to a non-blocking MSG_PEEK probe so closed peers are still
+    # detected when only a partial frame is buffered.
+    if not hasattr(sock, "recv"):
+        return False
+
+    original_timeout = None
+    if hasattr(sock, "gettimeout"):
+        original_timeout = sock.gettimeout()
+
+    try:
+        if hasattr(sock, "setblocking"):
+            sock.setblocking(False)
+        try:
+            chunk = sock.recv(1, socket.MSG_PEEK)
+        except (BlockingIOError, InterruptedError):
+            return False
+        except OSError:
+            return True
+        return chunk == b""
+    finally:
+        if original_timeout is not None and hasattr(sock, "settimeout"):
+            try:
+                sock.settimeout(original_timeout)
+            except OSError:
+                pass

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1/src/loopback_singleton.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopback-singleton
-Version: 0.1.1
+Version: 0.2.1
 Summary: Process-external local singleton via loopback daemon
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/TovarnovM/loopback_singleton
@@ -16,6 +16,7 @@ Requires-Dist: ruff>=0.4; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Dynamic: license-file
 
 # loopback-singleton
@@ -31,7 +32,7 @@ Current release: `0.1.1`.
 ### What works today
 
 - Local singleton daemon auto-start on first use.
-- Safe-ish concurrent startup with file locking to reduce duplicate daemons.
+- Concurrent startup coordination with file locking to reduce duplicate daemons.
 - Authenticated handshake (shared token in runtime dir) between client and daemon.
 - Sequential method execution on the singleton object (single executor queue).
 - Idle TTL auto-shutdown for daemon cleanup.
@@ -85,7 +86,7 @@ with svc.proxy() as obj:
     print(obj.inc())
 ```
 
-### API overview
+## API overview
 
 ```python
 local_singleton(
@@ -125,10 +126,9 @@ svc.shutdown()
 4. Daemon binds ephemeral loopback TCP port, writes runtime metadata, and serves requests.
 5. Each `CALL` request is executed sequentially against one in-memory object instance.
 
+## Lifecycle and robustness scenarios
 
-### Lifecycle and robustness scenarios
-
-#### Scenario A — Oversized payload fails fast, daemon remains healthy
+### Scenario A — Oversized payload fails fast, daemon remains healthy
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -138,11 +138,11 @@ with svc.proxy() as p:
 
 Large frames are capped (16 MiB by default). Oversized frames are rejected with a clear protocol/connection error, and the daemon keeps serving other clients.
 
-#### Scenario B — Idle shutdown survives stuck clients
+### Scenario B — Idle shutdown survives stuck clients
 
 Daemon client handlers use bounded socket read timeouts, so an idle/stuck TCP client cannot block daemon shutdown forever.
 
-#### Scenario C — Private methods are denied by daemon
+### Scenario C — Private methods are denied by daemon
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -152,7 +152,7 @@ with svc.proxy() as p:
 
 Even if a client bypasses proxy-side checks, daemon-side policy rejects `CALL` for methods starting with `_`.
 
-#### Scenario D — Warm-up without creating a proxy
+### Scenario D — Warm-up without creating a proxy
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -161,7 +161,7 @@ svc.ensure_started()
 
 This starts (or verifies) the daemon and completes handshake without creating a `Proxy`.
 
-#### Scenario E — Health check and deterministic shutdown
+### Scenario E — Health check and deterministic shutdown
 
 ```python
 svc = local_singleton("svc", factory="mypkg.m:MyObj")
@@ -209,9 +209,10 @@ If startup repeatedly fails due to stale metadata, stop clients and remove the d
 
 ## Development
 
-Run tests:
+Run checks and tests:
 
 ```bash
+ruff check .
 pytest -q
 ```
 

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1}/src/loopback_singleton.egg-info/requires.txt

@@ -6,3 +6,4 @@ ruff>=0.4
 build
 twine
 setuptools
+pytest-cov

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1}/tests/test_integration.py

@@ -203,6 +203,58 @@ def test_idle_shutdown_with_stuck_client_connection() -> None:
     remove_runtime(get_runtime_paths(name))
 
 
+def test_partial_frame_then_peer_close_does_not_block_idle_shutdown() -> None:
+    name = f"partial-close-{uuid.uuid4().hex}"
+    svc = local_singleton(name=name, factory=FACTORY, idle_ttl=0.5)
+
+    svc.ensure_started()
+    runtime_path = get_runtime_paths(name).runtime_file
+    runtime = pickle.loads(runtime_path.read_bytes())
+    token = ensure_auth_token(get_runtime_paths(name))
+    serializer = get_serializer("pickle")
+
+    with socket.create_connection((runtime["host"], runtime["port"]), timeout=2.0) as sock:
+        send_message(sock, ("HELLO", PROTOCOL_VERSION, token), serializer)
+        assert recv_message(sock, serializer)[0] == "OK"
+
+        payload = serializer.dumps(("PING",))
+        frame = struct.pack("!I", len(payload)) + payload
+        sock.sendall(frame[:1])
+
+    deadline = time.time() + 4.0
+    while time.time() < deadline and runtime_path.exists():
+        time.sleep(0.05)
+
+    assert not runtime_path.exists()
+    remove_runtime(get_runtime_paths(name))
+
+
+def test_partial_frame_stall_is_disconnected_after_retries() -> None:
+    name = f"partial-stall-{uuid.uuid4().hex}"
+    svc = local_singleton(name=name, factory=FACTORY, idle_ttl=0.5)
+
+    svc.ensure_started()
+    runtime_path = get_runtime_paths(name).runtime_file
+    runtime = pickle.loads(runtime_path.read_bytes())
+    token = ensure_auth_token(get_runtime_paths(name))
+    serializer = get_serializer("pickle")
+
+    with socket.create_connection((runtime["host"], runtime["port"]), timeout=2.0) as sock:
+        send_message(sock, ("HELLO", PROTOCOL_VERSION, token), serializer)
+        assert recv_message(sock, serializer)[0] == "OK"
+
+        payload = serializer.dumps(("PING",))
+        frame = struct.pack("!I", len(payload)) + payload
+        sock.sendall(frame[:1])
+        time.sleep(2.0)
+
+    deadline = time.time() + 4.0
+    while time.time() < deadline and runtime_path.exists():
+        time.sleep(0.05)
+
+    assert not runtime_path.exists()
+    remove_runtime(get_runtime_paths(name))
+
 def test_private_method_call_denied_server_side() -> None:
     name = f"private-denied-{uuid.uuid4().hex}"
     svc = local_singleton(name=name, factory=FACTORY, idle_ttl=2.0)
@@ -245,3 +297,30 @@ def test_service_ensure_started_ping_shutdown_lifecycle() -> None:
     second_info = svc.ping()
     assert second_info["pid"] != first_pid
     remove_runtime(get_runtime_paths(name))
+
+
+def test_chunked_ping_frame_survives_recv_timeout_window() -> None:
+    name = f"chunked-ping-{uuid.uuid4().hex}"
+    svc = local_singleton(name=name, factory=FACTORY, idle_ttl=2.0)
+
+    svc.ensure_started()
+    runtime = pickle.loads(get_runtime_paths(name).runtime_file.read_bytes())
+    token = ensure_auth_token(get_runtime_paths(name))
+    serializer = get_serializer("pickle")
+
+    with socket.create_connection((runtime["host"], runtime["port"]), timeout=2.0) as sock:
+        send_message(sock, ("HELLO", PROTOCOL_VERSION, token), serializer)
+        assert recv_message(sock, serializer)[0] == "OK"
+
+        payload = serializer.dumps(("PING",))
+        frame = struct.pack("!I", len(payload)) + payload
+        split_at = len(frame) // 2
+        sock.sendall(frame[:split_at])
+        time.sleep(0.7)
+        sock.sendall(frame[split_at:])
+
+        status, payload = recv_message(sock, serializer)
+        assert status == "OK"
+        assert payload["pid"] == runtime["pid"]
+
+    remove_runtime(get_runtime_paths(name))

{loopback_singleton-0.1.1 → loopback_singleton-0.2.1}/tests/test_regressions.py

@@ -8,6 +8,7 @@ import sys
 import time
 import uuid
 import stat
+import importlib
 
 import pytest
 from pathlib import Path
@@ -263,6 +264,66 @@ def test_ensure_auth_token_uses_fallback_when_xdg_runtime_unusable(monkeypatch,
     finally:
         blocked.chmod(0o700)
 
+
+def test_transport_imports_without_poll_support(monkeypatch) -> None:
+    import loopback_singleton.transport as transport
+
+    monkeypatch.delattr(transport.select, "poll", raising=False)
+    monkeypatch.delattr(transport.select, "POLLHUP", raising=False)
+    monkeypatch.delattr(transport.select, "POLLERR", raising=False)
+
+    reloaded = importlib.reload(transport)
+    assert reloaded._HAS_POLL is False
+    assert reloaded._peer_disconnected(object()) is False
+
+    importlib.reload(transport)
+
+
+def test_recv_message_timeout_sleeps_when_partial_frame_buffered(monkeypatch) -> None:
+    import loopback_singleton.transport as transport
+
+    class _Sock:
+        def recv(self, _n: int, _flags: int = 0) -> bytes:
+            return b"\x00\x01"
+
+
+    sock = _Sock()
+    serializer = get_serializer("pickle")
+    sleep_calls: list[float] = []
+
+    def fake_select(_r, _w, _x, _timeout):
+        return ([sock], [], [])
+
+    def fake_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+        raise RuntimeError("stop")
+
+    monkeypatch.setattr(transport.select, "select", fake_select)
+    monkeypatch.setattr(transport.time, "sleep", fake_sleep)
+    monkeypatch.setattr(transport, "_peer_disconnected", lambda _sock: False)
+
+    with pytest.raises(RuntimeError, match="stop"):
+        transport.recv_message_timeout(sock, serializer, timeout=0.1)
+
+    assert sleep_calls
+
+
+def test_recv_message_timeout_treats_select_oserror_as_disconnect(monkeypatch) -> None:
+    import loopback_singleton.transport as transport
+
+    class _Sock:
+        pass
+
+    serializer = get_serializer("pickle")
+
+    def fake_select(_r, _w, _x, _timeout):
+        raise OSError("bad file descriptor")
+
+    monkeypatch.setattr(transport.select, "select", fake_select)
+
+    with pytest.raises(ConnectionError, match="Socket closed while receiving"):
+        transport.recv_message_timeout(_Sock(), serializer, timeout=0.1)
+
 @pytest.mark.skipif(os.name == "nt", reason="POSIX-only metadata corruption regression")
 def test_corrupt_runtime_metadata_is_treated_as_missing_and_recovers(monkeypatch, tmp_path: Path) -> None:
     monkeypatch.setenv("XDG_RUNTIME_DIR", str(tmp_path))

loopback_singleton-0.1.1/src/loopback_singleton/transport.py

@@ -1,42 +0,0 @@
-"""TCP framing and message transport."""
-
-from __future__ import annotations
-
-import socket
-import struct
-from typing import Any
-
-from .errors import ProtocolError
-from .serialization import PickleSerializer
-
-_LEN_STRUCT = struct.Struct("!I")
-MAX_FRAME_BYTES = 16 * 1024 * 1024
-
-
-def _recv_exact(sock: socket.socket, n: int) -> bytes:
-    chunks = bytearray()
-    while len(chunks) < n:
-        chunk = sock.recv(n - len(chunks))
-        if not chunk:
-            raise ConnectionError("Socket closed while receiving")
-        chunks.extend(chunk)
-    return bytes(chunks)
-
-
-def send_message(sock: socket.socket, obj: Any, serializer: PickleSerializer) -> None:
-    payload = serializer.dumps(obj)
-    sock.sendall(_LEN_STRUCT.pack(len(payload)))
-    sock.sendall(payload)
-
-
-def recv_message(sock: socket.socket, serializer: PickleSerializer) -> Any:
-    raw_len = _recv_exact(sock, _LEN_STRUCT.size)
-    (payload_len,) = _LEN_STRUCT.unpack(raw_len)
-    if payload_len < 0:
-        raise ProtocolError(f"Invalid frame length: {payload_len}")
-    if payload_len > MAX_FRAME_BYTES:
-        raise ProtocolError(
-            f"Frame too large: {payload_len} bytes exceeds max {MAX_FRAME_BYTES} bytes"
-        )
-    payload = _recv_exact(sock, payload_len)
-    return serializer.loads(payload)