Struct MultiplexedStream 

pub struct MultiplexedStream { /* private fields */ }

Distributes ingestion round-robin across a fixed set of ZerobusStreams.

See the module-level documentation for routing, MessageId, and poisoning semantics.

Implementations

impl MultiplexedStream

pub fn new(streams: Vec<ZerobusStream>) -> Self

Creates a multiplexed stream over the given sub-streams.

Panics

Panics if streams is empty or holds more than 64 sub-streams.

pub async fn ingest_record( &self, payload: impl Into<EncodedRecord>, ) -> ZerobusResult<MessageId>

Ingests a single record into the next sub-stream (round-robin).

Returns once the record is queued; use wait_for_message_id with the returned id to await server acknowledgment. If the chosen sub-stream is at capacity, this waits for it to drain rather than rerouting.

pub async fn ingest_records<I, T>( &self, payload: I, ) -> ZerobusResult<Option<MessageId>>

where I: IntoIterator<Item = T>, T: Into<EncodedRecord>,

Ingests a batch of records into a single sub-stream (round-robin).

The whole batch lands on one sub-stream so a single returned id covers it. Returns None for an empty batch.

pub async fn flush(&self) -> ZerobusResult<()>

Waits until every record already queued on every sub-stream is acknowledged by the server.

If a sub-stream flush fails because that sub-stream reached a terminal state, the mux is poisoned. The first flush error is returned; additional ones are logged.

pub async fn wait_for_message_id( &self, message_id: MessageId, ) -> ZerobusResult<()>

Waits for server acknowledgment of the record or batch behind a MessageId returned from ingest_record or ingest_records.

pub async fn close(&mut self) -> ZerobusResult<()>

Flushes and closes all sub-streams, releasing their resources.

The first flush/close error is returned (additional ones are logged); on error, use get_unacked_records to recover records that were never acknowledged.

pub fn is_closed(&self) -> bool

Returns whether the mux is closed — either via close or because a sub-stream failure poisoned it.

pub async fn get_unacked_records( &mut self, ) -> ZerobusResult<impl Iterator<Item = EncodedRecord>>

Returns records that were ingested but not acknowledged.

Closes the mux first to ensure all sub-streams have reached their terminal state, so results are always complete. Any error from close is swallowed — if records can still be recovered, they will be returned.

pub async fn get_unacked_batches(&mut self) -> ZerobusResult<Vec<EncodedBatch>>

Returns batches that were ingested but not acknowledged.

Closes the mux first to ensure all sub-streams have reached their terminal state, so results are always complete. Any error from close is swallowed — if records can still be recovered, they will be returned.

Trait Implementations

impl Drop for MultiplexedStream

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.