Struct QuorumStateMachine 

pub struct QuorumStateMachine { /* private fields */ }

The hand-rolled KIP-595 + KIP-996 quorum state machine.

The state machine is pure and deterministic. It consumes Events, reads the log through LogView, takes the current time as an injected SimInstant, and produces a list of Actions for the caller to execute. It never touches the clock, the wire, or the log bytes directly.

Implementations

impl QuorumStateMachine

pub fn apply_voter_set( &mut self, voters: VoterSet, now: SimInstant, ) -> Vec<Action>

Apply the latest voter set read from the Raft log or a snapshot.

KIP-853 requires replicas to use an uncommitted VotersRecord immediately. The durable engine owns record history and invokes this method again with the preceding set if the log is truncated.

pub fn set_kraft_version(&mut self, version: u16)

Apply a committed KRaftVersionRecord.

pub fn commit_voter_set(&mut self)

Forget the preceding voter view once the latest voter record commits.

pub fn current_or_adjacent_voter_entry(&self, id: NodeId) -> Option<&Voter>

Voter id from the current voter set, or from the adjacent set of an uncommitted KIP-853 change. A leader that only the adjacent set names is still followed (see handle_begin_quorum_epoch), so its endpoints are looked up the same way.

pub fn finish_local_leader_removal(&mut self, now: SimInstant) -> Vec<Action>

Complete removal of the local leader after the reduced voter set has committed. Fetch serving continues until the engine invokes this edge.

The removed leader becomes a discovering observer and arms its fetch timer. No later leader announces itself to a node outside the voter set, so the Fetch that the timer sends is how this node finds the new leader. Kafka’s removed leader also goes on as an observer of its successor, and DescribeQuorum on that successor lists it.

impl QuorumStateMachine

pub fn adopt_replica_progress(&mut self, id: NodeId, progress: ReplicaProgress)

Give the voter id the progress it had while it was an observer, as Kafka does when a replica joins the voter set (LeaderState.updateVoterAndObserverStates reuses its ReplicaState). Nothing happens unless this replica leads and id is another voter.

impl QuorumStateMachine

pub fn resign_for_shutdown(&mut self, now: SimInstant) -> Vec<Action>

Resign the leadership this replica holds because it is shutting down.

A leader becomes Resigned and sends EndQuorumEpoch, naming the other voters by descending fetch offset as its preferred successors. This is pollLeader with a GracefulShutdown set. Any other role holds no leadership to hand over, and nothing changes.

pub fn graceful_shutdown_complete(&self) -> bool

Whether a shutting-down replica has nothing left to hand over.

This is Kafka’s KafkaRaftClient.maybeCompleteShutdown: an observer, the only voter, and a replica that knows a leader other than itself stop at once. A leader, a resigned leader, and a voter between leaders keep running until a remote leader is known, which is what lets the quorum elect a successor without them.

impl QuorumStateMachine

pub fn advance_epoch_for_vote( &mut self, candidate: ReplicaKey, epoch: u32, now: SimInstant, ) -> Vec<Action>

Kafka’s transitionToUnattached on seeing a vote or pre-vote from candidate at an epoch above ours: adopt that epoch as an unattached replica with no leader and no vote. A request at our own epoch, or below it, changes nothing, and neither does one between replicas that are not both voters, which this replica denies without acting on its epoch.

KafkaRaftClient.handleVoteRequest makes this transition before it checks the voter key the request names, so the engine calls it for a request it will refuse for its key, and the response then carries the new epoch.

impl QuorumStateMachine

pub fn new( me: NodeId, state: QuorumState, timeouts: QuorumTimeouts, ) -> QuorumStateMachine

timeouts.election is the base extent of an election timer, before jitter, and callers vary it per node for liveness. timeouts.fetch is the fetch watchdog.

This constructor rounds both values to whole milliseconds. That is the domain of both the verified jitter kernel and the SimInstant clock.

pub fn quorum_state(&self) -> &QuorumState

pub fn me(&self) -> NodeId

This replica’s own node id.

pub fn role(&self) -> &Role

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

The leader this replica knows for its epoch: the one it follows, or the one a prospective gave up on when it began its pre-vote.

This is Kafka’s QuorumState.hasLeader, which counts a ProspectiveState’s retained leader. A response that names the leader of the current epoch moves a replica to it only while this is None.

pub fn is_voter(&self) -> bool

pub fn on_event( &mut self, event: Event, log: &dyn LogView, now: SimInstant, ) -> Vec<Action>

Trait Implementations

impl Clone for QuorumStateMachine

fn clone(&self) -> QuorumStateMachine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuorumStateMachine

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

Formats the value using the given formatter.

impl Eq for QuorumStateMachine

impl Hash for QuorumStateMachine

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for QuorumStateMachine

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for QuorumStateMachine