Enum Connection 

pub enum Connection<'b, T, const N: usize = DEFAULT_MAX_HEADERS_COUNT> {
    Transition(TransitionState),
    Unbound(T),
    Request(RequestState<'b, T, N>),
    Response(ResponseState<T>),
}

A connection state machine for handling HTTP server requests-response cycles.

Variants

Transition(TransitionState)

Unbound(T)

Request(RequestState<'b, T, N>)

Response(ResponseState<T>)

Implementations

impl<'b, T, const N: usize> Connection<'b, T, N>

where T: Read + Write,

pub async fn new( buf: &'b mut [u8], io: T, ) -> Result<Connection<'b, T, N>, Error<T::Error>>

Create a new connection state machine for an incoming request

Note that the connection does not have any built-in read/write timeouts:

• To add a timeout on each IO operation, wrap the io type with the edge_nal::WithTimeout wrapper.
• To add a global request-response timeout, wrap your complete request-response processing logic with the edge_nal::with_timeout function.

Parameters:

• buf: A buffer to store the request headers
• io: A socket stream

pub fn is_request_initiated(&self) -> bool

Return true of the connection is in request state (i.e. the initial state upon calling new)

pub fn split(&mut self) -> (&RequestHeaders<'b, N>, &mut Body<'b, T>)

Split the connection into request headers and body

pub fn headers(&self) -> Result<&RequestHeaders<'b, N>, Error<T::Error>>

Return a reference to the request headers

pub fn is_ws_upgrade_request(&self) -> Result<bool, Error<T::Error>>

Return true if the request is a WebSocket upgrade request

pub async fn initiate_response( &mut self, status: u16, message: Option<&str>, headers: &[(&str, &str)], ) -> Result<(), Error<T::Error>>

Switch the connection into a response state

Parameters:

• status: The HTTP status code
• message: An optional HTTP status message
• headers: An array of HTTP response headers. Note that if no Content-Length or Transfer-Encoding headers are provided, the body will be send with chunked encoding (for HTTP1.1 only and if the connection is not Close)

pub async fn initiate_ws_upgrade_response( &mut self, buf: &mut [u8; 33], ) -> Result<(), Error<T::Error>>

A convenience method to initiate a WebSocket upgrade response

pub fn is_response_initiated(&self) -> bool

Return true if the connection is in response state

pub async fn complete(&mut self) -> Result<(), Error<T::Error>>

Completes the response and switches the connection back to the unbound state If the connection is still in a request state, and empty 200 OK response is sent

pub async fn complete_err(&mut self, err: &str) -> Result<(), Error<T::Error>>

Completes the response with an error message and switches the connection back to the unbound state

If the connection is still in a request state, an empty 500 Internal Error response is sent

pub fn needs_close(&self) -> bool

Return true if the connection needs to be closed

This is determined by the connection type (i.e. Connection: Close header)

pub fn unbind(&mut self) -> Result<&mut T, Error<T::Error>>

Switch the connection to unbound state, returning a mutable reference to the underlying socket stream

NOTE: Use with care, and only if the connection is completed in the meantime

Trait Implementations

impl<T, const N: usize> ErrorType for Connection<'_, T, N>

where T: ErrorType,

type Error = Error<<T as ErrorType>::Error>

Error type of all the IO operations on this type.

impl<T, const N: usize> Read for Connection<'_, T, N>

where T: Read + Write,

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<T, const N: usize> Write for Connection<'_, T, N>

where T: Read + Write,

async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.