Struct HttpProxy 

pub struct HttpProxy { /* private fields */ }

Implementations

impl HttpProxy

pub fn new( registry: Registry, sessions: Rc<RefCell<SessionManager>>, pool: Rc<RefCell<Pool>>, backends: Rc<RefCell<BackendMap>>, ) -> HttpProxy

pub fn add_listener( &mut self, config: HttpListenerConfig, token: Token, ) -> Result<Token, ProxyError>

pub fn get_listener(&self, token: &Token) -> Option<Rc<RefCell<HttpListener>>>

pub fn remove_listener( &mut self, remove: RemoveListener, ) -> Result<(), ProxyError>

pub fn inherited_socket_fate(&self, addr: &ListenerKey) -> InheritedSocketFate

What this proxy would do with a socket handed to activate_listener for addr. See crate::InheritedSocketFate.

The event loop is single-threaded, so nothing can change the listener’s active flag between this answer and the activate_listener call that acts on it.

pub fn activate_listener( &self, addr: &ListenerKey, tcp_listener: Option<MioTcpListener>, ) -> Result<Token, ProxyError>

pub fn listener_token(&self, address: &ListenerKey) -> Option<Token>

The slab token reserved for the listener at address, if this proxy holds one.

A listener owns exactly one slab slot for its whole AddListener -> RemoveListener lifetime, and no remove_listener implementation touches the session slab. Server therefore reads the token here BEFORE dropping the listener, so that reserved slot is released exactly once, at the end of the lifetime.

pub fn give_back_listeners(&mut self) -> Vec<(ListenerKey, MioTcpListener)>

pub fn give_back_listener( &mut self, address: &ListenerKey, ) -> Result<(Token, MioTcpListener), ProxyError>

pub fn update_listener( &mut self, patch: UpdateHttpListenerConfig, ) -> Result<(), ProxyError>

Apply a partial-update patch to the identified HTTP listener.

pub fn add_cluster(&mut self, cluster: Cluster) -> Result<(), ProxyError>

pub fn remove_cluster(&mut self, cluster_id: &str) -> Result<(), ProxyError>

pub fn add_http_frontend( &mut self, front: RequestHttpFrontend, ) -> Result<(), ProxyError>

pub fn remove_http_frontend( &mut self, front: RequestHttpFrontend, ) -> Result<(), ProxyError>

pub fn soft_stop(&mut self) -> Result<(), ProxyError>

pub fn hard_stop(&mut self) -> Result<(), ProxyError>

Trait Implementations

impl L7Proxy for HttpProxy

fn kind(&self) -> ListenerType

fn register_socket( &self, source: &mut TcpStream, token: Token, interest: Interest, ) -> Result<(), Error>

fn add_session(&self, session: Rc<RefCell<dyn ProxySession>>) -> Token

fn remove_session(&self, token: Token) -> bool

Remove the session from the session manager slab. Returns true if the session was actually there before deletion

fn clusters(&self) -> &HashMap<ClusterId, Cluster>

fn sessions(&self) -> Rc<RefCell<SessionManager>>

Access the worker’s crate::server::SessionManager for per-(cluster, source-IP) connection-limit accounting. The mux uses this to track / untrack stream-granular (cluster_id, ip) entries and consult the cluster_ip_at_limit gate before each backend connect.

impl ProxyConfiguration for HttpProxy

fn notify(&mut self, request: WorkerRequest) -> WorkerResponse

fn accept( &mut self, token: ListenToken, ) -> Result<(TcpStream, SocketAddr), AcceptError>

Accept one connection on the listener behind token, returning the socket together with the peer address accept(2) reported for it.

fn create_session( &mut self, frontend_sock: TcpStream, peer: SocketAddr, listener_token: ListenToken, wait_time: Duration, proxy: Rc<RefCell<Self>>, ) -> Result<(), AcceptError>

Build the session for a socket Self::accept returned. peer is the address accept(2) returned with it, so the session never has to ask the kernel again with getpeername(2).