Leader Election

Why Leader Election

Leader election selects one node to coordinate distributed operations.

The Problem

Without Leader:

Node A: I'll handle this request
Node B: I'll handle this request  (duplicate work!)
Node C: I'll handle this request

Result: Confusion, duplicates, inconsistency

With Leader

With Leader:

Node A: Leader (coordinates)
Node B: Follower (waits)
Node C: Follower (waits)

Result:有序 coordination

Use Cases

Use Case	Why Leader Needed
Database replication	Single source of truth
Task coordination	One coordinator
Configuration management	Single authority
Lock management	Centralized coordination
Shard assignment	Consistent routing

Requirements

1. Safety: Only one leader at a time
2. Liveness: Eventually some node becomes leader
3. Fault tolerance: Leader failure triggers re-election
4. Performance: Election should be fast

Raft Protocol

Raft is a consensus algorithm for leader election and log replication.

Node States

Raft Node States:

1. Follower:
   - Passive state
   - Responds to leader
   - Counts heartbeat timeout

2. Candidate:
   - Active election
   - Requests votes
   - Becomes leader if majority votes

3. Leader:
   - Handles client requests
   - Replicates log
   - Sends heartbeats

Election Process

1. Follower timeout (no heartbeat)
2. Become candidate
3. Increment term
4. Vote for self
5. Request votes from others
6. If majority votes → become leader
7. Send heartbeats to establish authority

Log Replication

Leader receives command:
1. Append to local log
2. Send AppendEntries to followers
3. Followers append to their logs
4. Once majority confirm → commit
5. Apply to state machine
6. Respond to client

Term Concept

Term = logical clock

Term 1: Node A elected
Term 2: Node A fails, Node B elected
Term 3: Split vote, no leader
Term 4: Node C elected

Each term has at most one leader

Raft Safety

1. Election Safety: At most one leader per term
2. Leader Append-Only: Leader never overwrites logs
3. Log Matching: Same index + term = same command
4. Leader Completeness: Committed logs preserved
5. State Machine Safety: Applied in same order

ZooKeeper Leader Election

ZooKeeper Concepts

ZooKeeper:
- Distributed coordination service
- Maintains hierarchical namespace (znodes)
- Provides strong consistency
- Used for: leader election, config, locks

Leader Election with ZooKeeper

from kazoo.client import KazooClient
import uuid

class ZooKeeperLeaderElection:
    def __init__(self, zk_hosts, election_path):
        self.zk = KazooClient(hosts=zk_hosts)
        self.election_path = election_path
        self.node_path = None
        self.is_leader = False
    
    def start(self):
        self.zk.start()
        self.zk.ensure_path(self.election_path)
        self.register()
    
    def register(self):
        # Create ephemeral sequential node
        self.node_path = self.zk.create(
            f"{self.election_path}/candidate-",
            value=str(uuid.uuid4()).encode(),
            ephemeral=True,
            sequence=True
        )
        self.watch_predecessor()
    
    def watch_predecessor(self):
        # Get all candidates
        candidates = self.zk.get_children(self.election_path)
        candidates.sort()
        
        # Find my position
        my_index = candidates.index(self.node_path.split('/')[-1])
        
        if my_index == 0:
            # I'm the leader!
            self.become_leader()
        else:
            # Watch predecessor
            predecessor = candidates[my_index - 1]
            @self.zk.DataWatch(f"{self.election_path}/{predecessor}")
            def watch_predecessor(data, stat):
                if stat is None:  # Predecessor gone
                    self.watch_predecessor()
    
    def become_leader(self):
        self.is_leader = True
        print("I am the leader!")

ZooKeeper vs Raft

Aspect	ZooKeeper	Raft
Implementation	Service	Algorithm
Usage	External service	Embedded library
Consistency	Strong	Strong
Complexity	Higher (service)	Lower (library)

When to Use

Scenario	Recommendation
Existing ZooKeeper	Use ZooKeeper
Need embedded	Use Raft library
Simple election	Redis lock
Strong consistency	ZooKeeper/Raft