Struct StallGuardSink 

struct StallGuardSink<S> {
    inner: S,
    timeout: Duration,
    timer: Delay,
    armed: bool,
}

A [Sink] adapter that fails the per-peer write pump once the inner sink stops making progress.

The write pump is rx.forward(frame_writer), where frame_writer writes to the peer’s quinn substream. When a remote stops reading, quinn’s poll_write parks (Pending) indefinitely under flow control, so the framed writer’s poll_ready/poll_flush never resolve and the pump task parks forever — never completing, so the cache-eviction closure attached to it never runs. The stalled peer’s channel then stays full and the shared egress drain burns one backpressure timeout per packet for that peer, head-of-line-blocking every other peer until the unbounded mixer queue exhausts memory (the 2026-08-27 jura-dev OOM).

This adapter arms an idle deadline the first time the inner sink returns Pending on a readiness/flush/close poll, and clears it the moment the inner sink returns Ready. If the deadline elapses while the inner sink is still Pending, the poll resolves to EgressWriteError::Stalled, driving the pump to completion so its cache entry is evicted and the next send reopens the stream. A merely-slow peer that keeps making progress within the timeout is never killed — the deadline resets on every Ready.

Fields

inner: S

timeout: Duration

timer: Delay

Persistent idle timer, reset in place when a stall starts (the same persistent-Delay pattern as the mixer’s MixerSink) so a busy-but-healthy peer that oscillates Pending/Ready does not churn a fresh Delay per flush cycle.

armed: bool

true while a readiness/flush/close poll is outstanding (inner last returned Pending). While set, the timer is polled without resetting, so a continuous stall is measured from its start rather than restarted on every poll.

Implementations

impl<S> StallGuardSink<S>

fn new(inner: S, timeout: Duration) -> Self

fn poll_guarded<T, E>( &mut self, cx: &mut Context<'_>, poll_inner: impl FnOnce(&mut S, &mut Context<'_>) -> Poll<Result<T, E>>, ) -> Poll<Result<T, EgressWriteError<E>>>

Poll the inner sink, arming/clearing the idle timer and mapping a stall to an error.

Trait Implementations

impl<S, T> Sink<T> for StallGuardSink<S>

where S: Sink<T> + Unpin,

type Error = EgressWriteError<<S as Sink<T>>::Error>

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.