22-Feb-2025

Raft is a consensus algorithm designed as a more understandable alternative to Paxos. It ensures that all servers in a distributed system agree on a single, consistent log of commands, even in the presence of failures. Raft simplifies the problem by breaking it down into three sub-problems:

• Leader Election: If the current leader fails or is unreachable, a new leader must be elected.
• Log Replication: The leader accepts new log entries and replicates them to the follower servers.
• Safety: Raft guarantees that committed log entries are consistent across all servers and will never be overwritten or lost.

How Raft Works:

Raft nodes can be in one of three states: Leader, Follower, or Candidate.

1. Leader Election:

   • Each node starts as a follower.
   • Followers wait for heartbeats from the leader.
   • If a follower doesn’t receive a heartbeat within a timeout period, it becomes a candidate.
   • The candidate requests votes from other nodes.
   • If a candidate receives a majority of votes, it becomes the new leader.

2. Log Replication:

   • The leader receives client requests and appends them to its log.
   • The leader then replicates these entries to the followers.
   • Each log entry includes a term number (which increases monotonically with each election) and an index.

3. Safety:

   • Raft ensures safety through several mechanisms:
     • Election Restrictions: Only a candidate with an up-to-date log can be elected leader.
     • Log Matching: The leader forces followers to match its log before committing entries.
     • Committing Entries: An entry is committed once a majority of followers in the current term have replicated it.

Simplified Example (Conceptual JavaScript):

// Server states
const FOLLOWER = 0;
const CANDIDATE = 1;
const LEADER = 2;

// Server object (simplified)
function Server(id) {
  this.id = id;
  this.state = FOLLOWER;
  this.term = 0;
  this.log = [];
  // ... other properties like votedFor, timeout, etc.
}


// Example of a server receiving a vote request
Server.prototype.onRequestVote = function(term, candidateId) {
    if (term > this.term && this.votedFor === null) {
        this.votedFor = candidateId;
        this.term = term;
        // Send vote granted message to candidate
        return true;
    }
    return false;
};

// Example of leader appending an entry
Server.prototype.appendEntry = function(term, entry) {
    if (term >= this.term) {
        this.term = term;
        this.log.push(entry);
        // Send append successful message to leader
        return true;
    }

    return false;
};


// Create some servers
const server1 = new Server(1);
const server2 = new Server(2);
const server3 = new Server(3);

// ... election logic, heartbeat logic, client interaction logic, etc. would go here

Key Advantages of Raft:

• Understandability: Raft’s design focuses on understandability, making it easier to implement and reason about.
• Strong Leader: Having a single leader simplifies log replication and other operations.
• Fault Tolerance: Raft can tolerate the failure of a minority of servers.

Raft is a powerful consensus algorithm that provides a robust foundation for building distributed systems. Its simplicity and clarity make it an attractive alternative to more complex algorithms like Paxos.