Struct MoveRange 

pub struct MoveRange { /* private fields */ }

One in-flight move-range: the bookkeeping that carries authority for one range from its current owner to a target without losing a write or letting the target serve early.

Built with begin, which enlists the target as a replica and captures the catalog CAS (owner / epoch / version) the cutover will use. The snapshot point and the target’s catch-up progress are filled in as the move runs. Until cut_over succeeds the catalog is unchanged, so the old owner keeps serving and the target — a mere replica — cannot.

Implementations

impl MoveRange

pub fn begin( catalog: &mut ShardOwnershipCatalog, collection: CollectionId, range_id: RangeId, target: NodeIdentity, ) -> Result<MoveRange, MoveError>

Start moving (collection, range_id) to target. Enlists target as a replica of the range if it is not one already (so the cutover has a valid promotion candidate), then captures the catalog CAS for the eventual fenced handoff. The move begins in CopyingSnapshot; the catalog’s owner is unchanged, so the old owner keeps serving writes.

Fails if the range is unknown or target is already its owner (a move to the incumbent is a no-op).

pub fn phase(&self) -> MovePhase

pub fn source(&self) -> &NodeIdentity

pub fn target(&self) -> &NodeIdentity

pub fn snapshot_watermark(&self) -> Option<CommitWatermark>

The consistent point the physical snapshot was taken at, once installed.

pub fn position(&self) -> Option<RangeStreamPosition>

The target’s catch-up position over the range-indexed WAL, once catch-up has begun.

pub fn complete_snapshot( &mut self, at: CommitWatermark, ) -> Result<(), MoveError>

Record that the target has installed a consistent physical snapshot taken at at. Moves the move into CatchingUp and seeds the catch-up position from the snapshot point: the target has applied everything up to at and will accept range records ahead of it, fencing any stamped below the range’s current ownership epoch.

Only valid while copying the snapshot.

pub fn record_catch_up( &mut self, records: &[ChangeRecord], ) -> Result<RangeCatchupPlan, MoveError>

Replay a slice of the shared logical stream into the target’s range-indexed catch-up, advancing its applied position past every record stamped for this range (issue #992). Returns the RangeCatchupPlan so the caller can see which records applied and which were fenced. Only valid while catching up.

pub fn catch_up_evidence(&self) -> Option<CatchUpEvidence>

The catch-up evidence the cutover will present for the target: the highest (term, lsn) it has applied for the range. None before a snapshot is installed.

pub fn has_caught_up(&self, live: CommitWatermark) -> bool

Whether the target’s applied log covers live — the live range commit watermark, which has advanced past the snapshot point as the old owner kept writing. The cutover may only proceed once this holds.

pub fn cut_over( &mut self, catalog: &mut ShardOwnershipCatalog, live: CommitWatermark, ) -> Result<TransitionOutcome, MoveError>

Cut over: move the catalog epoch to the target through the fenced Handoff transition, demoting the old owner to a replica. The move must be CatchingUp and the target must cover live — otherwise this returns TargetBehindWatermark without touching the catalog, so a target that has not caught up is never promoted and the old owner keeps serving.

On success the catalog names the target at a new epoch (fencing the old owner’s stale-epoch writes) and the move is Completed.

pub fn abort(&mut self)

Abandon the move. The catalog is untouched (the old owner remains owner); the target keeps whatever copy it has but is never promoted.

Trait Implementations

impl Clone for MoveRange

fn clone(&self) -> MoveRange

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MoveRange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for MoveRange

impl PartialEq for MoveRange

fn eq(&self, other: &MoveRange) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MoveRange