Struct sozu_lib::protocol::http::Http

pub struct Http<Front: SocketHandler, L: ListenerHandler> {

    pub frontend: Front,
    pub backend: Option<TcpStream>,
    pub status: SessionStatus,
    pub front_buf: Option<BufferQueue>,
    pub back_buf: Option<BufferQueue>,
    pub cluster_id: Option<String>,
    pub request_id: Ulid,
    pub backend_id: Option<String>,
    pub front_readiness: Readiness,
    pub back_readiness: Readiness,
    pub public_address: SocketAddr,
    pub session_address: Option<SocketAddr>,
    pub backend_data: Option<Rc<RefCell<Backend>>>,
    pub sticky_name: String,
    pub sticky_session: Option<StickySession>,
    pub protocol: Protocol,
    pub request_state: Option<RequestState>,
    pub response_state: Option<ResponseState>,
    pub req_header_end: Option<usize>,
    pub res_header_end: Option<usize>,
    pub added_req_header: Option<AddedRequestHeader>,
    pub added_res_header: String,
    pub keepalive_count: usize,
    pub backend_stop: Option<Instant>,
    pub closing: bool,
    pub front_timeout: TimeoutContainer,
    pub back_timeout: TimeoutContainer,
    pub frontend_timeout_duration: Duration,
    pub listener: Rc<RefCell<L>>,
    /* private fields */
}

Http will be contained in State wish itself is contained by Session

TODO: rename me (example: HttpState)

Fields

frontend: Front

backend: Option<TcpStream>

status: SessionStatus

front_buf: Option<BufferQueue>

back_buf: Option<BufferQueue>

cluster_id: Option<String>

request_id: Ulid

backend_id: Option<String>

front_readiness: Readiness

back_readiness: Readiness

public_address: SocketAddr

session_address: Option<SocketAddr>

backend_data: Option<Rc<RefCell<Backend>>>

sticky_name: String

sticky_session: Option<StickySession>

protocol: Protocol

request_state: Option<RequestState>

response_state: Option<ResponseState>

req_header_end: Option<usize>

res_header_end: Option<usize>

added_req_header: Option<AddedRequestHeader>

added_res_header: String

keepalive_count: usize

backend_stop: Option<Instant>

closing: bool

front_timeout: TimeoutContainer

back_timeout: TimeoutContainer

frontend_timeout_duration: Duration

listener: Rc<RefCell<L>>

Implementations

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

pub fn new(
    sock: Front,
    frontend_token: Token,
    request_id: Ulid,
    pool: Weak<RefCell<Pool>>,
    public_address: SocketAddr,
    session_address: Option<SocketAddr>,
    sticky_name: String,
    protocol: Protocol,
    answers: Rc<RefCell<HttpAnswers>>,
    front_timeout: TimeoutContainer,
    frontend_timeout_duration: Duration,
    backend_timeout_duration: Duration,
    listener: Rc<RefCell<L>>
) -> Http<Front, L>

pub fn reset(&mut self)

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

pub fn print_state(&self, prefix: &str) -> String

pub fn set_answer(
    &mut self,
    answer: DefaultAnswerStatus,
    buf: Option<Rc<Vec<u8>>>
)

pub fn added_response_header(&self) -> String

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 back_token(&self) -> Option<Token>

pub fn test_back_socket(&self) -> bool

pub fn is_valid_backend_socket(&self) -> bool

pub fn close(&mut self)

pub fn set_back_socket(
    &mut self,
    socket: TcpStream,
    backend: Option<Rc<RefCell<Backend>>>
)

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

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

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

pub fn clear_back_token(&mut self)

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

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

pub fn set_back_timeout(&mut self, dur: Duration)

pub fn timeout_status(&self) -> TimeoutStatus

pub fn remove_backend(&mut self) -> (Option<String>, Option<SocketAddr>)

pub fn front_hup(&mut self) -> SessionResult

pub fn back_hup(&mut self) -> SessionResult

pub fn shutting_down(&mut self) -> SessionResult

pub fn get_response_status(&self) -> Option<&StatusLine>

Retrieve the response status from the http response state

pub fn get_host(&self) -> Option<&str>

pub fn get_request_line(&self) -> Option<&RequestLine>

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

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

pub fn websocket_context(&self) -> String

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

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

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

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

Read content from the session

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

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

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

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

pub fn timeout(
    &mut self,
    token: Token,
    metrics: &mut SessionMetrics
) -> SessionResult

pub fn cancel_timeouts(&mut self)

pub fn cancel_backend_timeout(&mut self)