Enum Output 

pub enum Output {
    SelectBackend {
        flow: FlowId,
        cluster: ClusterId,
        key: u64,
    },
    OpenUpstream {
        flow: FlowId,
        backend: SocketAddr,
    },
    SendToBackend(Transmit),
    SendToClient(Transmit),
    ArmTimer(Instant),
    Metric(MetricEvent),
    CloseFlow(FlowId),
    Drop(DropReason),
}

Outputs the manager emits; the shell drains them via poll_output until None. The shell owns the actual syscalls and timer wheel.

Variants

SelectBackend

A new flow needs a backend. The shell consults the BackendMap with (cluster, key) and replies with ManagerInput::BackendResolved.

Fields

flow: FlowId

Flow awaiting a backend.

cluster: ClusterId

Cluster the flow’s listener routes to.

key: u64

Affinity hash for HRW / Maglev selection (key % M, max hash).

OpenUpstream

The shell should connect() a fresh upstream socket for this flow and register upstream_token -> flow for NAT return demux.

Fields

flow: FlowId

Flow that owns the upstream socket.

backend: SocketAddr

Backend address to connect to.

SendToBackend(Transmit)

Write an owned datagram to the backend (PPv2-prefixed when applicable).

SendToClient(Transmit)

Write an owned datagram back to the real client (symmetric NAT return).

ArmTimer(Instant)

Re-arm the single manager-wide timer at this absolute deadline. The shell owns the wheel; the core only ever requests one deadline.

Metric(MetricEvent)

A metric event for the shell to translate into udp.* counters/gauges.

CloseFlow(FlowId)

Tear down a flow (idle / responses-reached / requests-reached / drain). The shell closes the upstream socket, frees the slab slot, and decrements udp.active_flows.

Drop(DropReason)

A datagram was dropped before allocating any flow/buffer/socket (“silence is a virtue”). Carries the reason for metrics/logs.

Trait Implementations

impl Clone for Output

fn clone(&self) -> Output

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Output

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Output

impl PartialEq for Output

fn eq(&self, other: &Output) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Output