Struct H2cPrefaceSniff 

pub struct H2cPrefaceSniff {
    pub container_frontend_timeout: TimeoutContainer,
    pub frontend: TcpStream,
    pub frontend_readiness: Readiness,
    pub frontend_token: Token,
    pub session_address: Option<SocketAddr>,
    pub public_address: SocketAddr,
    pub request_id: Ulid,
    pub verdict: Option<PrefaceVerdict>,
}

The session stage of an h2c_prior_knowledge HTTP listener that decides between HTTP/2 and HTTP/1.x before the mux is built. See the module documentation.

Fields

container_frontend_timeout: TimeoutContainer

frontend: TcpStream

frontend_readiness: Readiness

frontend_token: Token

session_address: Option<SocketAddr>

Address the session is attributed to: the accept(2) peer, or the PROXY-advertised source when the listener also expects PROXY.

public_address: SocketAddr

Address the session was received on, as the mux context records it.

request_id: Ulid

Request id of the first HTTP/1.x request, minted at accept.

verdict: Option<PrefaceVerdict>

Some(H2 | Http1) once decided; never Some(NeedMore).

Implementations

impl H2cPrefaceSniff

pub fn new( container_frontend_timeout: TimeoutContainer, frontend: TcpStream, frontend_token: Token, request_id: Ulid, session_address: Option<SocketAddr>, public_address: SocketAddr, event: Ready, ) -> Self

Instantiate the sniff stage with interest READABLE | HUP | ERROR, carrying event (the readiness already observed on the socket, EMPTY for a freshly accepted one).

pub fn front_socket(&self) -> &TcpStream

Trait Implementations

impl SessionState for H2cPrefaceSniff

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 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 close( &mut self, _proxy: Rc<RefCell<dyn L7Proxy>>, _metrics: &mut SessionMetrics, )

close the state

fn shutting_down(&mut self) -> bool

tell the session it has to shut down if possible

fn targets(&self, _target: &SessionTarget) -> bool

Whether this state holds a backend connection target names; see ProxySession::targets (lib/src/lib.rs).