Struct DurableOutboundQueue 

pub struct DurableOutboundQueue<S: StorageEngine> { /* private fields */ }

Durable FIFO outbound queue backed by a StorageEngine namespace.

Implementations

impl<S: StorageEngine> DurableOutboundQueue<S>

pub const DEFAULT_CAP: usize = 100_000

Default maximum number of pending batches before backpressure kicks in.

pub async fn open( storage: Arc<S>, namespace: Namespace, ) -> Result<Self, LiteError>

Open a queue over the given namespace, deriving the next-ID from the highest key currently in storage (zero on an empty namespace).

pub async fn open_with_cap( storage: Arc<S>, namespace: Namespace, cap: usize, ) -> Result<Self, LiteError>

Open with a custom cap (useful for tests with small limits).

pub async fn enqueue(&self, payload: &[u8]) -> Result<(), LiteError>

Enqueue a pre-encoded payload.

Returns LiteError::Backpressure when len() >= cap.

pub async fn ensure_room(&self, entries: usize) -> Result<(), LiteError>

Check that entries more entries fit under the cap.

Returns LiteError::Backpressure when len() + entries > cap. A writer that enqueues after its local write calls this first, so a full queue refuses the write before it changes local state.

pub async fn drain_batch( &self, limit: usize, ) -> Result<Vec<(Vec<u8>, Vec<u8>)>, LiteError>

Return up to limit entries in FIFO order (lowest key first).

Does not remove the returned entries. Call [ack_keys] after Origin confirms delivery to remove them.

pub async fn ack_keys(&self, keys: &[Vec<u8>]) -> Result<(), LiteError>

Delete the entries identified by keys from storage.

Called after Origin acknowledges the corresponding batches. Deleting only confirmed keys means un-acked entries survive a crash and will be re-sent on reconnect (at-least-once delivery).

pub async fn update_entry( &self, key: &[u8], payload: &[u8], ) -> Result<(), LiteError>

Update the payload stored under an existing key in-place.

Used by the push paths to persist an assigned stream seq back into a durable entry before sending, so reconnects reuse the same seq.

pub async fn len(&self) -> Result<u64, LiteError>

Total number of pending entries in storage.

pub async fn is_empty(&self) -> Result<bool, LiteError>

Returns true if the queue contains no pending entries.