Struct SpatialOutbound 

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

Durable outbound queue for spatial insert and delete sync.

Held as Arc<SpatialOutbound<S>> by NodeDbLite and shared with the sync transport. The inner storage is accessed only for flush_staging() (from the auto-flush timer) and drain_inserts / drain_deletes / ack_* (from the async sync transport task).

Implementations

impl<S: StorageEngine> SpatialOutbound<S>

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

Open durable queues backed by Namespace::SpatialInsertPending and Namespace::SpatialDeletePending.

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

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

pub fn stage_insert( &self, collection: &str, field: &str, doc_id: &str, geometry: &Geometry, )

Synchronously stage a spatial insert entry.

Serialises the geometry to MessagePack; drops the entry with a warn! if serialisation fails or the staging buffer is at [STAGING_CAP].

pub fn stage_delete(&self, collection: &str, field: &str, doc_id: &str)

Synchronously stage a spatial delete entry.

Drops the entry with a warn! if the staging buffer is at [STAGING_CAP].

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

Spill staged entries to durable storage.

Called from the async flush() path (~every second). Drains the in-memory staging buffers and appends each entry to the durable queues. Returns LiteError::Backpressure on the first entry that cannot be enqueued (durable queue at cap); remaining staged entries are re-queued at the head of the staging buffer.

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

Drain up to limit pending inserts in FIFO order, skipping in-flight entries (sent but not yet acked by Origin).

Returns (durable_key, insert) pairs. On send success, call [mark_insert_in_flight]. The durable entry is deleted only on Origin ack via [ack_insert_in_flight].

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

Drain up to limit pending deletes in FIFO order, skipping in-flight entries.

Returns (durable_key, delete) pairs. On send success, call [mark_delete_in_flight]. The durable entry is deleted only on Origin ack via [ack_delete_in_flight].

pub async fn mark_insert_in_flight(&self, batch_id: u64, durable_key: Vec<u8>)

Record that an insert has been sent to Origin and is awaiting its ack.

pub async fn ack_insert_in_flight(&self, batch_id: u64) -> Option<Vec<u8>>

Remove the in-flight record for an insert and return its durable key.

pub async fn mark_delete_in_flight(&self, batch_id: u64, durable_key: Vec<u8>)

Record that a delete has been sent to Origin and is awaiting its ack.

pub async fn ack_delete_in_flight(&self, batch_id: u64) -> Option<Vec<u8>>

Remove the in-flight record for a delete and return its durable key.

pub async fn clear_in_flight(&self)

Clear all in-flight records on reconnect so entries are re-drained.

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

Delete the durable insert entries identified by keys (Origin ack path).

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

Delete the durable delete entries identified by keys (Origin ack path).

pub async fn update_insert_entry( &self, key: &[u8], insert: &PendingSpatialInsert, ) -> Result<(), LiteError>

Update the durable insert payload for key with the new seq.

pub async fn update_delete_entry( &self, key: &[u8], delete: &PendingSpatialDelete, ) -> Result<(), LiteError>

Update the durable delete payload for key with the new seq.

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

Number of pending insert entries in durable storage.

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

Number of pending delete entries in durable storage.