Struct 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,
    pub addresses: Option<ProxyAddr>,
    /* 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

addresses: Option<ProxyAddr>

Parsed PROXY-v2 address pair captured from the inbound header. None until the parser succeeds, or for headers that carry Command::Local (no encapsulated addresses). The pipe phase uses ProxyAddr::source() here to attribute the real client instead of the upstream PROXY-emitter’s peer_addr.

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>