Struct Http

pub struct Http<Front: SocketHandler, L: ListenerHandler + L7ListenerHandler> {
    pub backend: Option<Rc<RefCell<Backend>>>,
    pub backend_readiness: Readiness,
    pub backend_socket: Option<TcpStream>,
    pub backend_token: Option<Token>,
    pub container_backend_timeout: TimeoutContainer,
    pub container_frontend_timeout: TimeoutContainer,
    pub frontend_readiness: Readiness,
    pub frontend_socket: Front,
    pub request_stream: Kawa<Checkout>,
    pub response_stream: ResponseStream,
    pub context: HttpContext,
    /* private fields */
}

Http will be contained in State which itself is contained by Session

Fields

backend: Option<Rc<RefCell<Backend>>>

backend_readiness: Readiness

backend_socket: Option<TcpStream>

backend_token: Option<Token>

container_backend_timeout: TimeoutContainer

container_frontend_timeout: TimeoutContainer

frontend_readiness: Readiness

frontend_socket: Front

request_stream: Kawa<Checkout>

response_stream: ResponseStream

context: HttpContext

The HTTP context was separated from the State for borrowing reasons. Calling a kawa parser mutably borrows the State through request_stream or response_stream, so Http can’t be borrowed again to be used in callbacks. HttContext is an independant subsection of Http that can be mutably borrowed for parser callbacks.

Implementations

impl<Front: SocketHandler, L: ListenerHandler + L7ListenerHandler> Http<Front, L>

pub fn new( answers: Rc<RefCell<HttpAnswers>>, configured_backend_timeout: Duration, configured_connect_timeout: Duration, configured_frontend_timeout: Duration, container_frontend_timeout: TimeoutContainer, frontend_socket: Front, frontend_token: Token, listener: Rc<RefCell<L>>, pool: Weak<RefCell<Pool>>, protocol: Protocol, public_address: SocketAddr, request_id: Ulid, session_address: Option<SocketAddr>, sticky_name: String, ) -> Result<Http<Front, L>, AcceptError>

Instantiate a new HTTP SessionState with:

• frontend_interest: READABLE | HUP | ERROR
• frontend_event: EMPTY
• backend_interest: EMPTY
• backend_event: EMPTY

Remember to set the events from the previous State!

pub fn reset(&mut self)

Reset the connection in case of keep-alive to be ready for the next request

pub fn readable(&mut self, metrics: &mut SessionMetrics) -> StateResult

pub fn writable(&mut self, metrics: &mut SessionMetrics) -> StateResult

pub fn backend_writable( &mut self, metrics: &mut SessionMetrics, ) -> SessionResult

pub fn backend_readable( &mut self, metrics: &mut SessionMetrics, ) -> SessionResult

impl<Front: SocketHandler, L: ListenerHandler + L7ListenerHandler> Http<Front, L>

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

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

pub fn websocket_context(&self) -> WebSocketContext

Format the context of the websocket into a loggable String

pub fn log_request( &self, metrics: &SessionMetrics, error: bool, message: Option<&str>, )

pub fn log_request_success(&self, metrics: &SessionMetrics)

pub fn log_default_answer_success(&self, metrics: &SessionMetrics)

pub fn log_request_error(&self, metrics: &mut SessionMetrics, message: &str)

pub fn set_answer(&mut self, answer: DefaultAnswer)

pub fn test_backend_socket(&self) -> bool

pub fn is_valid_backend_socket(&self) -> bool

pub fn set_backend_socket( &mut self, socket: TcpStream, backend: Option<Rc<RefCell<Backend>>>, )

pub fn set_cluster_id(&mut self, cluster_id: String)

pub fn set_backend_id(&mut self, backend_id: String)

pub fn set_backend_token(&mut self, token: Token)

pub fn clear_backend_token(&mut self)

pub fn set_backend_timeout(&mut self, dur: Duration)

pub fn front_socket(&self) -> &TcpStream

pub fn extract_route( &self, ) -> Result<(&str, &str, &Method), RetrieveClusterError>

pub fn get_route(&self) -> String

pub fn backend_from_request( &mut self, cluster_id: &str, frontend_should_stick: bool, proxy: Rc<RefCell<dyn L7Proxy>>, metrics: &mut SessionMetrics, ) -> Result<TcpStream, BackendConnectionError>

pub fn backend_hup(&mut self, metrics: &mut SessionMetrics) -> StateResult

pub fn timeout_status(&self) -> TimeoutStatus

Trait Implementations

impl<Front: SocketHandler, L: ListenerHandler + L7ListenerHandler> SessionState for Http<Front, L>

fn ready( &mut self, session: Rc<RefCell<dyn ProxySession>>, proxy: Rc<RefCell<dyn L7Proxy>>, metrics: &mut SessionMetrics, ) -> SessionResult

if a session received an event or can still execute, the event loop will call this method. Its result indicates if it can still execute or if the session can be closed

fn update_readiness(&mut self, token: Token, events: Ready)

if the event loop got an event for a token associated with the session, it will call this method

fn close( &mut self, proxy: Rc<RefCell<dyn L7Proxy>>, metrics: &mut SessionMetrics, )

close the state

fn timeout(&mut self, token: Token, metrics: &mut SessionMetrics) -> StateResult

if a timeout associated with the session triggers, the event loop will call this method with the timeout’s token

fn cancel_timeouts(&mut self)

cancel frontend timeout (and backend timeout if present)

fn print_state(&self, context: &str)

display the session’s internal state (for debugging purpose),

fn shutting_down(&mut self) -> bool

tell the session it has to shut down if possible