Struct RaftNode 

pub struct RaftNode { /* private fields */ }

A Raft consensus node

Implementations

impl RaftNode

pub fn new(config: RaftConfig) -> RaftResult<Self>

Create a new Raft node

pub fn with_persistence( config: RaftConfig, persistence: Arc<dyn RaftPersistence>, ) -> RaftResult<Self>

Create a new Raft node with an explicit persistence backend.

Recovers state from the given persistence backend and uses it for all subsequent state and log mutations.

pub fn node_id(&self) -> NodeId

Get the current node ID

pub fn current_term(&self) -> Term

Get the current term

pub fn state(&self) -> NodeState

Get the current state

pub fn leader_id(&self) -> Option<NodeId>

Get the current leader ID

pub fn is_leader(&self) -> bool

Check if this node is the leader

pub fn commit_index(&self) -> LogIndex

Get the commit index

pub fn last_log_index(&self) -> LogIndex

Get the last log index

pub fn propose(&self, command: Command) -> RaftResult<LogIndex>

Append a command to the log (leader only)

pub fn is_recovering(&self) -> bool

Return true if the node is currently replaying its WAL on startup.

pub fn handle_request_vote( &self, req: RequestVoteRequest, ) -> RequestVoteResponse

Handle a RequestVote RPC

pub fn handle_append_entries( &self, req: AppendEntriesRequest, ) -> AppendEntriesResponse

Handle an AppendEntries RPC

pub fn start_election(&self) -> Vec<RequestVoteRequest>

Start an election (transition to candidate)

pub fn handle_vote_response( &self, from: NodeId, resp: RequestVoteResponse, ) -> bool

Handle a vote response during election

pub fn issue_fencing_token(&self) -> Option<FencingToken>

Issue a new fencing token for the current leader term.

Returns None if the node is not the current leader.

pub fn validate_fencing_token(&self, token: &FencingToken) -> RaftResult<()>

Validate that token is not stale relative to the current Raft term.

Returns Ok(()) if the token’s term matches the current Raft term. Returns Err(RaftError::StaleTerm) if the token predates the current term.

pub fn create_heartbeats(&self) -> Vec<(NodeId, AppendEntriesRequest)>

Create heartbeat messages for all peers

pub fn create_replication_requests(&self) -> Vec<(NodeId, AppendEntriesRequest)>

Create replication messages for all peers

pub fn replicate_to_followers(&self) -> Vec<(NodeId, AppendEntriesRequest)>

Replicate log entries to all followers that need them.

This is a convenience method that combines create_replication_requests() with the information the caller needs to actually send the RPCs. Returns a list of (peer_id, request) pairs. If a follower is fully caught up (its next_index > last_log_index), it is omitted – use create_heartbeats() for idle keep-alive messages.

Typical usage in a replication loop:

let requests = leader.replicate_to_followers();
for (peer, req) in requests {
    let resp = rpc_send(peer, req);
    leader.handle_replication_response(peer, resp)?;
}

pub fn create_replication_request_for( &self, peer: NodeId, ) -> Option<AppendEntriesRequest>

Create an AppendEntries request for a specific follower.

Returns None if this node is not the leader, if the follower is already fully caught up, or if leader state is unavailable.

pub fn handle_replication_response( &self, from: NodeId, resp: AppendEntriesResponse, ) -> RaftResult<()>

Handle a replication response

pub fn maybe_create_snapshot( &self, state_machine_data: Vec<u8>, ) -> RaftResult<bool>

Attempt to create a snapshot if the log has grown past the threshold

Call this after advancing the commit index. If a snapshot is created, the log is compacted up to the snapshot point.

state_machine_data is the serialized state of the application state machine at the current applied index.

pub fn auto_snapshot_if_needed<F>( &self, policy: &SnapshotPolicy, state_machine_data_fn: F, ) -> RaftResult<bool>

where F: FnOnce() -> RaftResult<Vec<u8>>,

Automatically create a snapshot if the log has grown past the configured threshold.

Unlike maybe_create_snapshot, this method uses a SnapshotPolicy to decide whether to snapshot and takes a closure that produces state machine data on demand (avoiding the cost of serialization when no snapshot is needed).

Call this after applying committed entries.

pub fn handle_install_snapshot( &self, req: InstallSnapshotRequest, ) -> RaftResult<InstallSnapshotResponse>

Handle an InstallSnapshot RPC from the leader

Used when a follower is too far behind and the leader sends a snapshot instead of individual log entries.

pub fn prepare_install_snapshot( &self, target_peer: NodeId, ) -> RaftResult<Option<InstallSnapshotRequest>>

Prepare an InstallSnapshot request for a follower that is too far behind

This is called by the leader when a follower’s next_index falls behind the snapshot point and log entries are no longer available.

pub fn follower_needs_snapshot(&self, peer: NodeId) -> bool

Check if a follower needs a snapshot instead of normal log replication

Returns true if the follower’s next_index is at or before the snapshot point.

pub fn add_node(&self, node_id: NodeId, address: String) -> RaftResult<()>

Add a node to the cluster via joint consensus.

If this node is the leader the change is proposed immediately. Returns an error if a membership change is already in progress or the node is already a member.

pub fn remove_node(&self, node_id: NodeId) -> RaftResult<()>

Remove a node from the cluster via joint consensus.

If the removed node is this node, it will step down after the configuration change commits.

pub fn cluster_members(&self) -> Vec<(NodeId, String)>

Get the current list of cluster members as (node_id, address) pairs.

pub fn is_in_joint_consensus(&self) -> bool

Check whether the cluster is currently in joint consensus.

pub fn membership_version(&self) -> u64

Get the current membership configuration version.

pub fn propose_membership_change( &self, change: MembershipChange, ) -> RaftResult<()>

Propose a membership change (leader only).

Implements the simplified Raft joint consensus protocol (Section 6):

1. Leader creates joint config C_{old,new} and replicates it.
2. Once C_{old,new} is committed the leader creates C_{new}.
3. During the joint state, decisions require a majority of both the old and new configurations.

pub fn commit_membership_change(&self) -> RaftResult<()>

Commit the joint consensus transition: move from C_{old,new} to C_{new}.

Call this once the joint config entry has been committed (i.e. acknowledged by a quorum of both old and new configs).

pub fn has_quorum(&self, responding_nodes: &HashSet<NodeId>) -> bool

Calculate whether a set of nodes forms a quorum under the current membership config (handles both stable and joint states).

pub fn is_stepping_down(&self) -> bool

Check if this node is stepping down (has been removed from the cluster).

pub fn election_timeout_elapsed(&self) -> bool

Check if election timeout has elapsed

pub fn reset_election_timer(&self)

Reset election timer

pub fn get_leader_hint(&self) -> Option<NodeId>

Get a hint about the current leader (for client redirection)

pub fn trigger_failover_election(&self) -> Vec<RequestVoteRequest>

Trigger a failover election if this node is a follower. Returns the vote requests to send to peers, or an empty vec if the node is not in follower state.