Struct RequestStream

pub struct RequestStream<S, B> { /* private fields */ }

Available on crate feature h3 only.

Manage request bodies transfer, response and trailers.

Once a request has been sent via crate::client::SendRequest::send_request(), a response can be awaited by calling RequestStream::recv_response(). A body for this request can be sent with RequestStream::send_data(), then the request shall be completed by either sending trailers with RequestStream::finish().

After receiving the response’s headers, it’s body can be read by RequestStream::recv_data() until it returns None. Then the trailers will eventually be available via RequestStream::recv_trailers().

TODO: If data is polled before the response has been received, an error will be thrown.

TODO: If trailers are polled but the body hasn’t been fully received, an UNEXPECT_FRAME error will be thrown

Whenever the client wants to cancel this request, it can call RequestStream::stop_sending(), which will put an end to any transfer concerning it.

Examples

// Prepare the HTTP request to send to the server
let request = Request::get("https://www.example.com/").body(())?;

// Receive the response
let response = req_stream.recv_response().await?;
// Receive the body
while let Some(mut chunk) = req_stream.recv_data().await? {
    let mut out = tokio::io::stdout();
    out.write_all_buf(&mut chunk).await?;
    out.flush().await?;
}

Implementations

impl<S, B> RequestStream<S, B>

where S: RecvStream,

pub async fn recv_response(&mut self) -> Result<Response<()>, StreamError>

Receive the HTTP/3 response

This should be called before trying to receive any data with recv_data().

pub async fn recv_data(&mut self) -> Result<Option<impl Buf>, StreamError>

Receive some of the request body.

pub fn poll_recv_data( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Option<impl Buf>, StreamError>>

Receive request body

pub async fn recv_trailers(&mut self) -> Result<Option<HeaderMap>, StreamError>

Receive an optional set of trailers for the response.

pub fn poll_recv_trailers( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Option<HeaderMap>, StreamError>>

Poll receive an optional set of trailers for the response.

pub fn stop_sending(&mut self, error_code: Code)

Tell the peer to stop sending into the underlying QUIC stream

pub fn id(&self) -> StreamId

Returns the underlying stream id

impl<S, B> RequestStream<S, B>

where S: SendStream<B>, B: Buf,

pub async fn send_data(&mut self, buf: B) -> Result<(), StreamError>

Send some data on the request body.

pub fn stop_stream(&mut self, error_code: Code)

Stop a stream with an error code

The code can be Code::H3_NO_ERROR.

pub async fn send_trailers( &mut self, trailers: HeaderMap, ) -> Result<(), StreamError>

Send a set of trailers to end the request.

RequestStream::finish() must be called to finalize a request.

pub async fn finish(&mut self) -> Result<(), StreamError>

End the request without trailers.

RequestStream::finish() must be called to finalize a request.

impl<S, B> RequestStream<S, B>

where S: BidiStream<B>, B: Buf,

pub fn split( self, ) -> (RequestStream<<S as BidiStream<B>>::SendStream, B>, RequestStream<<S as BidiStream<B>>::RecvStream, B>)

Split this stream into two halves that can be driven independently.

Trait Implementations

impl<S, B> CloseStream for RequestStream<S, B>

fn handle_connection_error_on_stream( &mut self, internal_error: InternalConnectionError, ) -> StreamError

Handles a connection error on a stream

fn handle_quic_stream_error(&self, error: StreamErrorIncoming) -> StreamError

Handles a incoming stream error from the quic layer

fn check_peer_connection_closing(&self) -> Option<StreamError>

Checks if the peer connection is closing an if it is allowed to send a request / server push

impl<S, B> ConnectionState for RequestStream<S, B>

fn shared_state(&self) -> &SharedState

Get the shared state

fn get_conn_error(&self) -> Option<ErrorOrigin>

Get the connection error if the connection is in error state because of another task

fn set_conn_error(&self, error: ErrorOrigin) -> ErrorOrigin

tries to set the connection error

fn set_conn_error_and_wake<T>(&self, error: T) -> ErrorOrigin

where T: Into<ErrorOrigin>,

set the connection error and wake the connection

fn settings(&self) -> Cow<'_, Settings>

Get the settings

fn set_closing(&self)

Set the connection to closing

fn is_closing(&self) -> bool

Check if the connection is closing

fn set_settings(&self, settings: Settings)

Set the settings

fn waker(&self) -> &AtomicWaker

Returns the waker for the connection