httpunk 0.2.2__tar.gz → 0.4.0__tar.gz

{httpunk-0.2.2 → httpunk-0.4.0}/Cargo.lock

@@ -118,7 +118,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.2.2"
+version = "0.4.0"
 dependencies = [
  "bytes",
  "h2",
@@ -132,9 +132,9 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d22053281f852e11534f5198498373cbb59295120a20771d90f7ed1897490a72"
+checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43"
 dependencies = [
  "atomic-waker",
  "bytes",

{httpunk-0.2.2 → httpunk-0.4.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.2.2"
+version = "0.4.0"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",
@@ -61,7 +61,7 @@ vendor-hyper-util = { path = "crates/vendor-hyper-util" }
 # the pinned versions land in Cargo.lock for `cargo audit` / Dependabot advisory
 # coverage without pulling them (and tokio) into the build.
 h2 = { version = "=0.4.19", optional = true }
-hyper = { version = "=1.11.0", optional = true, default-features = false, features = ["http1", "client", "server"] }
+hyper = { version = "=1.11.1", optional = true, default-features = false, features = ["http1", "client", "server"] }
 
 [profile.release]
 codegen-units = 1

{httpunk-0.2.2 → httpunk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.2.2
+Version: 0.4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Dist: tonio~=0.9.12 ; python_full_version >= '3.14' and extra == 'tonio'
+Requires-Dist: tonio~=0.9.15 ; python_full_version >= '3.14' and extra == 'tonio'
 Provides-Extra: tonio
 License-File: LICENSE
 Summary: The Rust HTTP library for Python
@@ -183,6 +183,7 @@ async for chunk in resp.aiter_bytes():
     ...
 
 resp.trailers                     # a HeaderMap of trailing headers, or None
+resp.version                      # httpunk.Version.HTTP_2 / HTTP_11 / HTTP_10 (≈ http::Version)
 ```
 
 A response can be used as an async context manager to guarantee release (cancelling the body
@@ -198,7 +199,9 @@ async with await conn.request("GET", "/big") as resp:
 
 `body` may be `bytes`, or a sync/async iterable of `bytes` (streamed as it is produced).
 `trailers` are header fields sent after the body — chunked trailers on HTTP/1, a trailing
-`HEADERS` frame on HTTP/2:
+`HEADERS` frame on HTTP/2. As in hyper, HTTP/1 trailers ride only on a chunked body (a
+streamed one; a `bytes` body is `Content-Length`-framed and drops them) and only the fields
+the request's own `Trailer` header declares are sent — undeclared ones are dropped:
 
 ```python
 async def chunks():
@@ -207,7 +210,7 @@ async def chunks():
 
 resp = await conn.request(
     "POST", "/upload",
-    headers={"host": "example.com", "content-type": "application/octet-stream"},
+    headers={"host": "example.com", "content-type": "application/octet-stream", "trailer": "x-checksum"},
     body=chunks(),
     trailers={"x-checksum": "..."},
 )
@@ -233,11 +236,51 @@ async with H1Server(transport, backend=Backend.asyncio) as server:
         await request.respond(200, headers={"content-type": "text/plain"}, body=body)
 ```
 
-Each `request` carries `method`, `target`/`path`, `headers`, and a streamable body
+Each `request` carries `method`, `target`/`path`, `headers`, `version`, and a streamable body
 (`request.read()` / `request.aiter_bytes()`). Answer it with `request.respond(status, *,
-headers=None, body=None)`. On HTTP/2 you can also abort a single stream with
-`request.reset()` instead of responding (e.g. when a handler fails) — the connection and its
-other streams keep running.
+headers=None, body=None, trailers=None)` — `trailers` are sent after the body (HTTP/1.1
+chunked trailers; an HTTP/2 trailing HEADERS frame), like the client's `Request.trailers` and
+under hyper's rules: on HTTP/1.1 they need a chunked (streamed) body and a `Trailer` header
+declaring the fields, and go out only if the request declared `TE: trailers`; otherwise they
+are dropped and the body ends normally, as hyper's server does.
+On HTTP/2 you can also abort a single stream with `request.reset()` instead of responding
+(e.g. when a handler fails) — the connection and its other streams keep running — and
+`await request.reset_received()` resolves with the reason
+when the *client* abandons the request (`RST_STREAM`, even after it finished sending), the
+signal a long-running or streaming handler races against its own completion to stop early.
+A reset also fails an in-flight `respond()` / `send_data` with `StreamResetError` carrying the
+client's reason, including while the body is waiting on the app's next chunk. The HTTP/1 twin
+is `await request.peer_closed()`: once the request body is complete, a client that closes the
+connection before the response is done is detected (hyper's `mid_message_detect_eof`), the
+in-flight `respond()` / `send_data` fail with `H1IncompleteMessageError`, and the accept loop
+ends. The await resolves either way and never hangs: `True` when the client closed
+mid-request, `False` once the exchange completed (or failed) first, at once if it already had.
+`H1Server(half_close=True)` turns the detection off, as hyper's `half_close` does. A request
+announcing an upgrade (`Upgrade: h2c`, `Upgrade: websocket`, CONNECT) is watched only from its
+response head on, when it can no longer be detached or switched.
+
+When `respond()` fails this way while streaming an async body, the failure is raised at once
+even if the body is parked waiting for its next chunk: the producer is cancelled at that
+`await` (as hyper drops the body future), its `finally` blocks run, and only then does
+`respond()` raise. Cancelling the task that awaits `respond()` cancels the producer the same way.
+
+For push-style producers (an ASGI `send()` loop, a server-sent-events endpoint) use
+`request.send_response(status, *, headers=None, end_stream=False)`: it writes the head now and
+returns a `SendStream` — h2's `SendResponse`/`SendStream` shape, identical on both protocols:
+
+```python
+stream = await request.send_response(200, headers={"content-type": "text/event-stream"})
+await stream.send_data(b"data: 1\n\n")            # each write awaits backpressure
+await stream.send_data(b"data: 2\n\n", end_stream=True)
+# stream.send_trailers({...}) ends the body with trailers; stream.send_reset() aborts it
+```
+
+`end_stream=True` on `send_response` is a bodyless response. Framing follows hyper: a
+`content-length` you set is honoured, otherwise the body is chunked (HTTP/1.1) or
+close-delimited (HTTP/1.0); on HEAD/204/304 body chunks are discarded, as hyper never polls
+that body. `send_reset` is `RST_STREAM(CANCEL)` on HTTP/2; HTTP/1 has no per-request reset, so
+there it closes the connection (what hyper does when a response body errors). `respond()` is
+the pull convenience built on the same path.
 
 HTTP/1 serves one request/response at a time (the loop won't yield the next until the current
 one is answered); HTTP/2 multiplexes, so for concurrent handling you would spawn a task per
@@ -275,24 +318,32 @@ h.raw_items()                # [(b'content-type', b'text/plain'), (b'set-cookie'
 
 ### Errors
 
-httpunk's exceptions all derive from a common `HTTPunkError` root. `ConnectionClosedError`
-is **protocol-neutral** — raised on both HTTP/1 and HTTP/2 when the transport closes with
-work in flight — so it sits directly under the root. Every **HTTP/2-specific** error shares
-the `H2Error` sub-base:
+httpunk's exceptions all derive from a common `HTTPunkError` root, with one class per
+public error kind of the upstream crate, so a caller can match on what hyper or h2 would
+have reported. `ConnectionClosedError` is **protocol-neutral** — hyper's `Io` and h2's
+`Io`: the transport failed with work in flight — so it sits directly under the root. The
+**HTTP/1** errors mirror hyper's `Error` kinds under `H1Error`; the **HTTP/2** errors
+mirror the h2 crate's under `H2Error`:
 
 ```
 HTTPunkError
-├── ConnectionClosedError    transport closed / IO error with work in flight  (HTTP/1 + HTTP/2)
-└── H2Error                  base for HTTP/2 protocol errors
-    ├── H2ProtocolError      connection-level protocol violation (-> GOAWAY)
-    ├── H2StreamError        stream-level protocol violation (-> RST_STREAM)
-    ├── H2UserError          local API misuse
-    ├── H2FlowControlError   flow-control window over/underflow
-    ├── GoAwayError          the peer sent GOAWAY
-    └── StreamResetError     the peer sent RST_STREAM for a stream
+├── ConnectionClosedError        transport closed / IO error with work in flight  (hyper Io, h2 Io)
+├── H1Error                      base for HTTP/1 errors (hyper `Error` kinds)
+│   ├── H1ParseError             malformed message head (hyper Parse) — args = (kind, message)
+│   ├── H1BodyError              malformed or truncated body (hyper Body) — args = (io_kind, message)
+│   ├── H1IncompleteMessageError EOF while a message was still expected (hyper IncompleteMessage)
+│   ├── H1UnexpectedMessageError bytes on an idle client connection (hyper UnexpectedMessage)
+│   └── H1UserError              local misuse hyper reports on the wire path (hyper User) — args = (kind, message)
+└── H2Error                      base for HTTP/2 protocol errors
+    ├── H2ProtocolError          connection-level protocol violation (-> GOAWAY)
+    ├── H2StreamError            stream-level protocol violation (-> RST_STREAM)
+    ├── H2UserError              local API misuse
+    ├── H2FlowControlError       flow-control window over/underflow
+    ├── GoAwayError              the peer sent GOAWAY
+    └── StreamResetError         the peer sent RST_STREAM for a stream
 ```
 
-Catch `H2Error` for HTTP/2 protocol failures, `ConnectionClosedError` for a dropped
+Catch `H1Error` / `H2Error` for protocol failures, `ConnectionClosedError` for a dropped
 transport, or `HTTPunkError` for anything httpunk raises.
 
 `GoAwayError` carries `last_stream_id`, `error_code` and `debug_data`; `StreamResetError`
@@ -300,7 +351,7 @@ carries `stream_id` and `error_code`. Error codes are `H2Reason` members (an `In
 they compare equal to plain ints) for known codes, or a raw int otherwise.
 
 ```python
-from httpunk import ConnectionClosedError, GoAwayError, HTTPunkError, StreamResetError
+from httpunk import ConnectionClosedError, GoAwayError, H1BodyError, HTTPunkError, StreamResetError
 
 try:
     resp = await conn.request("GET", "/")
@@ -310,6 +361,9 @@ except StreamResetError as exc:
 except GoAwayError as exc:
     # streams above last_stream_id were not processed and are safe to retry
     print("server going away:", exc.last_stream_id)
+except H1BodyError as exc:
+    io_kind, message = exc.args
+    print("truncated" if io_kind == "unexpected_eof" else "malformed body")
 except ConnectionClosedError:
     print("transport dropped")
 except HTTPunkError:
@@ -355,6 +409,25 @@ async with server:
         await request.respond(200, body=b"ok")
 ```
 
+To configure per-protocol options, use `auto.Builder` (hyper-util's `auto::Builder`): `http1()` /
+`http2()` return sub-builders whose setters chain, `http1_only()` / `http2_only()` force a protocol,
+and `serve_connection(transport, cancel=None)` sniffs and builds. `serve()` is the default-options
+shortcut over it.
+
+```python
+builder = auto.Builder(backend=Backend.asyncio)
+builder.http1().header_read_timeout(5.0).http2().max_concurrent_streams(200)
+server = await builder.serve_connection(transport)
+```
+
+The option set mirrors hyper's server builders, with hyper's defaults. HTTP/1
+(`http1::Builder`): `header_read_timeout`, `keep_alive`, `max_headers`, `max_buf_size`,
+`auto_date_header`, `title_case_headers`, `ignore_invalid_headers`. HTTP/2 (`http2::Builder`):
+`max_concurrent_streams`, `initial_stream_window_size`, `initial_connection_window_size`,
+`max_frame_size`, `max_header_list_size`, `max_pending_accept_reset_streams`,
+`max_local_error_reset_streams`, `auto_date_header`, `max_send_buf_size`, plus h2's
+`data_frame_budget`. The same keywords are accepted by `H1Server(...)` / `H2Server(...)` directly.
+
 #### Connection pools
 
 `httpunk.util.pool` provides three composable pools. A *connector* is an async callable

{httpunk-0.2.2 → httpunk-0.4.0}/README.md

@@ -147,6 +147,7 @@ async for chunk in resp.aiter_bytes():
     ...
 
 resp.trailers                     # a HeaderMap of trailing headers, or None
+resp.version                      # httpunk.Version.HTTP_2 / HTTP_11 / HTTP_10 (≈ http::Version)
 ```
 
 A response can be used as an async context manager to guarantee release (cancelling the body
@@ -162,7 +163,9 @@ async with await conn.request("GET", "/big") as resp:
 
 `body` may be `bytes`, or a sync/async iterable of `bytes` (streamed as it is produced).
 `trailers` are header fields sent after the body — chunked trailers on HTTP/1, a trailing
-`HEADERS` frame on HTTP/2:
+`HEADERS` frame on HTTP/2. As in hyper, HTTP/1 trailers ride only on a chunked body (a
+streamed one; a `bytes` body is `Content-Length`-framed and drops them) and only the fields
+the request's own `Trailer` header declares are sent — undeclared ones are dropped:
 
 ```python
 async def chunks():
@@ -171,7 +174,7 @@ async def chunks():
 
 resp = await conn.request(
     "POST", "/upload",
-    headers={"host": "example.com", "content-type": "application/octet-stream"},
+    headers={"host": "example.com", "content-type": "application/octet-stream", "trailer": "x-checksum"},
     body=chunks(),
     trailers={"x-checksum": "..."},
 )
@@ -197,11 +200,51 @@ async with H1Server(transport, backend=Backend.asyncio) as server:
         await request.respond(200, headers={"content-type": "text/plain"}, body=body)
 ```
 
-Each `request` carries `method`, `target`/`path`, `headers`, and a streamable body
+Each `request` carries `method`, `target`/`path`, `headers`, `version`, and a streamable body
 (`request.read()` / `request.aiter_bytes()`). Answer it with `request.respond(status, *,
-headers=None, body=None)`. On HTTP/2 you can also abort a single stream with
-`request.reset()` instead of responding (e.g. when a handler fails) — the connection and its
-other streams keep running.
+headers=None, body=None, trailers=None)` — `trailers` are sent after the body (HTTP/1.1
+chunked trailers; an HTTP/2 trailing HEADERS frame), like the client's `Request.trailers` and
+under hyper's rules: on HTTP/1.1 they need a chunked (streamed) body and a `Trailer` header
+declaring the fields, and go out only if the request declared `TE: trailers`; otherwise they
+are dropped and the body ends normally, as hyper's server does.
+On HTTP/2 you can also abort a single stream with `request.reset()` instead of responding
+(e.g. when a handler fails) — the connection and its other streams keep running — and
+`await request.reset_received()` resolves with the reason
+when the *client* abandons the request (`RST_STREAM`, even after it finished sending), the
+signal a long-running or streaming handler races against its own completion to stop early.
+A reset also fails an in-flight `respond()` / `send_data` with `StreamResetError` carrying the
+client's reason, including while the body is waiting on the app's next chunk. The HTTP/1 twin
+is `await request.peer_closed()`: once the request body is complete, a client that closes the
+connection before the response is done is detected (hyper's `mid_message_detect_eof`), the
+in-flight `respond()` / `send_data` fail with `H1IncompleteMessageError`, and the accept loop
+ends. The await resolves either way and never hangs: `True` when the client closed
+mid-request, `False` once the exchange completed (or failed) first, at once if it already had.
+`H1Server(half_close=True)` turns the detection off, as hyper's `half_close` does. A request
+announcing an upgrade (`Upgrade: h2c`, `Upgrade: websocket`, CONNECT) is watched only from its
+response head on, when it can no longer be detached or switched.
+
+When `respond()` fails this way while streaming an async body, the failure is raised at once
+even if the body is parked waiting for its next chunk: the producer is cancelled at that
+`await` (as hyper drops the body future), its `finally` blocks run, and only then does
+`respond()` raise. Cancelling the task that awaits `respond()` cancels the producer the same way.
+
+For push-style producers (an ASGI `send()` loop, a server-sent-events endpoint) use
+`request.send_response(status, *, headers=None, end_stream=False)`: it writes the head now and
+returns a `SendStream` — h2's `SendResponse`/`SendStream` shape, identical on both protocols:
+
+```python
+stream = await request.send_response(200, headers={"content-type": "text/event-stream"})
+await stream.send_data(b"data: 1\n\n")            # each write awaits backpressure
+await stream.send_data(b"data: 2\n\n", end_stream=True)
+# stream.send_trailers({...}) ends the body with trailers; stream.send_reset() aborts it
+```
+
+`end_stream=True` on `send_response` is a bodyless response. Framing follows hyper: a
+`content-length` you set is honoured, otherwise the body is chunked (HTTP/1.1) or
+close-delimited (HTTP/1.0); on HEAD/204/304 body chunks are discarded, as hyper never polls
+that body. `send_reset` is `RST_STREAM(CANCEL)` on HTTP/2; HTTP/1 has no per-request reset, so
+there it closes the connection (what hyper does when a response body errors). `respond()` is
+the pull convenience built on the same path.
 
 HTTP/1 serves one request/response at a time (the loop won't yield the next until the current
 one is answered); HTTP/2 multiplexes, so for concurrent handling you would spawn a task per
@@ -239,24 +282,32 @@ h.raw_items()                # [(b'content-type', b'text/plain'), (b'set-cookie'
 
 ### Errors
 
-httpunk's exceptions all derive from a common `HTTPunkError` root. `ConnectionClosedError`
-is **protocol-neutral** — raised on both HTTP/1 and HTTP/2 when the transport closes with
-work in flight — so it sits directly under the root. Every **HTTP/2-specific** error shares
-the `H2Error` sub-base:
+httpunk's exceptions all derive from a common `HTTPunkError` root, with one class per
+public error kind of the upstream crate, so a caller can match on what hyper or h2 would
+have reported. `ConnectionClosedError` is **protocol-neutral** — hyper's `Io` and h2's
+`Io`: the transport failed with work in flight — so it sits directly under the root. The
+**HTTP/1** errors mirror hyper's `Error` kinds under `H1Error`; the **HTTP/2** errors
+mirror the h2 crate's under `H2Error`:
 
 ```
 HTTPunkError
-├── ConnectionClosedError    transport closed / IO error with work in flight  (HTTP/1 + HTTP/2)
-└── H2Error                  base for HTTP/2 protocol errors
-    ├── H2ProtocolError      connection-level protocol violation (-> GOAWAY)
-    ├── H2StreamError        stream-level protocol violation (-> RST_STREAM)
-    ├── H2UserError          local API misuse
-    ├── H2FlowControlError   flow-control window over/underflow
-    ├── GoAwayError          the peer sent GOAWAY
-    └── StreamResetError     the peer sent RST_STREAM for a stream
+├── ConnectionClosedError        transport closed / IO error with work in flight  (hyper Io, h2 Io)
+├── H1Error                      base for HTTP/1 errors (hyper `Error` kinds)
+│   ├── H1ParseError             malformed message head (hyper Parse) — args = (kind, message)
+│   ├── H1BodyError              malformed or truncated body (hyper Body) — args = (io_kind, message)
+│   ├── H1IncompleteMessageError EOF while a message was still expected (hyper IncompleteMessage)
+│   ├── H1UnexpectedMessageError bytes on an idle client connection (hyper UnexpectedMessage)
+│   └── H1UserError              local misuse hyper reports on the wire path (hyper User) — args = (kind, message)
+└── H2Error                      base for HTTP/2 protocol errors
+    ├── H2ProtocolError          connection-level protocol violation (-> GOAWAY)
+    ├── H2StreamError            stream-level protocol violation (-> RST_STREAM)
+    ├── H2UserError              local API misuse
+    ├── H2FlowControlError       flow-control window over/underflow
+    ├── GoAwayError              the peer sent GOAWAY
+    └── StreamResetError         the peer sent RST_STREAM for a stream
 ```
 
-Catch `H2Error` for HTTP/2 protocol failures, `ConnectionClosedError` for a dropped
+Catch `H1Error` / `H2Error` for protocol failures, `ConnectionClosedError` for a dropped
 transport, or `HTTPunkError` for anything httpunk raises.
 
 `GoAwayError` carries `last_stream_id`, `error_code` and `debug_data`; `StreamResetError`
@@ -264,7 +315,7 @@ carries `stream_id` and `error_code`. Error codes are `H2Reason` members (an `In
 they compare equal to plain ints) for known codes, or a raw int otherwise.
 
 ```python
-from httpunk import ConnectionClosedError, GoAwayError, HTTPunkError, StreamResetError
+from httpunk import ConnectionClosedError, GoAwayError, H1BodyError, HTTPunkError, StreamResetError
 
 try:
     resp = await conn.request("GET", "/")
@@ -274,6 +325,9 @@ except StreamResetError as exc:
 except GoAwayError as exc:
     # streams above last_stream_id were not processed and are safe to retry
     print("server going away:", exc.last_stream_id)
+except H1BodyError as exc:
+    io_kind, message = exc.args
+    print("truncated" if io_kind == "unexpected_eof" else "malformed body")
 except ConnectionClosedError:
     print("transport dropped")
 except HTTPunkError:
@@ -319,6 +373,25 @@ async with server:
         await request.respond(200, body=b"ok")
 ```
 
+To configure per-protocol options, use `auto.Builder` (hyper-util's `auto::Builder`): `http1()` /
+`http2()` return sub-builders whose setters chain, `http1_only()` / `http2_only()` force a protocol,
+and `serve_connection(transport, cancel=None)` sniffs and builds. `serve()` is the default-options
+shortcut over it.
+
+```python
+builder = auto.Builder(backend=Backend.asyncio)
+builder.http1().header_read_timeout(5.0).http2().max_concurrent_streams(200)
+server = await builder.serve_connection(transport)
+```
+
+The option set mirrors hyper's server builders, with hyper's defaults. HTTP/1
+(`http1::Builder`): `header_read_timeout`, `keep_alive`, `max_headers`, `max_buf_size`,
+`auto_date_header`, `title_case_headers`, `ignore_invalid_headers`. HTTP/2 (`http2::Builder`):
+`max_concurrent_streams`, `initial_stream_window_size`, `initial_connection_window_size`,
+`max_frame_size`, `max_header_list_size`, `max_pending_accept_reset_streams`,
+`max_local_error_reset_streams`, `auto_date_header`, `max_send_buf_size`, plus h2's
+`data_frame_budget`. The same keywords are accepted by `H1Server(...)` / `H2Server(...)` directly.
+
 #### Connection pools
 
 `httpunk.util.pool` provides three composable pools. A *connector* is an async callable

httpunk-0.4.0/crates/vendor-h2/src/error.rs

@@ -0,0 +1,211 @@
+use crate::codec::{SendError, UserError};
+use crate::frame::StreamId;
+use crate::proto::{self, Initiator};
+
+use bytes::Bytes;
+use std::{error, fmt, io};
+
+pub use crate::frame::Reason;
+
+/// Represents HTTP/2 operation errors.
+///
+/// `Error` covers error cases raised by protocol errors caused by the
+/// peer, I/O (transport) errors, and errors caused by the user of the library.
+///
+/// If the error was caused by the remote peer, then it will contain a
+/// [`Reason`] which can be obtained with the [`reason`] function.
+///
+/// [`Reason`]: struct.Reason.html
+/// [`reason`]: #method.reason
+#[derive(Debug)]
+pub struct Error {
+    kind: Kind,
+}
+
+#[derive(Debug)]
+enum Kind {
+    /// A RST_STREAM frame was received or sent.
+    #[allow(dead_code)]
+    Reset(StreamId, Reason, Initiator),
+
+    /// A GO_AWAY frame was received or sent.
+    GoAway(Bytes, Reason, Initiator),
+
+    /// The user created an error from a bare Reason.
+    Reason(Reason),
+
+    /// An error resulting from an invalid action taken by the user of this
+    /// library.
+    User(UserError),
+
+    /// An `io::Error` occurred while trying to read or write.
+    Io(io::Error),
+}
+
+// ===== impl Error =====
+
+impl Error {
+    /// If the error was caused by the remote peer, the error reason.
+    ///
+    /// This is either an error received by the peer or caused by an invalid
+    /// action taken by the peer (i.e. a protocol error).
+    pub fn reason(&self) -> Option<Reason> {
+        match self.kind {
+            Kind::Reset(_, reason, _) | Kind::GoAway(_, reason, _) | Kind::Reason(reason) => {
+                Some(reason)
+            }
+            _ => None,
+        }
+    }
+
+    /// Returns true if the error is an io::Error
+    pub fn is_io(&self) -> bool {
+        matches!(self.kind, Kind::Io(..))
+    }
+
+    /// Returns the error if the error is an io::Error
+    pub fn get_io(&self) -> Option<&io::Error> {
+        match self.kind {
+            Kind::Io(ref e) => Some(e),
+            _ => None,
+        }
+    }
+
+    /// Returns the error if the error is an io::Error
+    pub fn into_io(self) -> Option<io::Error> {
+        match self.kind {
+            Kind::Io(e) => Some(e),
+            _ => None,
+        }
+    }
+
+    pub fn from_io(err: io::Error) -> Self {
+        Error {
+            kind: Kind::Io(err),
+        }
+    }
+
+    /// Returns true if the error is from a `GOAWAY`.
+    pub fn is_go_away(&self) -> bool {
+        matches!(self.kind, Kind::GoAway(..))
+    }
+
+    /// Returns true if the error is from a `RST_STREAM`.
+    pub fn is_reset(&self) -> bool {
+        matches!(self.kind, Kind::Reset(..))
+    }
+
+    /// Returns true if the error was received in a frame from the remote.
+    ///
+    /// Such as from a received `RST_STREAM` or `GOAWAY` frame.
+    pub fn is_remote(&self) -> bool {
+        matches!(
+            self.kind,
+            Kind::GoAway(_, _, Initiator::Remote) | Kind::Reset(_, _, Initiator::Remote)
+        )
+    }
+
+    /// Returns true if the error was created by `h2`.
+    ///
+    /// Such as noticing some protocol error and sending a GOAWAY or RST_STREAM.
+    pub fn is_library(&self) -> bool {
+        matches!(
+            self.kind,
+            Kind::GoAway(_, _, Initiator::Library) | Kind::Reset(_, _, Initiator::Library)
+        )
+    }
+}
+
+impl From<proto::Error> for Error {
+    fn from(src: proto::Error) -> Error {
+        use crate::proto::Error::*;
+
+        Error {
+            kind: match src {
+                Reset(stream_id, reason, initiator) => Kind::Reset(stream_id, reason, initiator),
+                GoAway(debug_data, reason, initiator) => {
+                    Kind::GoAway(debug_data, reason, initiator)
+                }
+                Io(kind, inner) => {
+                    Kind::Io(inner.map_or_else(|| kind.into(), |inner| io::Error::new(kind, inner)))
+                }
+            },
+        }
+    }
+}
+
+impl From<Reason> for Error {
+    fn from(src: Reason) -> Error {
+        Error {
+            kind: Kind::Reason(src),
+        }
+    }
+}
+
+impl From<SendError> for Error {
+    fn from(src: SendError) -> Error {
+        match src {
+            SendError::User(e) => e.into(),
+            SendError::Connection(e) => e.into(),
+        }
+    }
+}
+
+impl From<UserError> for Error {
+    fn from(src: UserError) -> Error {
+        Error {
+            kind: Kind::User(src),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let debug_data = match self.kind {
+            Kind::Reset(_, reason, Initiator::User) => {
+                return write!(fmt, "stream error sent by user: {}", reason)
+            }
+            Kind::Reset(_, reason, Initiator::Library) => {
+                return write!(fmt, "stream error detected: {}", reason)
+            }
+            Kind::Reset(_, reason, Initiator::Remote) => {
+                return write!(fmt, "stream error received: {}", reason)
+            }
+            Kind::GoAway(ref debug_data, reason, Initiator::User) => {
+                write!(fmt, "connection error sent by user: {}", reason)?;
+                debug_data
+            }
+            Kind::GoAway(ref debug_data, reason, Initiator::Library) => {
+                write!(fmt, "connection error detected: {}", reason)?;
+                debug_data
+            }
+            Kind::GoAway(ref debug_data, reason, Initiator::Remote) => {
+                write!(fmt, "connection error received: {}", reason)?;
+                debug_data
+            }
+            Kind::Reason(reason) => return write!(fmt, "protocol error: {}", reason),
+            Kind::User(ref e) => return write!(fmt, "user error: {}", e),
+            Kind::Io(ref e) => return e.fmt(fmt),
+        };
+
+        if !debug_data.is_empty() {
+            write!(fmt, " ({:?})", debug_data)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl error::Error for Error {}
+
+#[cfg(test)]
+mod tests {
+    use super::Error;
+    use crate::Reason;
+
+    #[test]
+    fn error_from_reason() {
+        let err = Error::from(Reason::HTTP_1_1_REQUIRED);
+        assert_eq!(err.reason(), Some(Reason::HTTP_1_1_REQUIRED));
+    }
+}

{httpunk-0.2.2 → httpunk-0.4.0}/crates/vendor-h2/src/lib.rs

@@ -3,10 +3,13 @@
 //! with `scripts/vendor-h2.sh`.
 //!
 //! Only h2's **synchronous, sans-IO** modules are vendored: `frame` (HTTP/2
-//! frame parse/serialize) and `hpack` (HPACK header compression), plus the tiny
-//! `ext::Protocol` type they depend on. h2's async `codec`, `proto`, `client`
-//! and `server` are intentionally *not* vendored — that orchestration is
-//! rewritten in Python.
+//! frame parse/serialize) and `hpack` (HPACK header compression), the tiny
+//! `ext::Protocol` type they depend on, the stream state machine + flow control
+//! (`proto::streams::{state,flow_control}`), the error types (`proto::error`,
+//! `codec::error`, the public `error`). h2's async `codec`, the streams store
+//! and orchestration, `client` and `server` are intentionally *not* vendored —
+//! their state is re-expressed in httpunk's `src/h2/conn.rs`, their async half
+//! in Python.
 //!
 //! The `.rs` files under here are kept **byte-identical to upstream modulo a
 //! uniform `crate::` -> `crate::` rewrite** the vendor script applies, so
@@ -33,7 +36,12 @@ macro_rules! proto_err {
 }
 
 pub mod codec;
+pub mod error;
 pub mod ext;
 pub mod frame;
 pub mod hpack;
 pub mod proto;
+
+// h2 lib.rs re-exports its public `Error` at the crate root; `proto/streams/state.rs`
+// names it as `crate::Error` (`ensure_reason`).
+pub use crate::error::Error;