Struct PendingQueue 

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

Durable outbound pending-op queue backed by Namespace::ArrayDelta.

Implementations

impl<S: StorageEngine> PendingQueue<S>

pub const DEFAULT_CAP: usize = 100_000

Default maximum number of pending ops before backpressure kicks in.

pub fn new(storage: Arc<S>) -> Self

Create a queue with [DEFAULT_CAP].

pub fn with_cap(storage: Arc<S>, cap: usize) -> Self

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

pub async fn enqueue(&self, op: &ArrayOp) -> Result<(), LiteError>

Enqueue a single op.

Returns LiteError::Backpressure when len() >= cap to prevent unbounded queue growth during prolonged offline operation.

pub async fn scan_after( &self, after: Option<Hlc>, limit: usize, ) -> Result<Vec<PendingArrayOp>, LiteError>

Return up to limit queued ops with an HLC strictly greater than after, in FIFO order. None starts at the head of the queue.

pub async fn set_seq(&self, hlc: Hlc, seq: u64) -> Result<bool, LiteError>

Persist seq as the stream seq of the op queued under hlc.

Returns false when the op is no longer queued. The push loop calls this only for an op it has not sent yet, so no ack or reject can remove the op between the read and the write.

pub async fn retire(&self, hlcs: &[Hlc]) -> Result<u64, LiteError>

Remove every op named in hlcs in one atomic write.

Ops no longer queued are skipped. Returns the number removed.

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

Return up to limit ops in FIFO order (lowest HLC first).

Does not remove the returned ops — call [ack_through] after they are confirmed by Origin.

pub async fn ack_through(&self, ack_hlc: Hlc) -> Result<u64, LiteError>

Remove all ops whose header.hlc <= ack_hlc.

Called after Origin acknowledges a batch up to ack_hlc. Returns the number of ops removed.

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

Total count of pending ops in storage.

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

Returns true if the queue contains no pending ops.

pub async fn remove(&self, hlc: Hlc) -> Result<bool, LiteError>

Remove a single op identified by hlc from the queue.

Returns true if the op existed and was deleted, false if it was not present (idempotent — safe to call on already-acked ops).

Used by the inbound reject handler to roll back a single optimistic local write without touching the rest of the queue.