Struct Pipe 

pub struct Pipe<Front: SocketHandler, L: ListenerHandler> {
    pub backend_readiness: Readiness,
    pub backend: Option<Rc<RefCell<Backend>>>,
    pub container_backend_timeout: Option<TimeoutContainer>,
    pub container_frontend_timeout: Option<TimeoutContainer>,
    pub frontend_readiness: Readiness,
    /* private fields */
}

Fields

backend_readiness: Readiness

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

container_backend_timeout: Option<TimeoutContainer>

container_frontend_timeout: Option<TimeoutContainer>

frontend_readiness: Readiness

Implementations

impl<Front: SocketHandler, L: ListenerHandler> Pipe<Front, L>

pub fn new( backend_buffer: Checkout, backend_id: Option<String>, backend_socket: Option<TcpStream>, backend: Option<Rc<RefCell<Backend>>>, container_backend_timeout: Option<TimeoutContainer>, container_frontend_timeout: Option<TimeoutContainer>, cluster_id: Option<String>, frontend_buffer: Checkout, frontend_token: Token, frontend: Front, listener: Rc<RefCell<L>>, protocol: Protocol, session_id: Ulid, request_id: Ulid, session_address: Option<SocketAddr>, websocket_context: WebSocketContext, ) -> Pipe<Front, L>

Instantiate a new Pipe SessionState with:

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

Remember to set the events from the previous State!

pub fn set_tls_metadata( &mut self, version: Option<&'static str>, cipher: Option<&'static str>, sni: Option<String>, alpn: Option<&'static str>, )

Stamp connection-scoped TLS metadata captured at handshake time onto the pipe for access-log emission. Called from the HTTPS→WSS upgrade path in https.rs::upgrade_mux after the Pipe has been built from the prior mux HttpContext. Leaves plaintext paths (plain TCP, plain WS, proxy-protocol) untouched so their access logs continue to emit None for all TLS fields.

pub fn front_socket(&self) -> &TcpStream

pub fn front_socket_mut(&mut self) -> &mut TcpStream

pub fn back_socket(&self) -> Option<&TcpStream>

pub fn back_socket_mut(&mut self) -> Option<&mut TcpStream>

pub fn set_back_socket(&mut self, socket: TcpStream)

pub fn back_token(&self) -> Vec<Token>

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

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

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

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

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

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

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

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

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

Access-log wrapper for benign idle-timeout tear-downs.

Unlike log_request_error, this path logs at debug! and skips the state dump — an idle pipe hitting its front/back_timeout is expected behaviour (e.g. a WebSocket with no keepalive) and should not pollute the error stream.

pub fn check_connections(&self) -> bool

Wether the session should be kept open, depending on endpoints status and buffer usage (both in memory and in kernel)

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

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

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

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

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

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

pub fn log_context(&self) -> LogContext<'_>

Trait Implementations

impl<Front: SocketHandler, L: ListenerHandler> SessionState for Pipe<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 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 close( &mut self, _proxy: Rc<RefCell<dyn L7Proxy>>, _metrics: &mut SessionMetrics, )

close the state

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