Drop inherited state in DqliteConnection.close() fork short-circuit

The fork-after-init short-circuit cleared _protocol and _db_id only.
The remaining state — _pending_drain (an asyncio.Task bound to the
parent's loop), _in_transaction, _tx_owner, _savepoint_stack,
_savepoint_implicit_begin, _has_untracked_savepoint, _bound_loop —
crossed the fork boundary intact. The Task in particular kept the
inherited writer transport alive via its coroutine frame, blocking
the kernel from reaping the FD and emitting the "Task was destroyed
but it is pending" warning on every forked-worker GC sweep — exactly
the warning the parent's _pending_drain-await machinery was built to
suppress.

Clear all eight items in the fork branch so GC in the child has no
references to parent-loop primitives or inherited FDs, and so the
child's view of the connection (in_transaction etc.) stays
self-consistent for any debugger / metric collector inspecting it.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/connection.py

@@ -1097,8 +1097,26 @@ async def close(self) -> None:
         # child preserves that contract for the GC / __del__ path that
         # commonly drives close in a forked worker.
         if os.getpid() != self._creator_pid:
+            # Drop every reference that crosses the fork boundary so
+            # GC in the child doesn't keep parent-loop primitives or
+            # the inherited socket FD alive. ``_pending_drain`` in
+            # particular is an ``asyncio.Task`` bound to the parent's
+            # loop; if it survives, ``Task.__del__`` later emits
+            # "Task was destroyed but it is pending" and the
+            # coroutine frame keeps the inherited writer transport
+            # (and FD) referenced indefinitely. Clearing the
+            # transaction / savepoint / loop bookkeeping also keeps
+            # the child's view of the connection self-consistent —
+            # ``in_transaction`` reads False for a closed connection.
             self._protocol = None
             self._db_id = None
+            self._pending_drain = None
+            self._in_transaction = False
+            self._tx_owner = None
+            self._savepoint_stack.clear()
+            self._savepoint_implicit_begin = False
+            self._has_untracked_savepoint = False
+            self._bound_loop = None
             return
         # Run the in-use guard BEFORE the ``_protocol is None``
         # early-return so a concurrent ``connect()`` racing with

tests/test_connection_after_fork_raises.py

@@ -18,6 +18,7 @@
 
 import asyncio
 import os
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -107,6 +108,45 @@ async def run() -> None:
     assert result == b"OK", f"child reported: {result!r}"
 
 
+def test_dqlite_connection_close_after_fork_drops_inherited_state() -> None:
+    """The fork short-circuit in ``DqliteConnection.close()`` must
+    drop every reference that crosses the fork boundary —
+    ``_pending_drain`` (parent-loop ``asyncio.Task``), transaction
+    bookkeeping, savepoint stack, and ``_bound_loop`` — so GC in
+    the child doesn't keep the inherited writer transport / socket
+    FD alive via the Task's coroutine frame, and the child's
+    ``in_transaction`` view stays self-consistent (False on a
+    closed connection)."""
+    conn = DqliteConnection("127.0.0.1:9999")
+    # Stage state that would normally be cleared by _close_impl.
+    sentinel_task = MagicMock(spec=asyncio.Task)
+    conn._pending_drain = sentinel_task
+    conn._in_transaction = True
+    conn._tx_owner = MagicMock()
+    conn._savepoint_stack.append("sp1")
+    conn._savepoint_implicit_begin = True
+    conn._has_untracked_savepoint = True
+    conn._bound_loop = MagicMock()
+    fake_parent_pid = conn._creator_pid + 1
+    conn._creator_pid = fake_parent_pid
+
+    async def run() -> None:
+        with patch("dqliteclient.connection.os.getpid", return_value=fake_parent_pid + 1):
+            await conn.close()
+
+    asyncio.run(run())
+
+    assert conn._protocol is None
+    assert conn._db_id is None
+    assert conn._pending_drain is None
+    assert conn._in_transaction is False
+    assert conn._tx_owner is None
+    assert conn._savepoint_stack == []
+    assert conn._savepoint_implicit_begin is False
+    assert conn._has_untracked_savepoint is False
+    assert conn._bound_loop is None
+
+
 @pytest.mark.skipif(not hasattr(os, "fork"), reason="requires os.fork")
 def test_dqlite_connection_close_after_fork_short_circuits() -> None:
     """``close()`` in the child must not touch the inherited socket