httpunk 0.2.0__tar.gz → 0.2.1__tar.gz

{httpunk-0.2.0 → httpunk-0.2.1}/Cargo.lock

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

{httpunk-0.2.0 → httpunk-0.2.1}/Cargo.toml

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

{httpunk-0.2.0 → httpunk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{httpunk-0.2.0 → httpunk-0.2.1}/httpunk/h2/connection.py

@@ -178,12 +178,12 @@ class H2ConnectionBase:
         # (F23). 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._transport is not None:
+        if self._transport is not None:
             with contextlib.suppress(Exception):
                 async with self._send_lock:
-                    await self._transport.send_all(pending)
+                    pending = self._take_pending()
+                    if pending:
+                        await self._transport.send_all(pending)
         if self._transport is not None:
             self.backend.close_transport(self._transport)
         handle, self._read_handle = self._read_handle, None
@@ -197,8 +197,13 @@ class H2ConnectionBase:
         self.streams.fail_all(self.error or ConnectionClosedError("connection closed"))
 
     async def send_frame(self, data):
+        # Drain-then-send under the one send lock: control frames committed
+        # (enqueued) before we acquired the wire go out first, so wire order =
+        # commit order — h2's single-queue property (a GOAWAY thus follows the
+        # RSTs committed before it, like h2 flushing its pending queue). See
+        # the design note below.
         async with self._send_lock:
-            await self._transport.send_all(data)
+            await self._transport.send_all(self._take_pending() + data)
 
     # Design note (why three send paths, vs h2's single frame queue): in the h2
     # crate ALL socket I/O belongs to the one connection task — user handles only
@@ -229,6 +234,24 @@ class H2ConnectionBase:
     #   close in user-task context; `close()` drains the queue before the FIN, so
     #   flushed-before-stop still holds.
     #
+    # ORDERING INVARIANT (the property h2's single queue gives for free, restored
+    # here for the hybrid): a control frame committed to the pending buffer before
+    # a sender acquires `_send_lock` reaches the wire before that sender's bytes.
+    # Two pieces enforce it, and both are load-bearing:
+    # - inline senders (`send_frame`, `send_frame_or_fail`) drain the buffer via
+    #   `_take_pending` and write it FIRST, under the send lock they hold;
+    # - the pump swaps the buffer INSIDE `_send_lock` (`_write_pump`), so a batch
+    #   swapped out but not yet written can never coexist with an available lock
+    #   (or an inline sender slipping in between swap and flush would still
+    #   invert the order).
+    # Without it, the RST/WINDOW_UPDATE a dispatch enqueues can lose the wire
+    # race to a response committed AFTER it (h2 guarantees the reverse), which is
+    # peer-observable: the forgotten-stream RST arriving after the next stream's
+    # response flaked F17 in CI. Lock order is send -> buf everywhere; the buffer
+    # lock is a sync leaf, never held across an await. NOT covered (unchanged,
+    # matches the pre-existing hybrid semantics): two INLINE sends serialize in
+    # lock-acquisition order, not state-commit order.
+    #
     # 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;
     # this hybrid was chosen to keep F41's zero-buffering and the inline hot path.
@@ -243,6 +266,18 @@ class H2ConnectionBase:
             self._write_buf += data
             self._write_evt.set()
 
+    def _take_pending(self):
+        """Swap out everything committed to the pending-send buffer. MUST be
+        called while holding `_send_lock` — writing what you take while still
+        holding it is what makes wire order equal commit order (see the design
+        note above). Deliberately does NOT clear `_write_evt`: only the pump
+        clears, in the same locked section where it observes `_write_stop` — a
+        drain that cleared here could erase `close()`'s paired stop+wake and
+        hang the pump join. The cost is one spurious empty pump wake."""
+        with self._write_buf_lock:
+            data, self._write_buf = bytes(self._write_buf), bytearray()
+        return data
+
     async def _write_pump(self):
         """Flush the pending-send buffer to the transport. Runs as a bare task
         (`_pump_handle`) and is never cancelled (see `close()` — a cancel landing between the
@@ -257,23 +292,32 @@ class H2ConnectionBase:
         or after the clear (its wake survives for the next iteration) — an
         unlocked clear could erase a wake for bytes not yet swapped (lost
         wakeup on the free-threaded runtime). A write failure fails the whole
-        connection — same as h2, where a connection-task write error is fatal."""
+        connection — same as h2, where a connection-task write error is fatal.
+
+        The swap happens INSIDE `_send_lock`: a batch swapped out but not yet
+        written must not coexist with an available send lock, or an inline
+        sender could slip its (later-committed) frame onto the wire ahead of
+        it — the second half of the ordering invariant (the inline senders'
+        `_take_pending` drain is the first). Lock order is send -> buf
+        everywhere; the buffer lock is a leaf, never held across an await."""
         while True:
             await self._write_evt.wait()
-            with self._write_buf_lock:
-                data, self._write_buf = bytes(self._write_buf), bytearray()
-                self._write_evt.clear()
-                stopping = self._write_stop
-            if data:
-                try:
-                    async with self._send_lock:
+            failed = None
+            async with self._send_lock:
+                with self._write_buf_lock:
+                    data, self._write_buf = bytes(self._write_buf), bytearray()
+                    self._write_evt.clear()
+                    stopping = self._write_stop
+                if data:
+                    try:
                         await self._transport.send_all(data)
-                except OSError as exc:
-                    self._fail(ConnectionClosedError(f"connection closed: {exc}"))
-                    break
-                except Exception as exc:
-                    self._fail(exc)
-                    break
+                    except OSError as exc:
+                        failed = ConnectionClosedError(f"connection closed: {exc}")
+                    except Exception as exc:
+                        failed = exc
+            if failed is not None:
+                self._fail(failed)
+                break
             if stopping:
                 # Drain-then-exit: anything enqueued during the send above left
                 # the event set (its `set()` came after our `clear()`), so loop
@@ -292,8 +336,16 @@ class H2ConnectionBase:
         connection ourselves (h2 equivalent: write errors are connection-fatal;
         partial writes are unrepresentable — the connection task resumes them).
         Cancellation while WAITING for the send lock is safe (nothing written) and
-        does not poison."""
+        does not poison.
+
+        Drains the pending control buffer first (under the lock — wire order =
+        commit order, see the design note): the RST/WINDOW_UPDATE a dispatch
+        committed before this frame can no longer lose the wire race to it
+        (the rsts=0 flake in the forgotten-stream test). An interruption then
+        also loses the drained control frames — moot, since every branch below
+        poisons the connection they belonged to."""
         async with self._send_lock:
+            data = self._take_pending() + data
             try:
                 await self._transport.send_all(data)
             except BaseException as exc:

{httpunk-0.2.0 → httpunk-0.2.1}/httpunk/h2/server.py

@@ -191,7 +191,18 @@ class ServerStreamManager(StreamManager):
         if st is not None:
             if st.state.is_local_error():
                 return None  # locally reset: swallow late frames "for some time"
-            return st  # existing stream -> the shared trailers path
+            if st.state.is_closed():
+                # Completed normally but still stored — the inline-write window
+                # (`StreamManager._drop_closed_stored`): drop it and classify
+                # below exactly as if already forgotten. For a server HEADERS
+                # target the deterministic post-release answer is the
+                # decreased-id connection error (h2 recv.rs `open` L127) — a
+                # peer sending HEADERS after its own END_STREAM violates either
+                # way, and the outcome must not depend on which side of the
+                # window the frame lands on.
+                self._drop_closed_stored(st)
+            else:
+                return st  # existing stream -> the shared trailers path
         reset_at = self._reset_streams.get(sid)
         if reset_at is not None:
             if self._conn.backend.monotonic() - reset_at <= _RESET_STREAM_SECS:

{httpunk-0.2.0 → httpunk-0.2.1}/httpunk/h2/streams.py

@@ -678,6 +678,29 @@ class StreamManager:
 
     # ===== per-frame recv dispatch (h2: proto/streams/streams.rs recv_*) =====
 
+    def _drop_closed_stored(self, st):
+        """Release a normally-completed stream observed while still stored — the
+        inline-write window: `respond`/`send_body` transition the state to Closed
+        BEFORE their awaited wire write and pop the stream only after it, so a
+        truly-parallel dispatch (free-threaded read pump) can catch it in
+        between. Upstream can't: its one connection task flushes, releases, and
+        dispatches serially under the store mutex, so by the time the peer can
+        react to the response the stream is already released. Sync, like all of
+        the lookup classification.
+
+        Deliberately NO waiter repair and NO `st.error`: a fully-closed stream
+        has its head delivered and EOF already queued on the body channel, so
+        nothing can be parked on it — and a straggling reader re-reads
+        `st.error` after EOF, so setting it would turn a completed exchange
+        into a spurious StreamResetError (the F18 repair in `reset_stream` is
+        for streams that closed ERRORED with waiters still parked, not this).
+        The reclaim is a no-op when `respond`/`aclose` already ran it (F22
+        `recv_reclaimed`), and covers the in-window case where it hasn't."""
+        conn_wu = self._reclaim_stream_accounting(st)
+        self._close_stream(st)
+        if conn_wu:
+            self._conn.enqueue_frame(self._conn.codec.serialize_window_update(0, conn_wu))
+
     def _recv_lookup(self, stream_id):
         """Resolve the target stream for an inbound HEADERS/DATA frame, or
         classify why there isn't one.
@@ -698,6 +721,20 @@ class StreamManager:
                 # Locally reset: ignore frames "for some time" (the peer may have
                 # sent trailers/data before receiving our RST_STREAM).
                 return None
+            if st.state.is_closed():
+                # Completed normally but still stored — the inline-write window
+                # (`_drop_closed_stored`). Upstream's serialized lookup can only
+                # ever see this stream as already forgotten, so give the peer
+                # exactly the forgotten answer — drop it and classify
+                # STREAM_CLOSED: the caller then RSTs once and the id enters the
+                # reset store (`reset_on_error`'s forgotten path), making the
+                # peer-visible outcome independent of which side of the window
+                # the frame lands on. (Upstream's own guard here — recv.rs
+                # recv_data L665-673 — calls it a connection error, with a TODO
+                # conceding STREAM_CLOSED; only its seriality keeps that arm
+                # unreachable for a benign peer.)
+                self._drop_closed_stored(st)
+                raise _StreamError(stream_id, int(H2Reason.STREAM_CLOSED))
             return st
         reset_at = self._reset_streams.get(stream_id)
         if reset_at is not None:

{httpunk-0.2.0 → httpunk-0.2.1}/tests/test_h1_server.py

@@ -25,7 +25,14 @@ async def _listener():
 
 async def _raw_client(host, port):
     """A byte-level transport — for wire-fidelity cases the (sequential) httpunk
-    client can't drive: pipelining, HTTP/1.0, upgrades, malformed heads."""
+    client can't drive: pipelining, HTTP/1.0, upgrades, malformed heads.
+
+    Callers must run their test body in `try/finally: transport.close(); s.cancel()`:
+    an assertion that fires while the transport is still open leaves the spawned
+    server parked in a read only our EOF can end (tonio's optimistic cancellation
+    cannot land on its pre-existing waiter), and the scope join then waits it out
+    forever — the conftest deadline turns the real failure into an opaque timeout.
+    Both calls are idempotent, so a body that already closed/cancelled is fine."""
     return await TonioBackend().connect_tcp(host, port)
 
 
@@ -248,12 +255,14 @@ async def test_server_pipelined_requests():
     async with scope() as s:
         s.spawn(_echo_server(listener, seen))
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /a HTTP/1.1\r\nhost: x\r\n\r\nGET /b HTTP/1.1\r\nhost: x\r\n\r\n")
-        data = await _read_until(transport, b"GET /b -> ")
-        assert b"GET /a -> " in data
-        assert b"GET /b -> " in data
-        transport.close()
-        s.cancel()
+        try:
+            await transport.send_all(b"GET /a HTTP/1.1\r\nhost: x\r\n\r\nGET /b HTTP/1.1\r\nhost: x\r\n\r\n")
+            data = await _read_until(transport, b"GET /b -> ")
+            assert b"GET /a -> " in data
+            assert b"GET /b -> " in data
+        finally:
+            transport.close()
+            s.cancel()
     assert seen == ["/a", "/b"]
 
 
@@ -265,11 +274,14 @@ async def test_server_http10_response_version_and_close():
     async with scope() as s:
         s.spawn(_echo_server(listener))
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /old HTTP/1.0\r\nhost: x\r\n\r\n")
-        data = await _drain_all(transport)  # 1.0 default-close → server closes after replying
-        assert data.startswith(b"HTTP/1.0 200")
-        assert b"GET /old -> " in data
-        s.cancel()
+        try:
+            await transport.send_all(b"GET /old HTTP/1.0\r\nhost: x\r\n\r\n")
+            data = await _drain_all(transport)  # 1.0 default-close → server closes after replying
+            assert data.startswith(b"HTTP/1.0 200")
+            assert b"GET /old -> " in data
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -287,10 +299,13 @@ async def test_server_header_read_timeout_closes_slow_head():
     async with scope() as s:
         s.spawn(serve())
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET / HTTP/1.1\r\nhost: x\r\n")  # partial head, never completes
-        data = await _drain_all(transport)  # server times out and closes -> EOF
-        assert data == b""  # no response sent; the connection was just closed
-        s.cancel()
+        try:
+            await transport.send_all(b"GET / HTTP/1.1\r\nhost: x\r\n")  # partial head, never completes
+            data = await _drain_all(transport)  # server times out and closes -> EOF
+            assert data == b""  # no response sent; the connection was just closed
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.asyncio
@@ -333,10 +348,13 @@ async def test_server_detach_hands_off_open_connection():
     async with scope() as s:
         s.spawn(serve())
         client = await _raw_client(host, port)
-        # request head + trailing bytes the client sent past it (must survive as `leftover`)
-        await client.send_all(b"GET /up HTTP/1.1\r\nhost: x\r\nupgrade: custom\r\nconnection: upgrade\r\n\r\nEXTRA")
-        data = await _read_until(client, b"OWNED")
-        s.cancel()
+        try:
+            # request head + trailing bytes the client sent past it (must survive as `leftover`)
+            await client.send_all(b"GET /up HTTP/1.1\r\nhost: x\r\nupgrade: custom\r\nconnection: upgrade\r\n\r\nEXTRA")
+            data = await _read_until(client, b"OWNED")
+        finally:
+            client.close()
+            s.cancel()
 
     assert captured["leftover"] == b"EXTRA"  # bytes past the head handed back
     assert b"101 Switching Protocols" in data and data.endswith(b"OWNED")  # socket stayed open
@@ -350,11 +368,16 @@ async def test_server_no_100_continue_for_http10():
     async with scope() as s:
         s.spawn(_echo_server(listener))
         transport = await _raw_client(host, port)
-        await transport.send_all(b"POST /x HTTP/1.0\r\nhost: x\r\ncontent-length: 3\r\nexpect: 100-continue\r\n\r\nabc")
-        data = await _drain_all(transport)  # 1.0 default-close → server closes after replying
-        assert b"100 Continue" not in data  # F16: no interim for a 1.0 client
-        assert data.startswith(b"HTTP/1.0 200")  # the real response still arrives
-        s.cancel()
+        try:
+            await transport.send_all(
+                b"POST /x HTTP/1.0\r\nhost: x\r\ncontent-length: 3\r\nexpect: 100-continue\r\n\r\nabc"
+            )
+            data = await _drain_all(transport)  # 1.0 default-close → server closes after replying
+            assert b"100 Continue" not in data  # F16: no interim for a 1.0 client
+            assert data.startswith(b"HTTP/1.0 200")  # the real response still arrives
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -375,14 +398,16 @@ async def test_server_http10_streamed_body_with_content_length_reuses():
     async with scope() as s:
         s.spawn(serve())
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /a HTTP/1.0\r\nhost: x\r\nconnection: keep-alive\r\n\r\n")
-        r1 = await _read_until(transport, b"/a")  # head + the 2-byte length-framed body
-        assert r1.startswith(b"HTTP/1.0 200")
-        assert b"connection: keep-alive" in r1.lower()  # reusable, not close-delimited
-        await transport.send_all(b"GET /b HTTP/1.0\r\nhost: x\r\nconnection: keep-alive\r\n\r\n")
-        assert b"/b" in await _read_until(transport, b"/b")  # connection was reused
-        transport.close()
-        s.cancel()
+        try:
+            await transport.send_all(b"GET /a HTTP/1.0\r\nhost: x\r\nconnection: keep-alive\r\n\r\n")
+            r1 = await _read_until(transport, b"/a")  # head + the 2-byte length-framed body
+            assert r1.startswith(b"HTTP/1.0 200")
+            assert b"connection: keep-alive" in r1.lower()  # reusable, not close-delimited
+            await transport.send_all(b"GET /b HTTP/1.0\r\nhost: x\r\nconnection: keep-alive\r\n\r\n")
+            assert b"/b" in await _read_until(transport, b"/b")  # connection was reused
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -393,12 +418,14 @@ async def test_server_http10_keep_alive_header():
     async with scope() as s:
         s.spawn(_echo_server(listener))
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /a HTTP/1.0\r\nhost: x\r\nconnection: keep-alive\r\n\r\n")
-        data = await _read_until(transport, b"\r\n\r\n")
-        assert data.startswith(b"HTTP/1.0 200")
-        assert b"connection: keep-alive" in data.lower()
-        transport.close()
-        s.cancel()
+        try:
+            await transport.send_all(b"GET /a HTTP/1.0\r\nhost: x\r\nconnection: keep-alive\r\n\r\n")
+            data = await _read_until(transport, b"\r\n\r\n")
+            assert data.startswith(b"HTTP/1.0 200")
+            assert b"connection: keep-alive" in data.lower()
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -417,11 +444,14 @@ async def test_server_response_connection_close():
     async with scope() as s:
         s.spawn(serve())
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /a HTTP/1.1\r\nhost: x\r\n\r\n")
-        data = await _drain_all(transport)  # server closes despite the keep-alive request
-        assert b"connection: close" in data.lower()
-        assert b"bye" in data
-        s.cancel()
+        try:
+            await transport.send_all(b"GET /a HTTP/1.1\r\nhost: x\r\n\r\n")
+            data = await _drain_all(transport)  # server closes despite the keep-alive request
+            assert b"connection: close" in data.lower()
+            assert b"bye" in data
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -441,10 +471,13 @@ async def test_server_unread_large_body_closes_not_drains():
     async with scope() as s:
         s.spawn(serve())
         transport = await _raw_client(host, port)
-        await transport.send_all(b"POST / HTTP/1.1\r\nhost: x\r\ncontent-length: 1000000\r\n\r\npartial")
-        data = await _drain_all(transport)  # returns once the server closes (no hang)
-        assert b"ok" in data
-        s.cancel()
+        try:
+            await transport.send_all(b"POST / HTTP/1.1\r\nhost: x\r\ncontent-length: 1000000\r\n\r\npartial")
+            data = await _drain_all(transport)  # returns once the server closes (no hang)
+            assert b"ok" in data
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -468,13 +501,15 @@ async def test_server_upgrade_tunnel():
     async with scope() as s:
         s.spawn(serve())
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /chat HTTP/1.1\r\nhost: x\r\nconnection: upgrade\r\nupgrade: myproto\r\n\r\n")
-        head = await _read_until(transport, b"\r\n\r\n")
-        assert head.startswith(b"HTTP/1.1 101")
-        await transport.send_all(b"ping")
-        assert await transport.receive_some() == b"echo:ping"
-        transport.close()
-        s.cancel()
+        try:
+            await transport.send_all(b"GET /chat HTTP/1.1\r\nhost: x\r\nconnection: upgrade\r\nupgrade: myproto\r\n\r\n")
+            head = await _read_until(transport, b"\r\n\r\n")
+            assert head.startswith(b"HTTP/1.1 101")
+            await transport.send_all(b"ping")
+            assert await transport.receive_some() == b"echo:ping"
+        finally:
+            transport.close()
+            s.cancel()
 
 
 @pytest.mark.tonio
@@ -673,13 +708,18 @@ async def test_abrupt_client_close_ends_iteration_cleanly():
     async with scope() as s:
         s.spawn(server())
         transport = await _raw_client(host, port)
-        await transport.send_all(b"GET /one HTTP/1.1\r\nhost: x\r\n\r\n")
-        resp = b""
-        while b"\r\n\r\n" not in resp:
-            resp += await transport.receive_some(65536)
-        # RST the connection while the server is parked in the next head-read.
-        transport.socket._sock.setsockopt(pysock.SOL_SOCKET, pysock.SO_LINGER, struct.pack("ii", 1, 0))
-        transport.close()
-        # The scope join below waits out the server task: it must finish, cleanly.
+        try:
+            await transport.send_all(b"GET /one HTTP/1.1\r\nhost: x\r\n\r\n")
+            resp = b""
+            while b"\r\n\r\n" not in resp:
+                chunk = await transport.receive_some(65536)
+                assert chunk, "connection closed before the response head"
+                resp += chunk
+            # RST the connection while the server is parked in the next head-read.
+            transport.socket._sock.setsockopt(pysock.SOL_SOCKET, pysock.SO_LINGER, struct.pack("ii", 1, 0))
+        finally:
+            # No s.cancel(): the scope join waiting out the server task — which must
+            # finish CLEANLY on its own — is the assertion under test.
+            transport.close()
     assert served == ["/one"]
     assert not server_errors