Crate almost_raft

Consensus or agreeing on some value is a fundamental issue in a distributed system. While there are algorithms like Paxos exists since long back, the complexity of those make implementation complicated.

So Raft was designed to solve the problem while keeping the algorithm understandable.

Raft tackles the problem in two steps -

• Leader Election - Elect a node as a leader on startup or when the existing one fails
• Log Replication - Maintain the log consistency among nodes

This crate handles Leader election provided a list of nodes.

For more on Raft https://raft.github.io.

Usage

almost-raft uses a closed loop, the only way to communicate is to use mpsc channel and control messages.

First step is to implement trait Node. For example - a simple node that uses mpsc channel to communicate with others

use tokio::sync::mpsc::Sender;
use almost_raft::{Message, Node};
#[derive(Debug, Clone)]
struct NodeMPSC {
    id: String,
    sender: Sender<Message<NodeMPSC>>,
}

#[async_trait]
impl Node for NodeMPSC {
    type NodeType = NodeMPSC;
    async fn send_message(&self, msg: Message<Self::NodeType>) {
        self.sender.send(msg).await;
    }

    fn node_id(&self) -> &String {
        &self.id
    }
}

To initiate RaftElectionState

use tokio::sync::mpsc;
use almost_raft::election::RaftElectionState;
let (heartbeat_interval, message_timeout, timeout, max_node, min_node) =
    (1000, 20, 5000, 5, 3);
let (tx, mut from_raft) = mpsc::channel(10);
let self_id = uuid::Uuid::new_v4().to_string();
let nodes = vec![]; // we'll add node later
let (state, tx_to_raft) = RaftElectionState::init(
    self_id,
    timeout,
    heartbeat_interval,
    message_timeout,
    nodes,
    tx.clone(),
    max_node,
    min_node,
);

Now we can start the election process using the state. But this will not necessarily start the election, it’ll wait as long as there isn’t enough node (min_node).

use almost_raft::election::raft_election;
tokio::spawn(raft_election(state));

Let’s add nodes

use tokio::sync::mpsc;
use almost_raft::Message;
let (tx,rx) = mpsc::channel(10);
tx_to_raft
    .send(Message::ControlAddNode(NodeMPSC {
        id: uuid::Uuid::new_v4().to_string(),
        sender: tx,
    }))
    .await;

Raft will notify through mpsc channel if there’s any change in leadership. To receive the event

// let (tx, mut from_raft) = mpsc::channel(10);
// tx was used to initialize RaftElectionState
from_raft.recv().await;

Modules

election

handles election process

Enums

Message

Messages to communicate with Raft

NodeState

States of the node

Traits

Node

A Cluster node