Struct SinkHandoff 

pub struct SinkHandoff<F: RecFamily, E, R> { /* private fields */ }

The chain’s terminal stage. Owns one accumulation buffer per shard, seals EncodedChunks at ChunkConfig::target_bytes, and hands them to the sink workers through the bounded ShardQueues — a try_send that never blocks the pipeline thread.

Trait Implementations

impl<'buf, F, E, R> Collector<<F as RecFamily>::Rec<'buf>> for SinkHandoff<F, E, R>

where F: RecFamily, E: RowEncoder<F> + Clone, R: ShardRouter,

fn push(&mut self, rec: Record<F::Rec<'buf>>) -> Flow

Push one record. Flow::Blocked propagates up to the boundary.

impl<F: Debug + RecFamily, E: Debug, R: Debug> Debug for SinkHandoff<F, E, R>

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

Formats the value using the given formatter.

impl<F: RecFamily, E, R> Drop for SinkHandoff<F, E, R>

Teardown safety: un-sent output (parked chunks after a drain deadline, partial shard buffers) holds its acknowledgements in fail-on-drop AckSets, so tearing the handoff down stalls those watermarks and the records replay after restart — at-least-once over completeness, always. This Drop only reconciles the in-flight byte budget for parked chunks (their bytes were added at seal time).

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<F: RecFamily, E, R> StageLifecycle for SinkHandoff<F, E, R>

where E: RowEncoder<F> + Clone,

fn on_batch_end(&mut self, elapsed: Duration)

Flush per-batch metric accumulators. elapsed is the chain-level batch duration: per-stage attribution inside one inlined loop is not measurable without per-record clocks, so every stage reports the chain figure, keeping the histograms comparable.

fn take_fatal(&mut self) -> Option<FatalError>

Take the first fatal error recorded by any stage.

fn relieve(&mut self) -> Flow

Let the terminal stage drain parked output. Flow::Blocked means it is still backed up and the chain must not accept new payloads.

fn flush_terminal(&mut self) -> Flow

Seal and hand off all terminal buffers, partial chunks included. Flow::Blocked means not everything could be sent; retry later.