Struct sozu_lib::protocol::proxy_protocol::send::SendProxyProtocol

pub struct SendProxyProtocol<Front: SocketHandler> {
    pub header: Option<Vec<u8>>,
    pub frontend: Front,
    pub request_id: Ulid,
    pub backend: Option<TcpStream>,
    pub frontend_token: Token,
    pub backend_token: Option<Token>,
    pub front_readiness: Readiness,
    pub back_readiness: Readiness,
    /* private fields */
}

Fields

header: Option<Vec<u8>>

frontend: Front

request_id: Ulid

backend: Option<TcpStream>

frontend_token: Token

backend_token: Option<Token>

front_readiness: Readiness

back_readiness: Readiness

Implementations

impl<Front: SocketHandler + Read> SendProxyProtocol<Front>

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

pub fn back_writable(
    &mut self,
    metrics: &mut SessionMetrics
) -> (ProtocolResult, 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 set_back_connected(&mut self, status: BackendConnectionStatus)

pub fn front_readiness(&mut self) -> &mut Readiness

pub fn back_readiness(&mut self) -> &mut Readiness

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