Struct HttpsProxy 

pub struct HttpsProxy { /* private fields */ }

Implementations

impl HttpsProxy

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

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

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

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

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

pub fn query_all_certificates( &mut self, ) -> Result<Option<ResponseContent>, ProxyError>

pub fn query_certificate_for_domain( &mut self, domain: String, ) -> Result<Option<ResponseContent>, 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( &mut 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: UpdateHttpsListenerConfig, ) -> Result<(), ProxyError>

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

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

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

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

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

pub fn add_certificate( &mut self, add_certificate: AddCertificate, ) -> Result<Option<ResponseContent>, ProxyError>

pub fn remove_certificate( &mut self, remove_certificate: RemoveCertificate, ) -> Result<Option<ResponseContent>, ProxyError>

pub fn replace_certificate( &mut self, replace_certificate: ReplaceCertificate, ) -> Result<Option<ResponseContent>, ProxyError>

Trait Implementations

impl L7Proxy for HttpsProxy

fn kind(&self) -> ListenerType

fn register_socket( &self, socket: &mut MioTcpStream, 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 HttpsProxy

fn accept( &mut self, token: ListenToken, ) -> Result<(MioTcpStream, StdSocketAddr), 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: MioTcpStream, peer: StdSocketAddr, 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).

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