Struct raft::Raft

pub struct Raft<T: Storage> {
    pub msgs: Vec<Message>,
    pub r: RaftCore<T>,
    /* private fields */
}

A struct that represents the raft consensus itself. Stores details concerning the current and possible state the system can take.

Fields

msgs: Vec<Message>

The list of messages.

r: RaftCore<T>

Internal raftCore.

Implementations

impl<T: Storage> Raft<T>

pub fn new(c: &Config, store: T, logger: &Logger) -> Result<Self>

Creates a new raft for use on the node.

pub fn set_priority(&mut self, priority: i64)

Sets priority of node.

pub fn with_default_logger(c: &Config, store: T) -> Result<Self>

Creates a new raft for use on the node with the default logger.

The default logger is an slog to log adapter.

pub fn store(&self) -> &T

Grabs an immutable reference to the store.

pub fn mut_store(&mut self) -> &mut T

Grabs a mutable reference to the store.

pub fn snap(&self) -> Option<&Snapshot>

Grabs a reference to the snapshot

pub fn pending_read_count(&self) -> usize

Returns the number of pending read-only messages.

pub fn ready_read_count(&self) -> usize

Returns how many read states exist.

pub fn soft_state(&self) -> SoftState

Returns a value representing the softstate at the time of calling.

pub fn hard_state(&self) -> HardState

Returns a value representing the hardstate at the time of calling.

pub fn in_lease(&self) -> bool

Returns whether the current raft is in lease.

pub fn election_timeout(&self) -> usize

Fetch the length of the election timeout.

pub fn heartbeat_timeout(&self) -> usize

Fetch the length of the heartbeat timeout

pub fn heartbeat_elapsed(&self) -> usize

Fetch the number of ticks elapsed since last heartbeat.

pub fn randomized_election_timeout(&self) -> usize

Return the length of the current randomized election timeout.

pub fn skip_bcast_commit(&mut self, skip: bool)

Set whether skip broadcast empty commit messages at runtime.

pub fn set_batch_append(&mut self, batch_append: bool)

Set whether batch append msg at runtime.

pub fn enable_group_commit(&mut self, enable: bool)

Configures group commit.

If group commit is enabled, only logs replicated to at least two different groups are committed.

You should use assign_commit_groups to configure peer groups.

pub fn group_commit(&self) -> bool

Whether enable group commit.

pub fn assign_commit_groups(&mut self, ids: &[(u64, u64)])

Assigns groups to peers.

The tuple is (peer_id, group_id). group_id should be larger than 0.

The group information is only stored in memory. So you need to configure it every time a raft state machine is initialized or a snapshot is applied.

pub fn clear_commit_group(&mut self)

Removes all commit group configurations.

pub fn check_group_commit_consistent(&mut self) -> Option<bool>

Checks whether the raft group is using group commit and consistent over group.

If it can’t get a correct answer, None is returned.

pub fn commit_to_current_term(&self) -> bool

Checks if logs are committed to its term.

The check is useful usually when raft is leader.

pub fn apply_to_current_term(&self) -> bool

Checks if logs are applied to current term.

pub fn set_max_committed_size_per_ready(&mut self, size: u64)

Set max_committed_size_per_ready to size.

pub fn set_check_quorum(&mut self, check_quorum: bool)

Set whether or not check_quorum.

impl<T: Storage> Raft<T>

pub fn inflight_buffers_size(&self) -> usize

Get the inflight buffer size.

pub fn send_append(&mut self, to: u64)

Sends an append RPC with new entries (if any) and the current commit index to the given peer.

pub fn bcast_append(&mut self)

Sends RPC, with entries to all peers that are not up-to-date according to the progress recorded in r.prs().

pub fn ping(&mut self)

Broadcasts heartbeats to all the followers if it’s leader.

pub fn bcast_heartbeat(&mut self)

Sends RPC, without entries to all the peers.

pub fn maybe_commit(&mut self) -> bool

Attempts to advance the commit index. Returns true if the commit index changed (in which case the caller should call r.bcast_append).

pub fn commit_apply(&mut self, applied: u64)

Commit that the Raft peer has applied up to the given index.

Registers the new applied index to the Raft log.

Hooks

• Post: Checks to see if it’s time to finalize a Joint Consensus state.

