impl<B: Buf> SendResponse<B>

fn send_informational(&mut self, response: Response<()>) -> Result<(), Error>

Send an interim informational response (1xx status codes)

This method can be called multiple times before calling send_response() to send the final response. Only 1xx status codes are allowed.

Interim informational responses are used to provide early feedback to the client before the final response is ready. Common examples include:

• 100 Continue: Indicates the client should continue with the request
• 103 Early Hints: Provides early hints about resources to preload

Arguments

• response - HTTP response with 1xx status code and headers

Returns

• Ok(()) - Interim Informational response sent successfully
• Err(Error) - Failed to send (invalid status code, connection error, etc.)

Examples

use h2::server;
use http::{Response, StatusCode};

# async fn example(mut send_response: h2::server::SendResponse<bytes::Bytes>) -> Result<(), h2::Error> {
// Send 100 Continue before processing request body
let continue_response = Response::builder()
    .status(StatusCode::CONTINUE)
    .body(())
    .unwrap();
send_response.send_informational(continue_response)?;

// Later send the final response
let final_response = Response::builder()
    .status(StatusCode::OK)
    .body(())
    .unwrap();
let _stream = send_response.send_response(final_response, false)?;
# Ok(())
# }

Errors

This method will return an error if:

• The response status code is not in the 1xx range
• The final response has already been sent
• There is a connection-level error

fn send_response(&mut self, response: Response<()>, end_of_stream: bool) -> Result<SendStream<B>, Error>

Send a response to a client request.

On success, a SendStream instance is returned. This instance can be used to stream the response body and send trailers.

If a body or trailers will be sent on the returned SendStream instance, then end_of_stream must be set to false when calling this function.

The SendResponse instance is already associated with a received request. This function may only be called once per instance and only if send_reset has not been previously called.

fn push_request(&mut self, request: Request<()>) -> Result<SendPushedResponse<B>, Error>

Push a request and response to the client

On success, a SendResponse instance is returned.

fn send_reset(&mut self, reason: Reason)

Send a stream reset to the peer.

This essentially cancels the stream, including any inbound or outbound data streams.

If this function is called before send_response, a call to send_response will result in an error.

If this function is called while a SendStream instance is active, any further use of the instance will result in an error.

This function should only be called once.

fn poll_reset(&mut self, cx: &mut Context<'_>) -> Poll<Result<Reason, Error>>

Polls to be notified when the client resets this stream.

If stream is still open, this returns Poll::Pending, and registers the task to be notified if a RST_STREAM is received.

If a RST_STREAM frame is received for this stream, calling this method will yield the Reason for the reset.

Error

Calling this method after having called send_response will return a user error.

fn stream_id(&self) -> StreamId

Returns the stream ID of the response stream.

Panics

If the lock on the stream store has been poisoned.