Struct sozu_lib::protocol::proxy_protocol::relay::RelayProxyProtocol

pub struct RelayProxyProtocol<Front: SocketHandler> {
    pub backend_readiness: Readiness,
    pub backend_token: Option<Token>,
    pub backend: Option<TcpStream>,
    pub frontend_buffer: Checkout,
    pub frontend_readiness: Readiness,
    pub frontend_token: Token,
    pub frontend: Front,
    pub header_size: Option<usize>,
    pub request_id: Ulid,
    /* private fields */
}

Fields

backend_readiness: Readiness

backend_token: Option<Token>

backend: Option<TcpStream>

frontend_buffer: Checkout

frontend_readiness: Readiness

frontend_token: Token

frontend: Front

header_size: Option<usize>

request_id: Ulid

Implementations

impl<Front: SocketHandler> RelayProxyProtocol<Front>

pub fn new( frontend: Front, frontend_token: Token, request_id: Ulid, backend: Option<TcpStream>, front_buf: Checkout ) -> Self

Instantiate a new RelayProxyProtocol SessionState with:

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

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

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

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) -> Option<Token>

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

pub fn into_pipe( self, back_buf: Checkout, listener: Rc<RefCell<TcpListener>> ) -> Pipe<Front, TcpListener>