Prevent reconnect stalls from orphaned kernel_info requests (#1632)

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

Author: krassowski

jupyter_server/services/kernels/connection/channels.py

@@ -461,6 +461,18 @@ def disconnect(self):
         # start_buffering early-return below, otherwise the channel leaks.
         if self.kernel_info_channel is not None and not self.kernel_info_channel.closed():
             self.kernel_info_channel.close()
+            # If this connection owned the shared kernel_info future and we
+            # are closing its channel before a reply arrives, unblock any
+            # reconnect path waiting on that pending future.
+            if not self._kernel_info_future.done():
+                self._kernel_info_future.set_result({})
+            # Allow a future connection to issue a fresh kernel_info request
+            # rather than inheriting an orphaned/empty cached future.
+            if (
+                getattr(self.kernel_manager, "_kernel_info_future", None)
+                is self._kernel_info_future
+            ):
+                del self.kernel_manager._kernel_info_future
         self.kernel_info_channel = None
 
         if self.kernel_id in self.multi_kernel_manager:

tests/services/kernels/test_connection.py

@@ -222,3 +222,40 @@ async def test_no_fd_leak_on_disconnect_with_orphaned_kernel_info_channel(
         f"FD leak detected: {final_fds - baseline_fds} FDs leaked after 100 "
         f"disconnects with orphaned kernel_info_channel"
     )
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Times out on Windows")
+async def test_disconnect_resolves_orphaned_kernel_info_future(jp_serverapp: ServerApp) -> None:
+    """Disconnecting with an orphaned kernel_info channel should not leave
+    kernel_manager._kernel_info_future pending, which would block reconnects
+    waiting for a never-arriving kernel_info reply."""
+    app = jp_serverapp
+    km = app.kernel_manager
+    kernel_id = await km.start_kernel()
+    kernel = km.get_kernel(kernel_id)
+
+    conn1 = _make_connection(app, kernel, timeout=5.0)
+    conn1.create_stream()
+    conn1.session.key = kernel.session.key
+    conn1.session_key = f"{kernel_id}:{conn1.session.session}"
+
+    # Simulate an in-flight kernel_info request that never gets a reply.
+    conn1.kernel_info_channel = km.connect_shell(kernel_id)
+    km._kernel_info_future = conn1._kernel_info_future
+
+    # Force the buffering early-return path in disconnect().
+    # disconnect() first decrements the connection count via
+    # notify_disconnect(), so start at 1 to reach the == 0 branch.
+    km._kernel_connections[kernel_id] = 1
+    ZMQChannelsWebsocketConnection._open_sockets.add(conn1)
+    conn1.disconnect()
+
+    # Regression check: pending shared future must be resolved by disconnect.
+    assert conn1._kernel_info_future.done()
+
+    # A new connection should not block waiting on the stale pending future.
+    conn2 = _make_connection(app, kernel, timeout=0.2)
+    conn2.create_stream()
+    conn2.session.key = kernel.session.key
+    conn2.kernel_info_timeout = 0.2
+    await asyncio.wait_for(asyncio.wrap_future(conn2.request_kernel_info()), timeout=1.0)