Struct SendRequest

pub struct SendRequest<T, B>
where
    T: OpenStreams<B>,
    B: Buf,
{ /* private fields */ }

Available on crate feature h3 only.

HTTP/3 request sender

send_request() initiates a new request and will resolve when it is ready to be sent to the server. Then a RequestStream will be returned to send a request body (for POST, PUT methods) and receive a response. After the whole body is sent, it is necessary to call RequestStream::finish() to let the server know the request transfer is complete. This includes the cases where no body is sent at all.

This struct is cloneable so multiple requests can be sent concurrently.

Existing instances are atomically counted internally, so whenever all of them have been dropped, the connection will be automatically closed with HTTP/3 connection error code HTTP_NO_ERROR = 0.

Examples

Sending a request with no body

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

// Send the request to the server
let mut req_stream: RequestStream<_, _> = send_request.send_request(request).await?;
// Don't forget to end up the request by finishing the send stream.
req_stream.finish().await?;
// Receive the response
let response: Response<()> = req_stream.recv_response().await?;
// Process the response...

Sending a request with a body and trailers

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

// Send the request to the server
let mut req_stream = send_request.send_request(request).await?;
// Send some data
req_stream.send_data("body".into()).await?;
// Prepare the trailers
let mut trailers = HeaderMap::new();
trailers.insert("trailer", "value".parse()?);
// Send them and finish the send stream
req_stream.send_trailers(trailers).await?;
// We don't need to finish the send stream, as `send_trailers()` did it for us

// Receive the response.
let response = req_stream.recv_response().await?;
// Process the response...

Implementations

impl<T, B> SendRequest<T, B>

where T: OpenStreams<B>, B: Buf,

pub async fn send_request( &mut self, req: Request<()>, ) -> Result<RequestStream<<T as OpenStreams<B>>::BidiStream, B>, StreamError>

Send an HTTP/3 request to the server

Trait Implementations

impl<T, B> Clone for SendRequest<T, B>

where T: OpenStreams<B> + Clone, B: Buf,

fn clone(&self) -> SendRequest<T, B>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, B> CloseStream for SendRequest<T, B>

where T: OpenStreams<B>, B: Buf,

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<T, B> ConnectionState for SendRequest<T, B>

where T: OpenStreams<B>, B: Buf,

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

impl<T, B> Drop for SendRequest<T, B>

where T: OpenStreams<B>, B: Buf,

fn drop(&mut self)

Executes the destructor for this type.