Struct SwapDb 

pub struct SwapDb<D> { /* private fields */ }

A dataset that stays readable across an atomic re-bootstrap swap.

Generic over the installed dataset D so the replication engine, the integration tests, and any future caller share one swap discipline rather than re-implementing the lock dance. D is held behind an Arc, so a “swap” is a single pointer write and old readers keep their snapshot alive.

Implementations

impl<D> SwapDb<D>

pub fn new(data: D) -> Self

Install data as the initial dataset. The node starts not re-bootstrapping — it is serving normally.

pub fn is_rebootstrapping(&self) -> bool

true while a re-bootstrap is in flight. This is exactly the value the topology advertiser surfaces as ReplicaInfo::rebootstrapping.

pub fn snapshot(&self) -> Arc<D>

The currently-installed dataset, cloned as an Arc. Always available — this is the stay-readable path. During a rebuild it returns the old data; after Self::complete_rebootstrap it returns the new data.

pub fn read_noncausal(&self) -> Arc<D>

Serve a non-causal read: always the currently-installed dataset, rebuild in flight or not. Never blocks on the rebuild, never fails. Identical to Self::snapshot; named for intent at the call site.

pub fn read_causal(&self) -> Result<Arc<D>, RebootstrapInProgress>

Serve a causal (bookmark) read.

Returns the installed dataset only when the node is not re-bootstrapping. While a rebuild is in flight it returns RebootstrapInProgress so the caller bounces the read to a caught-up peer — never serving a bookmark from data the node is about to discard.

pub fn begin_rebootstrap(&self)

Enter the re-bootstrap state. Idempotent: calling it while already rebuilding is a no-op. The installed dataset is left untouched, so non-causal reads keep flowing from the old data while the fresh snapshot loads in the background.

pub fn complete_rebootstrap(&self, fresh: D) -> Arc<D>

Atomically install fresh as the new dataset and leave the re-bootstrap state.

The pointer swap happens under the write lock; the rebootstrapping flag is cleared only after the new dataset is published, so there is no instant at which the node both claims to be caught up and still serves the old data to a causal reader. Returns the previously-installed dataset (the old Arc) so the caller can keep or drop it; outstanding readers that already cloned it stay valid regardless.