Struct HttpSession 

pub struct HttpSession {
    pub write_timeout: Option<Duration>,
    /* private fields */
}

HTTP/2 server session

Fields

write_timeout: Option<Duration>

The write timeout which will be applied to writing response body. The timeout is reset on every write. This is not a timeout on the overall duration of the response.

Implementations

impl HttpSession

pub async fn from_h2_conn( conn: &mut Connection<Box<dyn IO>, Bytes>, digest: Arc<Digest>, ) -> Result<Option<HttpSession>, Box<Error>>

Create a new HttpSession from the HTTP/2 connection. This function returns a new HTTP/2 session when the provided HTTP/2 connection, conn, establishes a new HTTP/2 stream to this server.

A Digest from the IO stream is also stored in the resulting session, since the session doesn’t have access to the underlying stream (and the stream itself isn’t accessible from the h2::server::Connection).

Note: in order to handle all existing and new HTTP/2 sessions, the server must call this function in a loop until the client decides to close the connection.

None will be returned when the connection is closing so that the loop can exit.

pub fn req_header(&self) -> &RequestHeader

The request sent from the client

Different from its HTTP/1.X counterpart, this function never panics as the request is already read when established a new HTTP/2 stream.

pub fn req_header_mut(&mut self) -> &mut RequestHeader

A mutable reference to request sent from the client

Different from its HTTP/1.X counterpart, this function never panics as the request is already read when established a new HTTP/2 stream.

pub async fn read_body_bytes(&mut self) -> Result<Option<Bytes>, Box<Error>>

Read request body bytes. None when there is no more body to read.

pub async fn drain_request_body(&mut self) -> Result<(), Box<Error>>

Drain the request body. Ok(()) when there is no (more) body to read.

pub fn set_write_timeout(&mut self, timeout: Option<Duration>)

Sets the downstream write timeout. This will trigger if we’re unable to write to the stream after timeout.

pub fn set_total_drain_timeout(&mut self, timeout: Option<Duration>)

Sets the total drain timeout. This timeout will be used while draining the request body.

pub fn write_response_header( &mut self, header: Box<ResponseHeader>, end: bool, ) -> Result<(), Box<Error>>

Write the response header to the client.

the end flag

end marks the end of this session. If the end flag is set, no more header or body can be sent to the client.

pub async fn write_body( &mut self, data: Bytes, end: bool, ) -> Result<(), Box<Error>>

Write response body to the client. See Self::write_response_header for how to use end.

pub fn write_trailers(&mut self, trailers: HeaderMap) -> Result<(), Box<Error>>

Write response trailers to the client, this also closes the stream.

pub fn write_response_header_ref( &mut self, header: &ResponseHeader, end: bool, ) -> Result<(), Box<Error>>

Similar to Self::write_response_header, this function takes a reference instead

pub fn finish(&mut self) -> Result<(), Box<Error>>

Mark the session end. If no end flag is already set before this call, this call will signal the client. Otherwise this call does nothing.

Dropping this object without sending end will cause an error to the client, which will cause the client to treat this session as bad or incomplete.

pub async fn response_duplex_vec( &mut self, tasks: Vec<HttpTask>, ) -> Result<bool, Box<Error>>

pub fn request_summary(&self) -> String

Return a string $METHOD $PATH, Host: $HOST. Mostly for logging and debug purpose

pub fn response_written(&self) -> Option<&ResponseHeader>

Return the written response header. None if it is not written yet.

pub fn shutdown(&mut self)

Give up the stream abruptly.

This will send a INTERNAL_ERROR stream error to the client

pub fn pseudo_raw_h1_request_header(&self) -> Bytes

pub fn is_body_done(&self) -> bool

Whether there is no more body to read

pub fn is_body_empty(&self) -> bool

Whether there is any body to read. true means there no body in request.

pub fn retry_buffer_truncated(&self) -> bool

pub fn enable_retry_buffering(&mut self)

pub fn get_retry_buffer(&self) -> Option<Bytes>

pub fn idle(&mut self) -> Idle<'_>

async fn idle() -> Result<Reason, Error>; This async fn will be pending forever until the client closes the stream/connection This function is used for watching client status so that the server is able to cancel its internal tasks as the client waiting for the tasks goes away

pub async fn read_body_or_idle( &mut self, no_body_expected: bool, ) -> Result<Option<Bytes>, Box<Error>>

Similar to read_body_bytes() but will be pending after Ok(None) is returned, until the client closes the connection

pub fn body_bytes_sent(&self) -> usize

Return how many response body bytes (application, not wire) already sent downstream

pub fn body_bytes_read(&self) -> usize

Return how many request body bytes (application, not wire) already read from downstream

pub fn digest(&self) -> Option<&Digest>

Return the Digest of the connection.

pub fn digest_mut(&mut self) -> Option<&mut Digest>

Return a mutable Digest reference for the connection.

pub fn server_addr(&self) -> Option<&SocketAddr>

Return the server (local) address recorded in the connection digest.

pub fn client_addr(&self) -> Option<&SocketAddr>

Return the client (peer) address recorded in the connection digest.