Struct UdpProxy 

pub struct UdpProxy { /* private fields */ }

The UDP proxy. Holds the listeners, one UdpManager per listener token, the shared BackendMap, the session slab and a cloned registry. Does NOT implement ProxyConfiguration / L7Proxy; the server drives it through the inherent notify plus the activate/give-back helpers.

Implementations

impl UdpProxy

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

pub fn health_poll(&mut self)

Drive the UDP health prober one event-loop step (server calls this once per iteration, mirroring HealthChecker::poll). Non-blocking.

The prober borrows self.registry directly. It must not clone it: Registry::try_clone is an fcntl(F_DUPFD_CLOEXEC) of the epoll descriptor and dropping the clone is a close, so a clone here cost two syscalls on every event-loop turn, with or without a UDP cluster, and silently skipped health probing whenever the worker was out of descriptors (EMFILE).

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

Record mio readiness for a UDP health-probe socket.

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

Whether token is a UDP health-probe socket this proxy owns.

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

pub fn remove_listener(&mut self, address: &ListenerKey) -> bool

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, udp_socket: Option<UdpSocket>, ) -> Result<Token, ProxyError>

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

Whether the real UdpListenerSession for token is already installed, i.e. build_session has run for it and no teardown has removed it since.

listener_sessions is populated by build_session alone and emptied by give_back_listener (deactivate), remove_listener and soft/hard stop, so membership tracks the installed session exactly. Server reads it to tell a first ActivateListener from a repeat: UdpListener::activate answers Ok(token) for an already-active listener without doing any work, and rebuilding on that answer would destroy the live session.

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 build_session( &mut self, token: Token, ) -> Option<Rc<RefCell<UdpListenerSession>>>

Build the UdpListenerSession that drives this listener’s datagrams. The server inserts the returned session into the slab at the listener token, replacing the ListenSession placeholder, so the generic readiness path reaches UdpListenerSession::update_readiness. Returns None if the listener token is unknown.

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

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

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

pub fn add_udp_front( &mut self, front: RequestUdpFrontend, ) -> Result<(), ProxyError>

pub fn remove_udp_front( &mut self, front: RequestUdpFrontend, ) -> Result<(), ProxyError>

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

Inherent dispatch entry point — the server calls this directly (UDP does not implement ProxyConfiguration). Handles UDP frontends, cluster config, listener removal, and stop. No accept / create_session.