Struct solicit::http::server::ServerConnection

pub struct ServerConnection<F, State = DefaultSessionState<ServerMarker, DefaultStream>> where
    State: SessionState,
    F: StreamFactory<Stream = State::Stream>,  {
    pub state: State,
    // some fields omitted
}

The struct provides a more convenient API for server-related functionality of an HTTP/2 connection, such as sending a response back to the client.

Fields

state: State

The state of the session associated to this client connection. Maintains the status of the connection streams.

Implementations

impl<F, State> ServerConnection<F, State> where
    State: SessionState,
    F: StreamFactory<Stream = State::Stream>, 

pub fn with_connection(
    conn: HttpConnection,
    state: State,
    factory: F
) -> ServerConnection<F, State>

Creates a new ServerConnection that will use the given HttpConnection for its underlying HTTP/2 communication. The state and factory represent, respectively, the initial state of the connection and an instance of the StreamFactory type (allowing the client to handle newly created streams).

pub fn scheme(&self) -> HttpScheme

Returns the scheme of the underlying HttpConnection.

pub fn send_settings<S: SendFrame>(&mut self, sender: &mut S) -> HttpResult<()>

Send the current settings associated to the ServerConnection to the client.

pub fn expect_settings<Recv: ReceiveFrame, Sender: SendFrame>(
    &mut self,
    rx: &mut Recv,
    tx: &mut Sender
) -> HttpResult<()>

Handles the next frame on the given ReceiveFrame instance and expects it to be a (non-ACK) SETTINGS frame. Returns an error if not.

pub fn handle_next_frame<Recv: ReceiveFrame, Sender: SendFrame>(
    &mut self,
    rx: &mut Recv,
    tx: &mut Sender
) -> HttpResult<()>

Fully handles the next frame provided by the given ReceiveFrame instance. Handling the frame can cause the session state of the ServerConnection to update.

pub fn start_response<'n, 'v, S: SendFrame>(
    &mut self,
    headers: Vec<Header<'n, 'v>>,
    stream_id: StreamId,
    end_stream: EndStream,
    sender: &mut S
) -> HttpResult<()>

Starts a response on the stream with the given ID by sending the given headers.

The body of the response is assumed to be provided by the Stream instance stored within the connection's state. (The body does not have to be ready when this method is called, as long as the Stream instance knows how to provide it to the connection later on.)

pub fn send_next_data<S: SendFrame>(
    &mut self,
    sender: &mut S
) -> HttpResult<SendStatus>

Queues a new DATA frame onto the underlying SendFrame.

Currently, no prioritization of streams is taken into account and which stream's data is queued cannot be relied on.