pub fn reset(&mut self, term: u64)

Resets the current node to a given term.

pub fn append_entry(&mut self, es: &mut [Entry]) -> bool

Appends a slice of entries to the log. The entries are updated to match the current index and term. Only called by leader currently

pub fn on_persist_entries(&mut self, index: u64, term: u64)

Notifies that these raft logs have been persisted.

pub fn on_persist_snap(&mut self, index: u64)

Notifies that the snapshot have been persisted.

pub fn tick(&mut self) -> bool

Returns true to indicate that there will probably be some readiness need to be handled.

pub fn tick_election(&mut self) -> bool

Run by followers and candidates after self.election_timeout.

Returns true to indicate that there will probably be some readiness need to be handled.

pub fn become_follower(&mut self, term: u64, leader_id: u64)

Converts this node to a follower.

pub fn become_candidate(&mut self)

Converts this node to a candidate

Panics

Panics if a leader already exists.

pub fn become_pre_candidate(&mut self)

Converts this node to a pre-candidate

Panics

Panics if a leader already exists.

pub fn become_leader(&mut self)

Makes this raft the leader.

Panics

Panics if this is a follower node.

pub fn step(&mut self, m: Message) -> Result<()>

Steps the raft along via a message. This should be called everytime your raft receives a message from a peer.

pub fn request_snapshot(&mut self) -> Result<()>

Request a snapshot from a leader.

pub fn handle_append_entries(&mut self, m: &Message)

For a given message, append the entries to the log.

pub fn handle_heartbeat(&mut self, m: Message)

For a message, commit and send out heartbeat.

pub fn restore(&mut self, snap: Snapshot) -> bool

Recovers the state machine from a snapshot. It restores the log and the configuration of state machine.

pub fn post_conf_change(&mut self) -> ConfState

Updates the in-memory state and, when necessary, carries out additional actions such as reacting to the removal of nodes or changed quorum requirements.

pub fn has_pending_conf(&self) -> bool

Check if there is any pending confchange.

This method can be false positive.

pub fn should_bcast_commit(&self) -> bool

Specifies if the commit should be broadcast.

pub fn promotable(&self) -> bool

Indicates whether state machine can be promoted to leader, which is true when it’s a voter and its own id is in progress list.

pub fn prs(&self) -> &ProgressTracker

Returns a read-only reference to the progress set.

pub fn mut_prs(&mut self) -> &mut ProgressTracker

Returns a mutable reference to the progress set.

pub fn load_state(&mut self, hs: &HardState)

For a given hardstate, load the state into self.

pub fn pass_election_timeout(&self) -> bool

pass_election_timeout returns true iff election_elapsed is greater than or equal to the randomized election timeout in [election_timeout, 2 * election_timeout - 1].

pub fn reset_randomized_election_timeout(&mut self)

Regenerates and stores the election timeout.

pub fn send_timeout_now(&mut self, to: u64)

Issues a message to timeout immediately.

pub fn abort_leader_transfer(&mut self)

Stops the transfer of a leader.

pub fn reduce_uncommitted_size(&mut self, ents: &[Entry])

Reduce size of ‘ents’ from uncommitted size.

pub fn maybe_increase_uncommitted_size(&mut self, ents: &[Entry]) -> bool

Increase size of ‘ents’ to uncommitted size. Return true when size limit is satisfied. Otherwise return false and uncommitted size remains unchanged. For raft with no limit(or non-leader raft), it always return true.

pub fn uncommitted_size(&self) -> usize

Return current uncommitted size recorded by uncommitted_state

pub fn maybe_free_inflight_buffers(&mut self)

A Raft leader allocates a vector with capacity max_inflight_msgs for every peer. It takes a lot of memory if there are too many Raft groups. maybe_free_inflight_buffers is used to free memory if necessary.

pub fn adjust_max_inflight_msgs(&mut self, target: u64, cap: usize)

To adjust max_inflight_msgs for the specified peer. Set to 0 will disable the progress.

Trait Implementations

impl<T: Storage> Deref for Raft<T>

type Target = RaftCore<T>

The resulting type after dereferencing.

fn deref(&self) -> &RaftCore<T>

Dereferences the value.

impl<T: Storage> DerefMut for Raft<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.