Struct ReqBody

pub struct ReqBody { /* private fields */ }

ReqBody implements an asynchronous streaming mechanism for HTTP request bodies.

Design Goals

The main design goals of ReqBody are:

1. Provide efficient streaming of request bodies without buffering entire payload in memory
2. Bridge the gap between low-level payload streams and high-level http_body::Body interface
3. Support concurrent processing of request handling and body streaming
4. Allow proper cleanup of unread body data to maintain protocol correctness

Architecture

ReqBody uses a channel-based architecture:

• ReqBody: Consumer side that implements http_body::Body
• ReqBodySender: Producer side that reads from raw payload stream
• They communicate through a mpsc channel and oneshot channels

Example Flow

1. HttpConnection creates ReqBody/ReqBodySender pair
2. ReqBody is passed to request handler for body consumption
3. ReqBodySender runs concurrently to stream payload chunks
4. If handler doesn’t read entire body, remaining data is skipped

Implementations

impl ReqBody

pub fn body_channel<S>( payload_stream: &mut S, ) -> (ReqBody, ReqBodySender<'_, S>)

where S: Stream + Unpin,

Creates a body streaming channel pair for processing HTTP request bodies.

This is the main entry point for setting up request body streaming. It creates the necessary channels and returns both consumer and producer components.

The returned ReqBody implements http_body::Body and can be passed to request handlers, while ReqBodySender handles reading from the underlying stream.

Trait Implementations

impl Body for ReqBody

Implements standard HTTP body interface for request bodies.

This implementation bridges our custom streaming mechanism with the standard http_body::Body trait, allowing ReqBody to work seamlessly with HTTP handlers and middleware that expect the standard interface.

type Data = Bytes

Values yielded by the Body.

type Error = ParseError

The error type this Body might generate.

fn poll_frame( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>>

Attempt to pull out the next data buffer of this stream.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.