pub struct RequestStream<S, B> { /* private fields */ }Expand description
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§
Source§impl<S, B> RequestStream<S, B>where S: RecvStream,
impl<S, B> RequestStream<S, B>where S: RecvStream,
Sourcepub async fn recv_response(&mut self) -> Result<Response<()>, StreamError>
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().
Sourcepub async fn recv_data(&mut self) -> Result<Option<impl Buf>, StreamError>
pub async fn recv_data(&mut self) -> Result<Option<impl Buf>, StreamError>
Receive some of the request body.
Sourcepub fn poll_recv_data( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Option<impl Buf>, StreamError>>
pub fn poll_recv_data( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Option<impl Buf>, StreamError>>
Receive request body
Sourcepub async fn recv_trailers(&mut self) -> Result<Option<HeaderMap>, StreamError>
pub async fn recv_trailers(&mut self) -> Result<Option<HeaderMap>, StreamError>
Receive an optional set of trailers for the response.
Sourcepub fn poll_recv_trailers( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Option<HeaderMap>, StreamError>>
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.
Sourcepub fn stop_sending(&mut self, error_code: Code)
pub fn stop_sending(&mut self, error_code: Code)
Tell the peer to stop sending into the underlying QUIC stream
Source§impl<S, B> RequestStream<S, B>where S: SendStream<B>, B: Buf,
impl<S, B> RequestStream<S, B>where S: SendStream<B>, B: Buf,
Sourcepub async fn send_data(&mut self, buf: B) -> Result<(), StreamError>
pub async fn send_data(&mut self, buf: B) -> Result<(), StreamError>
Send some data on the request body.
Sourcepub fn stop_stream(&mut self, error_code: Code)
pub fn stop_stream(&mut self, error_code: Code)
Stop a stream with an error code
The code can be Code::H3_NO_ERROR.
Sourcepub async fn send_trailers( &mut self, trailers: HeaderMap, ) -> Result<(), StreamError>
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.
Sourcepub async fn finish(&mut self) -> Result<(), StreamError>
pub async fn finish(&mut self) -> Result<(), StreamError>
End the request without trailers.
RequestStream::finish() must be called to finalize a request.
Source§impl<S, B> RequestStream<S, B>where S: BidiStream<B>, B: Buf,
impl<S, B> RequestStream<S, B>where S: BidiStream<B>, B: Buf,
Sourcepub fn split( self, ) -> (RequestStream<S::SendStream, B>, RequestStream<S::RecvStream, B>)
pub fn split( self, ) -> (RequestStream<S::SendStream, B>, RequestStream<S::RecvStream, B>)
Split this stream into two halves that can be driven independently.