gisolate 0.2.16.dev0__tar.gz → 0.2.16.dev1__tar.gz

{gisolate-0.2.16.dev0 → gisolate-0.2.16.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gisolate
-Version: 0.2.16.dev0
+Version: 0.2.16.dev1
 Summary: Process isolation for gevent applications — run any object in a clean subprocess, call methods transparently via ZMQ IPC.
 Project-URL: Repository, https://github.com/wy-z/gisolate
 License-Expression: MIT

{gisolate-0.2.16.dev0 → gisolate-0.2.16.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gisolate"
-version = "0.2.16.dev0"
+version = "0.2.16.dev1"
 description = "Process isolation for gevent applications — run any object in a clean subprocess, call methods transparently via ZMQ IPC."
 readme = "README.md"
 license = "MIT"

{gisolate-0.2.16.dev0 → gisolate-0.2.16.dev1}/src/gisolate/_internal.py

@@ -4,7 +4,7 @@ import contextlib
 import io
 import logging
 import pickle
-from typing import Any, Protocol, runtime_checkable
+from typing import Any, Protocol
 
 import dill
 import gevent.monkey
@@ -44,7 +44,6 @@ class RemoteError(RuntimeError):
 # ---------------------------------------------------------------------------
 
 
-@runtime_checkable
 class Serializer(Protocol):
     """Pluggable serializer protocol: ``dumps(obj) -> bytes`` / ``loads(bytes) -> obj``."""
 

{gisolate-0.2.16.dev0 → gisolate-0.2.16.dev1}/src/gisolate/pubsub.py

@@ -15,22 +15,9 @@ from ._internal import Serializer, SmartPickle
 
 log = logging.getLogger(__name__)
 
-_TOPIC_ENCODING = "utf-8"
-
-# Default high-water mark for PUB send queue. ZMQ drops when exceeded.
-_DEFAULT_SNDHWM = 1000
-
 Handler = Callable[[str, Any], Awaitable[None]]
 
 
-def _encode_topic(topic: str) -> bytes:
-    return topic.encode(_TOPIC_ENCODING)
-
-
-def _decode_topic(data: bytes) -> str:
-    return data.decode(_TOPIC_ENCODING, errors="replace")
-
-
 def _safe_close(sock: Any, ctx: Any) -> None:
     """Best-effort tear down of a ZMQ socket + context. Swallows errors."""
     with contextlib.suppress(Exception):
@@ -71,7 +58,7 @@ class ProcessPublisher:
         address: str,
         *,
         serializer: Serializer = SmartPickle,
-        sndhwm: int = _DEFAULT_SNDHWM,
+        sndhwm: int = 1000,
     ):
         self._addr = address
         self._serializer = serializer
@@ -82,9 +69,10 @@ class ProcessPublisher:
         self._send_lock: Any = None
 
     def __del__(self):
-        with contextlib.suppress(Exception):
-            if getattr(self, "_started", False):
-                self.close()
+        # Best-effort sync cleanup. Avoid full close() — at GC time the
+        # gevent hub may be torn down, so acquiring the send-lock can fail.
+        # The ipc file is left on disk (process is exiting anyway).
+        _safe_close(getattr(self, "_sock", None), getattr(self, "_ctx", None))
 
     def __enter__(self) -> "ProcessPublisher":
         return self.start()
@@ -141,7 +129,7 @@ class ProcessPublisher:
                 return
             try:
                 self._sock.send_multipart(
-                    [_encode_topic(topic), data], flags=zmq_mod.NOBLOCK
+                    [topic.encode("utf-8"), data], flags=zmq_mod.NOBLOCK
                 )
             except zmq_mod.Again:
                 # SNDHWM hit — slow subscribers. Drop, matching PUB semantics.
@@ -254,7 +242,7 @@ class ProcessSubscriber:
             sock.connect(self._addr)
             # Re-subscribe to any prefixes registered before start().
             for prefix in self._handlers:
-                sock.setsockopt(zmq.SUBSCRIBE, _encode_topic(prefix))
+                sock.setsockopt(zmq.SUBSCRIBE, prefix.encode("utf-8"))
         except Exception:
             _safe_close(sock, ctx)
             raise
@@ -262,7 +250,10 @@ class ProcessSubscriber:
         self._ctx = ctx
         self._sock = sock
         self._started = True
-        self._reader_task = loop.create_task(self._read_loop())
+        # Bind the reader to *this* socket. A close()+start() restart from
+        # inside a handler swaps ``self._sock``; the stale reader must not
+        # resume against the new socket (would race the new reader's recv).
+        self._reader_task = loop.create_task(self._read_loop(sock))
         return self
 
     def subscribe(self, topic_prefix: str, handler: Handler) -> None:
@@ -279,7 +270,7 @@ class ProcessSubscriber:
         if new_prefix and self._started:
             import zmq
 
-            self._sock.setsockopt(zmq.SUBSCRIBE, _encode_topic(topic_prefix))
+            self._sock.setsockopt(zmq.SUBSCRIBE, topic_prefix.encode("utf-8"))
 
     def unsubscribe(
         self, topic_prefix: str, handler: Handler | None = None
@@ -305,7 +296,7 @@ class ProcessSubscriber:
 
                 with contextlib.suppress(Exception):
                     self._sock.setsockopt(
-                        zmq.UNSUBSCRIBE, _encode_topic(topic_prefix)
+                        zmq.UNSUBSCRIBE, topic_prefix.encode("utf-8")
                     )
 
     def _match(self, topic: str) -> list[Handler]:
@@ -316,22 +307,32 @@ class ProcessSubscriber:
             for h in handlers
         ]
 
-    async def _read_loop(self) -> None:
-        """Single reader task: dispatch messages to matched handlers."""
+    async def _read_loop(self, sock: Any) -> None:
+        """Single reader task: dispatch messages to matched handlers.
+
+        ``sock`` is captured at task creation time so a close+restart cycle
+        leaves stale readers pointing at the already-closed socket — their
+        recv fails immediately and they exit without touching the new socket.
+        """
         try:
             while True:
+                # Check before each recv: close() or a close+start restart
+                # may have swapped ``self._sock`` while we were suspended in
+                # the previous gather() (pyzmq does not necessarily wake a
+                # pending recv future when the socket is closed, so we can't
+                # rely solely on recv raising).
+                if not self._started or sock is not self._sock:
+                    return
                 try:
-                    parts = await self._sock.recv_multipart()
+                    parts = await sock.recv_multipart()
                 except Exception:
-                    # close() torpedoed the socket; exit cleanly without
-                    # logging a fake crash.
-                    if not self._started:
+                    if not self._started or sock is not self._sock:
                         return
                     raise
                 if len(parts) < 2:
                     continue
                 topic_bytes, data, *_ = parts
-                topic = _decode_topic(topic_bytes)
+                topic = topic_bytes.decode("utf-8", errors="replace")
                 handlers = self._match(topic)
                 if not handlers:
                     continue
@@ -353,9 +354,9 @@ class ProcessSubscriber:
                     if isinstance(r, (SystemExit, KeyboardInterrupt)):
                         # Honor process-exit intent from a handler.
                         raise r
-                    if isinstance(r, BaseException) and not isinstance(
-                        r, asyncio.CancelledError
-                    ):
+                    # CancelledError is BaseException (not Exception) since
+                    # 3.8, so ``isinstance(r, Exception)`` naturally skips it.
+                    if isinstance(r, Exception):
                         log.error(
                             "subscriber handler raised %s for topic %s",
                             type(r).__name__,
@@ -366,6 +367,17 @@ class ProcessSubscriber:
             pass
         except Exception:
             log.exception("subscriber reader task crashed")
+            # Reader is dying for an unrelated reason (malformed frame,
+            # libzmq error, etc.). Tear our resources down so the
+            # subscriber doesn't look alive while silently dropping
+            # messages, and so ``start()`` can rebuild from scratch.
+            if sock is self._sock and self._started:
+                self._started = False
+                ctx = self._ctx
+                self._sock = None
+                self._ctx = None
+                self._reader_task = None
+                _safe_close(sock, ctx)
 
     async def _invoke(self, handler: Handler, topic: str, payload: Any) -> None:
         task = asyncio.current_task()

{gisolate-0.2.16.dev0 → gisolate-0.2.16.dev1}/tests/test_pubsub.py

@@ -617,6 +617,72 @@ class TestPubSubIntegration:
             stop.set()
             thread.join(timeout=3)
 
+    def test_handler_close_then_restart_no_stale_reader(self):
+        """close+start from inside a handler must not leave a stale reader live.
+
+        Regression: ``_read_loop`` used to read ``self._sock`` dynamically, so
+        after a handler did ``await sub.close(); sub.start()`` the original
+        reader resumed against the *new* socket, racing the new reader's
+        recv. The reader is now bound to its start-time socket and exits on
+        the first failed recv from the closed old socket.
+        """
+        addr = _make_addr()
+        bucket: list[tuple[str, Any]] = []
+        ready = threading.Event()
+        stop = threading.Event()
+        restarted = threading.Event()
+        reader_tasks_snapshot: dict[str, Any] = {}
+
+        def runner() -> None:
+            async def main() -> None:
+                sub = ProcessSubscriber(addr)
+
+                async def handler(topic, payload):
+                    bucket.append((topic, payload))
+                    if payload == {"i": 0} and not restarted.is_set():
+                        old_task = sub._reader_task
+                        await sub.close()
+                        sub.start()
+                        reader_tasks_snapshot["old"] = old_task
+                        reader_tasks_snapshot["new"] = sub._reader_task
+                        restarted.set()
+
+                sub.subscribe("v1.x.", handler)
+                sub.start()
+                ready.set()
+                try:
+                    while not stop.is_set():
+                        await asyncio.sleep(0.02)
+                finally:
+                    await sub.close()
+
+            asyncio.run(main())
+
+        thread = threading.Thread(target=runner, daemon=True)
+        thread.start()
+        try:
+            assert ready.wait(2.0)
+            pub = ProcessPublisher(addr).start()
+            try:
+                gevent.sleep(0.2)
+                pub.publish("v1.x.k", {"i": 0})
+                assert _wait_until(restarted.is_set, timeout=3.0)
+                # Give the old reader time to wake and (correctly) exit.
+                gevent.sleep(0.3)
+                old = reader_tasks_snapshot["old"]
+                new = reader_tasks_snapshot["new"]
+                assert old is not new
+                assert old.done(), "stale reader from pre-restart still alive"
+                # New reader still receives.
+                pub.publish("v1.x.k", {"i": 1})
+                assert _wait_until(lambda: len(bucket) >= 2, timeout=3.0)
+                assert bucket[1] == ("v1.x.k", {"i": 1})
+            finally:
+                pub.close()
+        finally:
+            stop.set()
+            thread.join(timeout=3)
+
     def test_custom_serializer_end_to_end(self):
         addr = _make_addr()
         bucket: list[tuple[str, Any]] = []

{gisolate-0.2.16.dev0 → gisolate-0.2.16.dev1}/uv.lock

@@ -126,7 +126,7 @@ wheels = [
 
 [[package]]
 name = "gisolate"
-version = "0.2.15"
+version = "0.2.16.dev0"
 source = { editable = "." }
 dependencies = [
     { name = "dill" },