httpunk 0.1.4__tar.gz → 0.1.5__tar.gz

{httpunk-0.1.4 → httpunk-0.1.5}/Cargo.lock

@@ -118,7 +118,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "bytes",
  "h2",

{httpunk-0.1.4 → httpunk-0.1.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.1.4"
+version = "0.1.5"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",

{httpunk-0.1.4 → httpunk-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.1.4
+Version: 0.1.5
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{httpunk-0.1.4 → httpunk-0.1.5}/httpunk/h2/connection.py

@@ -141,11 +141,16 @@ class H2ConnectionBase:
         # `resp.aclose()` immediately followed by close ENQUEUES the RST_STREAM,
         # and whether the pump wakes before the cancel above is a scheduler race;
         # dropping it would ship the close without ever telling the peer to stop
-        # (h2 likewise drains its pending-send queue before shutdown). Best-effort:
-        # the connection is closing regardless, so a send failure is ignored.
+        # (h2 likewise drains its pending-send queue before shutdown). Unconditional
+        # on `self.error`: h2's `State::Closing` runs `codec.shutdown` = flush THEN
+        # shutdown on every non-IO close (connection.rs L304-310), including the
+        # GOAWAY-exchanged clean close (F23), whose reply GOAWAY sits in this queue
+        # with `error` already set. Best-effort: the connection is closing
+        # regardless, so a send failure (a dead transport — h2's Io branch, which
+        # skips straight to Closed) is ignored.
         with self._write_buf_lock:
             pending, self._write_buf = bytes(self._write_buf), bytearray()
-        if pending and self.error is None and self._transport is not None:
+        if pending and self._transport is not None:
             with contextlib.suppress(Exception):
                 async with self._send_lock:
                     await self._transport.send_all(pending)
@@ -190,7 +195,10 @@ class H2ConnectionBase:
     # - Connection-lifecycle frames (preface/SETTINGS, GOAWAY, acks) keep plain
     #   `send_frame`: they run in the pump/handshake/shutdown, not under user
     #   cancellation, and GOAWAY needs flushed-before-stop semantics a queue would
-    #   complicate.
+    #   complicate. One exception: the idle-after-peer-GOAWAY reply
+    #   (`_maybe_goaway_reply`) is queued, because its trigger can be a sync stream
+    #   close in user-task context; `close()` drains the queue before the FIN, so
+    #   flushed-before-stop still holds.
     #
     # The full-fidelity alternative — port h2's buffered-send/`reserve_capacity`
     # model and route DATA through the queue too — remains open as a future step;
@@ -255,10 +263,27 @@ class H2ConnectionBase:
                     self.backend.close_transport(self._transport)
                 raise
 
-    async def _maybe_goaway_reply(self):
+    def _maybe_goaway_reply(self):
         """If the peer has GOAWAY'd us with a REAL last-stream-id and no streams remain,
-        send our acknowledging GOAWAY(NO_ERROR, last-processed-id) exactly once and
-        report that the pump should stop (F23). No-op otherwise.
+        queue our acknowledging GOAWAY(NO_ERROR, last-processed-id) exactly once and
+        mark the connection DONE (F23). No-op otherwise; returns whether it fired.
+
+        h2: proto/connection.rs `poll` (L287-295) — `go_away_now(NO_ERROR)` once
+        `error.is_some() && !has_streams()`, after which `should_close_now()` makes
+        the connection future resolve `Ready(Ok(()))`: sending the reply and being
+        done are ONE step. The "done" half here is `_fail`, the fan-out every other
+        pump exit gets (server: end the accept loop so the caller's `__aexit__`
+        closes the transport; client: wake openers). `fail_all` aborts nothing
+        (no streams remain) and `error` is set so later use fails as closed — the
+        client still reports `GoAwayError` first (`open_stream`/`wait_until_ready`
+        check `_goaway` before `error`, as h2's conn_error is never overwritten).
+
+        Two triggers, like h2's connection task being woken both by inbound frames
+        and by a stream closing (streams.rs `drop_stream_ref` L1647): the read pump
+        after a batch, and `_close_stream`/`_abort_stream` when the last stream
+        goes. The latter is sync user-task context (a `respond()`/`aclose()`
+        finishing), so the frame goes through `enqueue_frame` — exactly h2's
+        `GoAway.pending` queue; `close()` drains it before the FIN (codec.shutdown).
 
         A phase-1 graceful GOAWAY (`last_stream_id == 2^31-1`) is explicitly NOT a
         trigger — it means "I'm shutting down, keep your in-flight work going" and is
@@ -267,6 +292,7 @@ class H2ConnectionBase:
         (h2's `should_close_on_idle` excludes `StreamId::MAX` for the same reason)."""
         if (
             self._goaway_replied
+            or self.error is not None
             or self.streams._goaway is None
             or self.streams._streams
             or self.streams._goaway_last_id is None
@@ -274,7 +300,8 @@ class H2ConnectionBase:
         ):
             return False
         self._goaway_replied = True
-        await self.send_frame(self.codec.serialize_go_away(self._goaway_last_stream_id(), int(H2Reason.NO_ERROR)))
+        self.enqueue_frame(self.codec.serialize_go_away(self._goaway_last_stream_id(), int(H2Reason.NO_ERROR)))
+        self._fail(ConnectionClosedError("connection closed: GOAWAY exchanged"))
         return True
 
     # ----- inbound -----
@@ -306,13 +333,15 @@ class H2ConnectionBase:
                         # resets (F25).
                         if se.args[2] != "remote":
                             await self.streams.reset_on_error(se.args[0], se.args[1])
-                # After a peer GOAWAY, once every in-flight stream has finished, send our
+                # After a peer GOAWAY, once every in-flight stream has finished, queue our
                 # acknowledging GOAWAY(NO_ERROR, last-processed-id) and stop serving —
                 # h2's poll loop does exactly this (`go_away_now(NO_ERROR)` once
                 # `error.is_some()` and `!has_streams()`, connection.rs L287-295), rather
-                # than lingering until the peer closes the socket (F23). The transport's
-                # FIN follows on the caller's `__aexit__` (httpunk's user-driven lifecycle).
-                if await self._maybe_goaway_reply():
+                # than lingering until the peer closes the socket (F23). The connection is
+                # DONE (`_fail` inside): the accept loop / openers are woken, and the
+                # transport's FIN follows on the caller's `__aexit__` → `close()`, which
+                # drains the queued GOAWAY first (httpunk's user-driven lifecycle).
+                if self._maybe_goaway_reply():
                     break
         except H2Error as exc:
             # A protocol/flow violation we detected (bad state, HPACK/CONTINUATION,

{httpunk-0.1.4 → httpunk-0.1.5}/httpunk/h2/streams.py

@@ -896,6 +896,19 @@ class StreamManager:
         """
         if st.state.is_closed() and self._streams.pop(st.id, None) is not None:
             self._release_slot(st)
+            self._on_stream_gone()
+
+    def _on_stream_gone(self):
+        """A stream left `_streams`: re-run the connection's idle-close check.
+
+        h2: streams.rs `drop_stream_ref` (L1647) wakes the connection task when a
+        closed stream is released, so `Connection::poll` re-evaluates
+        `error.is_some() && !has_streams()` → `go_away_now(NO_ERROR)`
+        (connection.rs L287-295). Without this, a peer GOAWAY that arrived while
+        a request was in flight would never be acknowledged if the peer sends
+        nothing further — the read pump only re-checks after inbound bytes.
+        """
+        self._conn._maybe_goaway_reply()
 
     def _abort_stream(self, st, exc):
         """Error a stream, unblock its waiters, remove it, and free its slot."""
@@ -912,6 +925,7 @@ class StreamManager:
         st.window_evt.set()  # unblock a sender parked on flow control (it re-checks st.error)
         if self._streams.pop(st.id, None) is not None:
             self._release_slot(st)
+            self._on_stream_gone()  # no-op during `fail_all` (`_conn.error` already set)
 
     def handle_go_away(self, last_stream_id, exc):
         """Peer sent GOAWAY: refuse new streams; streams > last_stream_id were

{httpunk-0.1.4 → httpunk-0.1.5}/tests/test_asyncio_protocol.py

@@ -159,6 +159,36 @@ async def test_h2_protocol_graceful_shutdown():
         await conn.__aexit__(None, None, None)
 
 
+@pytest.mark.asyncio
+async def test_h2_protocol_closes_after_client_goaway():
+    """The CLIENT GOAWAYs an idle connection: the server replies GOAWAY(NO_ERROR) and
+    then CLOSES — its serve task ends and the client reads EOF (F23, server role, on
+    the asyncio backend). It used to reply and then leak the connection forever:
+    the read pump exited without ending the accept loop, so nothing closed."""
+    server, host, port, protocols = await _serve(_EchoH2)
+    async with server:
+        r, w = await asyncio.open_connection(host, port)
+        # Preface + empty SETTINGS; let the server's SETTINGS arrive and ack it so our
+        # ack is not left unread in its buffer (which would turn the FIN into a RST).
+        w.write(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" + b"\x00\x00\x00\x04\x00\x00\x00\x00\x00")
+        await w.drain()
+        await asyncio.wait_for(r.read(65536), 5)  # server SETTINGS (+ WINDOW_UPDATE)
+        w.write(b"\x00\x00\x00\x04\x01\x00\x00\x00\x00")  # SETTINGS ack
+        w.write(b"\x00\x00\x08\x07\x00\x00\x00\x00\x00" + b"\x00" * 8)  # GOAWAY(last=0, NO_ERROR)
+        await w.drain()
+        got = b""
+        while chunk := await asyncio.wait_for(r.read(65536), 5):  # hangs here without the fix
+            got += chunk
+        frames, i = [], 0  # raw framing: (type, payload)
+        while i < len(got):
+            n = int.from_bytes(got[i : i + 3], "big")
+            frames.append((got[i + 3], got[i + 9 : i + 9 + n]))
+            i += 9 + n
+        assert [p for t, p in frames if t == 0x07] == [b"\x00" * 8]  # GOAWAY(last=0, NO_ERROR), then EOF
+        await asyncio.wait_for(protocols[0].wait_closed(), 5)
+        w.close()
+
+
 @pytest.mark.asyncio
 async def test_h1_protocol_graceful_shutdown_releases_idle():
     # h1 graceful releases the idle head-read (via backend.select) and closes; the

{httpunk-0.1.4 → httpunk-0.1.5}/tests/test_h2_errors.py

@@ -9,6 +9,7 @@ from tonio.colored import Event, scope, sleep
 from tonio.colored.net import open_tcp_listeners
 
 from httpunk import (
+    ConnectionClosedError,
     GoAwayError,
     H2Connection,
     H2Error,
@@ -24,6 +25,7 @@ from httpunk._httpunk import (
     H2FrameData as Data,
     H2FrameGoAway as GoAway,
     H2FrameHeaders as Headers,
+    H2FramePing as Ping,
     H2FrameRstStream as RstStream,
     H2FrameSettings as Settings,
 )
@@ -809,3 +811,47 @@ async def test_end_stream_with_content_length_resets_not_hangs():
             with pytest.raises(H2Error):  # RST_STREAM(PROTOCOL_ERROR), woken promptly
                 await conn.request("GET", "/")
         s.cancel()
+
+
+@pytest.mark.tonio
+async def test_close_flushes_queued_frames_even_after_connection_error():
+    """`close()` drains the control-frame queue BEFORE the FIN regardless of
+    `error` being set — h2's `State::Closing` runs `codec.shutdown` (flush, then
+    shutdown) on every non-IO close (connection.rs L304-310). The GOAWAY-exchanged
+    clean close (F23) relies on this: its reply GOAWAY is queued with `error` already
+    set, and whether the write pump wakes before `close()` tears it down is a
+    scheduler race. The write-pump wake is stubbed out so the queue is guaranteed
+    to still hold the frame when `close()` runs."""
+    listener = (await open_tcp_listeners(0, host="127.0.0.1"))[0]
+    host, port = listener.socket.getsockname()[:2]
+    seen = []
+
+    async def server():
+        stream, codec, frames = await _accept_handshake(listener)
+        for f in frames:
+            if isinstance(f, Settings) and not f.ack:
+                await stream.send_all(codec.serialize_settings_ack())
+        while True:
+            chunk = await stream.receive_some(65536)
+            if not chunk:
+                seen.append("eof")
+                break
+            for f in codec.receive(chunk):
+                if isinstance(f, Settings) and not f.ack:
+                    await stream.send_all(codec.serialize_settings_ack())
+                else:
+                    seen.append(f)
+
+    async with scope() as s:
+        s.spawn(server())
+        async with open_h2(host, port) as conn:
+            inner = conn._conn
+            inner._write_evt.set = lambda: None  # the pump never wakes: the frame stays queued
+            inner.enqueue_frame(inner.codec.serialize_ping(b"flushme!"))
+            inner.error = ConnectionClosedError("simulated failure")
+        # `__aexit__` -> `close()` must have written the queued PING before closing.
+        while seen[-1:] != ["eof"]:
+            await sleep(0)
+        s.cancel()
+
+    assert any(isinstance(f, Ping) and f.data == b"flushme!" for f in seen), seen

{httpunk-0.1.4 → httpunk-0.1.5}/tests/test_h2_server.py

@@ -568,3 +568,152 @@ async def test_h2_bodyless_request_with_trailers():
 
     assert seen["body"] == b""
     assert seen["trailers"].get("x-done") == b"1"
+
+
+# ===== peer GOAWAY → acknowledging GOAWAY + connection done (F23, server role) =====
+
+
+async def _serve_and_report(listener, done):
+    """Serve one connection; set `done` once the accept loop has exited and the
+    server's `__aexit__` has run (i.e. the transport is closed)."""
+    transport = await listener.accept()
+    with contextlib.suppress(Exception):
+        async with H2Server(transport) as server, scope() as handlers:
+            async for req in server:
+
+                async def handle(r):
+                    await r.read()
+                    await r.respond(200, body=b"ok")
+
+                handlers.spawn(handle(req))
+    done.set()
+
+
+async def _settle_handshake(transport, codec, seen):
+    """Read the server's SETTINGS and ack it BEFORE the test sends GOAWAY: once the
+    server has replied GOAWAY it stops reading (h2: `should_close_now` → no more
+    `poll_next`), so a SETTINGS ack still in flight would sit unread in its socket
+    buffer and turn its close into a TCP RST instead of a FIN."""
+    while not any(isinstance(f, Settings) and not f.ack for f in seen):
+        data = await transport.receive_some(65536)
+        assert data
+        for f in codec.receive(data):
+            if isinstance(f, Settings) and not f.ack:
+                await transport.send_all(codec.serialize_settings_ack())
+            seen.append(f)
+
+
+async def _read_until_eof(transport, codec, *, seen=None):
+    """Read frames (acking SETTINGS) until the peer's FIN. Returns the frames seen."""
+    seen = [] if seen is None else seen
+    while True:
+        data = await transport.receive_some(65536)
+        if not data:
+            return seen
+        for f in codec.receive(data):
+            if isinstance(f, Settings) and not f.ack:
+                await transport.send_all(codec.serialize_settings_ack())
+            seen.append(f)
+
+
+async def _assert_goaway_then_eof(transport, codec, done, *, seen=None):
+    """The one contract under test: the server replies GOAWAY(NO_ERROR), then CLOSES
+    (the client reads EOF — without the fix it hangs here), and its accept loop ends."""
+    seen = await _read_until_eof(transport, codec, seen=seen)
+    goaways = [f for f in seen if isinstance(f, GoAway)]
+    assert len(goaways) == 1 and goaways[0].error_code == H2Reason.NO_ERROR
+    await done.wait()
+    transport.close()
+    return seen
+
+
+@pytest.mark.tonio
+@pytest.mark.parametrize("last_id", [0, 1])
+async def test_server_closes_after_goaway_reply_when_idle(last_id):
+    """Peer GOAWAY on an idle connection (one completed request): the server sends its
+    acknowledging GOAWAY(NO_ERROR) AND closes the connection / ends the accept loop —
+    h2 `go_away_now` → `should_close_now` → the connection future resolves (F23).
+    Previously only the GOAWAY went out and the socket leaked forever."""
+    listener, host, port = await _listener()
+    done = Event()
+    async with scope() as s:
+        s.spawn(_serve_and_report(listener, done))
+        transport, codec = await _raw_handshake(host, port)
+        await transport.send_all(codec.serialize_request_headers(1, "GET", "http://x/", end_stream=True))
+        seen = []
+        while not any(isinstance(f, Headers) for f in seen):  # full response for stream 1
+            data = await transport.receive_some(65536)
+            assert data
+            for f in codec.receive(data):
+                if isinstance(f, Settings) and not f.ack:
+                    await transport.send_all(codec.serialize_settings_ack())
+                seen.append(f)
+        await transport.send_all(codec.serialize_go_away(last_id, H2Reason.NO_ERROR))
+        await _assert_goaway_then_eof(transport, codec, done, seen=seen)
+        s.cancel()
+
+
+@pytest.mark.tonio
+async def test_server_closes_after_goaway_reply_no_streams_ever():
+    """Peer GOAWAY right after the handshake, no stream ever opened: same contract."""
+    listener, host, port = await _listener()
+    done = Event()
+    async with scope() as s:
+        s.spawn(_serve_and_report(listener, done))
+        transport, codec = await _raw_handshake(host, port)
+        seen = []
+        await _settle_handshake(transport, codec, seen)
+        await transport.send_all(codec.serialize_go_away(0, H2Reason.NO_ERROR))
+        await _assert_goaway_then_eof(transport, codec, done, seen=seen)
+        s.cancel()
+
+
+@pytest.mark.tonio
+async def test_server_closes_after_goaway_received_mid_request():
+    """Peer GOAWAY(last=1) while stream 1 is still in flight, and the peer sends NOTHING
+    more. Stream 1 finishing is a local event — h2's `drop_stream_ref` wakes the
+    connection task so the idle check re-runs (streams.rs L1647); httpunk must do the
+    same from the stream-close path, not only after inbound bytes."""
+    listener, host, port = await _listener()
+    done = Event()
+    async with scope() as s:
+        s.spawn(_serve_and_report(listener, done))
+        transport, codec = await _raw_handshake(host, port)
+        seen = []
+        await _settle_handshake(transport, codec, seen)
+        # Request body still pending (no END_STREAM) when the GOAWAY lands...
+        await transport.send_all(codec.serialize_request_headers(1, "POST", "http://x/", end_stream=False))
+        await transport.send_all(codec.serialize_go_away(1, H2Reason.NO_ERROR))
+        # ...then finish it; after this the client is silent.
+        await transport.send_all(codec.serialize_data(1, b"x", end_stream=True))
+        seen = await _assert_goaway_then_eof(transport, codec, done, seen=seen)
+        # Stream 1 was <= last_stream_id, so it was served before the close.
+        assert any(isinstance(f, Headers) and f.stream_id == 1 and f.status == 200 for f in seen)
+        s.cancel()
+
+
+@pytest.mark.tonio
+async def test_server_keeps_serving_after_phase1_goaway():
+    """A phase-1 graceful GOAWAY (last_stream_id = 2^31-1) is NOT an idle-close
+    trigger: the connection must stay open and keep serving (h2 `should_close_on_idle`
+    excludes `StreamId::MAX`)."""
+    listener, host, port = await _listener()
+    done = Event()
+    async with scope() as s:
+        s.spawn(_serve_and_report(listener, done))
+        transport, codec = await _raw_handshake(host, port)
+        await transport.send_all(codec.serialize_go_away(2**31 - 1, H2Reason.NO_ERROR))
+        await transport.send_all(codec.serialize_request_headers(1, "GET", "http://x/", end_stream=True))
+        seen = []
+        while not any(isinstance(f, Headers) for f in seen):
+            data = await transport.receive_some(65536)
+            assert data, "server closed after a phase-1 GOAWAY"
+            for f in codec.receive(data):
+                if isinstance(f, Settings) and not f.ack:
+                    await transport.send_all(codec.serialize_settings_ack())
+                seen.append(f)
+        assert not any(isinstance(f, GoAway) for f in seen)
+        assert not done.is_set()
+        transport.close()
+        await done.wait()  # the server sees our FIN and exits cleanly
+        s.cancel()