Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

Avoid blocking on IPC kernel shutdown (#11615)

Trevor Manza23b9f1bcf4b
diff --git a/marimo/_ipc/queue_manager.py b/marimo/_ipc/queue_manager.py
index 6d11a610bc..5e30e6e662 100644
--- a/marimo/_ipc/queue_manager.py
+++ b/marimo/_ipc/queue_manager.py
@@ -6,8 +6,11 @@ from __future__ import annotations
import dataclasses
import typing
+import msgspec
+
from marimo._ipc.connection import Connection
from marimo._ipc.types import ConnectionInfo
+from marimo._runtime.commands import StopKernelCommand
if typing.TYPE_CHECKING:
from marimo._messaging.types import KernelMessage
@@ -75,6 +78,18 @@ class QueueManager:
"""Close all queues and cleanup resources."""
self.conn.close()
+ def request_kernel_stop(self) -> None:
+ """Request shutdown without waiting for a receiver or queue capacity."""
+ import zmq
+
+ try:
+ self.conn.control.socket.send(
+ msgspec.msgpack.encode(StopKernelCommand()),
+ flags=zmq.DONTWAIT,
+ )
+ except zmq.Again:
+ pass
+
@classmethod
def create(
cls,
diff --git a/marimo/_session/managers/ipc.py b/marimo/_session/managers/ipc.py
index f01db43a9f..5efcdf34b4 100644
--- a/marimo/_session/managers/ipc.py
+++ b/marimo/_session/managers/ipc.py
@@ -179,6 +179,9 @@ class IPCQueueManagerImpl(QueueManager):
def close_queues(self) -> None:
self._ipc.close_queues()
+ def request_kernel_stop(self) -> None:
+ self._ipc.request_kernel_stop()
+
def put_control_request(self, request: commands.CommandMessage) -> None:
route_control_request(
request,
@@ -697,9 +700,8 @@ class IPCKernelManagerImpl(KernelManager):
def close_kernel(self, *, graceful: bool = False) -> None:
if self._process is not None:
- self.queue_manager.put_control_request(
- commands.StopKernelCommand()
- )
+ if self.is_alive():
+ self.queue_manager.request_kernel_stop()
# A clean stop lets the kernel flush pending work (the
# profile dump, cache writes) before we kill it. Unlike the
# multiprocessing manager, every wait here is bounded.
diff --git a/tests/_session/managers/test_ipc.py b/tests/_session/managers/test_ipc.py
index d393fd3bab..a2c77d2c3f 100644
--- a/tests/_session/managers/test_ipc.py
+++ b/tests/_session/managers/test_ipc.py
@@ -348,14 +348,12 @@ class TestCloseKernel:
return manager
def test_graceful_waits_bounded_for_exit(self) -> None:
- from marimo._runtime import commands
from marimo._session.managers.ipc import GRACEFUL_EXIT_TIMEOUT
manager = self._closable_manager()
manager.close_kernel(graceful=True)
- (request,), _ = manager.queue_manager.put_control_request.call_args
- assert isinstance(request, commands.StopKernelCommand)
+ manager.queue_manager.request_kernel_stop.assert_called_once_with()
manager.queue_manager.close_queues.assert_called_once()
manager._process.wait.assert_called_once_with(
timeout=GRACEFUL_EXIT_TIMEOUT
@@ -366,6 +364,58 @@ class TestCloseKernel:
manager.close_kernel()
manager._process.wait.assert_not_called()
+ @pytest.mark.requires("zmq")
+ @pytest.mark.parametrize("returncode", [None, 0])
+ def test_close_without_kernel_receiver(
+ self, returncode: int | None, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ import zmq
+
+ from marimo._ipc.queue_manager import QueueManager
+ from marimo._session.managers.ipc import IPCQueueManagerImpl
+
+ original_send = zmq.Socket.send
+ sent = False
+
+ def send(
+ socket: zmq.Socket[bytes], data: bytes, *, flags: int = 0
+ ) -> None:
+ nonlocal sent
+ # Check before sending so a blocking regression fails, not hangs.
+ assert flags == zmq.DONTWAIT
+ sent = True
+ original_send(socket, data, flags=flags)
+
+ monkeypatch.setattr(zmq.Socket, "send", send)
+ ipc, _ = QueueManager.create()
+ manager = self._closable_manager()
+ manager.queue_manager = IPCQueueManagerImpl(ipc)
+ manager._process.poll.return_value = returncode
+ try:
+ manager.close_kernel()
+ assert ipc.conn.context.closed
+ assert sent == (returncode is None)
+ finally:
+ ipc.close_queues()
+
+ @pytest.mark.requires("zmq")
+ def test_stop_reaches_connected_kernel(self) -> None:
+ import zmq
+
+ from marimo._ipc.queue_manager import QueueManager
+ from marimo._runtime.commands import StopKernelCommand
+ from marimo._session.managers.ipc import IPCQueueManagerImpl
+
+ host, info = QueueManager.create()
+ kernel = QueueManager.connect(info)
+ try:
+ assert host.conn.control.socket.poll(1000, zmq.POLLOUT)
+ IPCQueueManagerImpl(host).request_kernel_stop()
+ assert kernel.control_queue.get(timeout=1) == StopKernelCommand()
+ finally:
+ kernel.close_queues()
+ host.close_queues()
+
def test_profiling_close_waits_for_flush(self) -> None:
from marimo._session.managers.ipc import PROFILE_FLUSH_TIMEOUT