Crate raft[−][src]
Creating a Raft node
You can use RawNode::new
to create the Raft node. To create the Raft node, you need to provide a Storage
component, and a Config
to the RawNode::new
function.
use raft::{ Config, storage::MemStorage, raw_node::RawNode, }; // Select some defaults, then change what we need. let id = 1; let peers = vec![]; let storage = MemStorage::default(); let config = Config::new(id); // ... Make any configuration changes. // After, make sure it's valid! config.validate().unwrap(); // We'll use the built-in `MemStorage`, but you will likely want your own. // Finally, create our Raft node! let mut node = RawNode::new(&config, storage, peers).unwrap();
Ticking the Raft node
Use a timer to tick the Raft node at regular intervals. See the following example using Rust channel recv_timeout
to drive the Raft node at least every 100ms, calling tick()
each time.
use std::{sync::mpsc::{channel, RecvTimeoutError}, time::{Instant, Duration}}; // We're using a channel, but this could be any stream of events. let (tx, rx) = channel(); let timeout = Duration::from_millis(100); // Send the `tx` somewhere else... let ticks = 5; // Only tick 5 times. let mut remaining_timeout = timeout; for _ in 0..ticks { let now = Instant::now(); match rx.recv_timeout(remaining_timeout) { Ok(()) => { // Let's save this for later. unimplemented!() }, Err(RecvTimeoutError::Timeout) => (), Err(RecvTimeoutError::Disconnected) => unimplemented!(), } let elapsed = now.elapsed(); if elapsed >= remaining_timeout { remaining_timeout = timeout; // We drive Raft every 100ms. node.tick(); } else { remaining_timeout -= elapsed; } }
Proposing to, and stepping the Raft node
Using the propose
function you can drive the Raft node when the client sends a request to the Raft server. You can call propose
to add the request to the Raft log explicitly.
In most cases, the client needs to wait for a response for the request. For example, if the client writes a value to a key and wants to know whether the write succeeds or not, but the write flow is asynchronous in Raft, so the write log entry must be replicated to other followers, then committed and at last applied to the state machine, so here we need a way to notify the client after the write is finished.
One simple way is to use a unique ID for the client request, and save the associated callback function in a hash map. When the log entry is applied, we can get the ID from the decoded entry, call the corresponding callback, and notify the client.
You can call the step
function when you receive the Raft messages from other nodes.
Here is a simple example to use propose
and step
:
let mut cbs = HashMap::new(); loop { match receiver.recv_timeout(d) { Ok(Msg::Propose { id, callback }) => { cbs.insert(id, callback); node.propose(vec![id], false).unwrap(); } Ok(Msg::Raft(m)) => node.step(m).unwrap(), // ... } //... }
In the above example, we use a channel to receive the propose
and step
messages. We only propose the request ID to the Raft log. In your own practice, you can embed the ID in your request and propose the encoded binary request data.
Processing the Ready
State
When your Raft node is ticked and running, Raft should enter a Ready
state. You need to first use has_ready
to check whether Raft is ready. If yes, use the ready
function to get a Ready
state:
if !node.has_ready() { return; } // The Raft is ready, we can do something now. let mut ready = node.ready();
The Ready
state contains quite a bit of information, and you need to check and process them one by one:
-
Check whether
snapshot
is empty or not. If not empty, it means that the Raft node has received a Raft snapshot from the leader and we must apply the snapshot:ⓘThis example is not testedif !raft::is_empty_snap(&ready.snapshot) { // This is a snapshot, we need to apply the snapshot at first. node.mut_store() .wl() .apply_snapshot(ready.snapshot.clone()) .unwrap(); }
-
Check whether
entries
is empty or not. If not empty, it means that there are newly added entries but has not been committed yet, we must append the entries to the Raft log:ⓘThis example is not testedif !ready.entries.is_empty() { // Append entries to the Raft log node.mut_store().wl().append(&ready.entries).unwrap(); }
-
Check whether
hs
is empty or not. If not empty, it means that theHardState
of the node has changed. For example, the node may vote for a new leader, or the commit index has been increased. We must persist the changedHardState
:ⓘThis example is not testedif let Some(ref hs) = ready.hs { // Raft HardState changed, and we need to persist it. node.mut_store().wl().set_hardstate(hs.clone()); }
-
Check whether
messages
is empty or not. If not, it means that the node will send messages to other nodes. There has been an optimization for sending messages: if the node is a leader, this can be done together with step 1 in parallel; if the node is not a leader, it needs to reply the messages to the leader after appending the Raft entries:ⓘThis example is not testedif !is_leader { // If not leader, the follower needs to reply the messages to // the leader after appending Raft entries. let msgs = ready.messages.drain(..); for _msg in msgs { // Send messages to other peers. } }
-
Check whether
committed_entires
is empty or not. If not, it means that there are some newly committed log entries which you must apply to the state machine. Of course, after applying, you need to update the applied index and resumeapply
later:ⓘThis example is not testedif let Some(committed_entries) = ready.committed_entries.take() { let mut _last_apply_index = 0; for entry in committed_entries { // Mostly, you need to save the last apply index to resume applying // after restart. Here we just ignore this because we use a Memory storage. _last_apply_index = entry.get_index(); if entry.get_data().is_empty() { // Emtpy entry, when the peer becomes Leader it will send an empty entry. continue; } match entry.get_entry_type() { EntryType::EntryNormal => handle_normal(entry), EntryType::EntryConfChange => handle_conf_change(entry), } } }
-
Call
advance
to prepare for the nextReady
state.ⓘThis example is not testednode.advance(ready);
For more information, check out an example.
Re-exports
pub use self::raft_log::NO_LIMIT; |
pub use self::raw_node::is_empty_snap; |
pub use self::raw_node::Peer; |
pub use self::raw_node::RawNode; |
pub use self::raw_node::Ready; |
pub use self::raw_node::SnapshotStatus; |
pub use self::storage::RaftState; |
pub use self::storage::Storage; |
Modules
eraftpb | |
prelude |
A "prelude" for crates using the |
raw_node | |
storage | |
util |
Structs
Config |
Config contains the parameters to start a raft. |
Inflights | |
Progress | |
ProgressSet |
|
Raft | |
RaftLog |
Raft log implementation |
ReadState | |
SoftState | |
Status | |
Unstable |
Enums
Error | |
ProgressState | |
ReadOnlyOption | |
StateRole | |
StorageError |
Constants
INVALID_ID | |
INVALID_INDEX |
Functions
quorum | |
vote_resp_msg_type |
Type Definitions
Result |