Struct PartitionGuard 

pub struct PartitionGuard {
    pub partition_id: u32,
    pub epoch: u64,
    pub node_id: NodeId,
    /* private fields */
}

An epoch-fenced guard for a single partition.

The hot-path check() is a single atomic load, designed for sub-10ns latency in the event processing loop.

Fields

partition_id: u32

The partition this guard protects.

epoch: u64

The epoch at which this node acquired ownership.

node_id: NodeId

The owning node.

Implementations

impl PartitionGuard

pub fn new(partition_id: u32, epoch: u64, node_id: NodeId) -> Self

Create a new guard for a partition at the given epoch.

pub fn check(&self) -> Result<(), EpochError>

Fast-path epoch check (single atomic load).

Returns Ok(()) if this node still owns the partition at the expected epoch. Returns Err(EpochError::Fenced) if the epoch has advanced (meaning ownership has changed).

Errors

Returns EpochError::Fenced if the partition’s epoch has changed.

pub fn update_cached_epoch(&self, new_epoch: u64)

Update the cached epoch from an external source (e.g., Raft read).

Called periodically by the health-check task to propagate epoch changes from the Raft state machine.

pub fn cached_epoch_handle(&self) -> Arc<AtomicU64>

Get a handle to the cached epoch atomic for external updates.

Trait Implementations

impl Debug for PartitionGuard

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

Formats the value using the given formatter.