mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
544 lines
24 KiB
HTML
544 lines
24 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>distributed-systems-leader-election</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/distributed-systems-leader-election.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/distributed-systems-leader-election">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/distributed-systems-leader-election.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>distributed-systems-leader-election</h1><p class="lede">Leader election algorithms including bully algorithm, ring algorithm, and consensus-based election with RAFT/Paxos</p><h1>Leader Election</h1>
|
|
<p><strong>Scope</strong>: Leader election algorithms, bully, ring, consensus-based, practical implementations <strong>Lines</strong>: ~220 <strong>Last Updated</strong>: 2025-10-27 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<hr>
|
|
<h2>When to Use This Skill</h2>
|
|
<p>Activate this skill when:</p>
|
|
<ul><li>Coordinating distributed services</li><li>Implementing active-passive failover</li><li>Building distributed databases</li><li>Managing cluster coordination</li><li>Implementing job schedulers</li><li>Understanding etcd, ZooKeeper patterns</li><li>Handling failover scenarios</li><li>Building high-availability systems</li></ul>
|
|
<h2>Core Concepts</h2>
|
|
<h3>Why Leader Election?</h3>
|
|
<pre><code>Problem: Who coordinates distributed operations?
|
|
|
|
Solutions requiring leader:
|
|
- Single point for writes (primary-backup)
|
|
- Job scheduling (avoid duplicate work)
|
|
- Configuration management
|
|
- Distributed transactions coordination</code></pre>
|
|
<h3>Properties</h3>
|
|
<pre><code>Safety: At most one leader at a time
|
|
Liveness: Eventually elects leader
|
|
Termination: Election completes in finite time</code></pre>
|
|
<hr>
|
|
<h2>Election Algorithms</h2>
|
|
<h3>1. Bully Algorithm</h3>
|
|
<p><strong>Approach</strong>: Highest ID becomes leader</p>
|
|
<pre><code class="lang-python">import time
|
|
import threading
|
|
|
|
class BullyElection:
|
|
"""Bully algorithm for leader election"""
|
|
|
|
def __init__(self, node_id, all_nodes):
|
|
self.node_id = node_id
|
|
self.all_nodes = sorted(all_nodes)
|
|
self.leader = None
|
|
self.is_leader = False
|
|
|
|
def start_election(self):
|
|
"""Initiate election"""
|
|
print(f"Node {self.node_id} starting election")
|
|
|
|
# Send ELECTION message to higher IDs
|
|
higher_nodes = [n for n in self.all_nodes if n > self.node_id]
|
|
|
|
if not higher_nodes:
|
|
# No higher nodes - I'm the leader
|
|
self.become_leader()
|
|
return
|
|
|
|
# Wait for responses from higher nodes
|
|
responses = []
|
|
for node in higher_nodes:
|
|
response = self.send_election_message(node)
|
|
if response:
|
|
responses.append(node)
|
|
|
|
if responses:
|
|
# Higher node responded - they'll handle election
|
|
pass
|
|
else:
|
|
# No higher nodes responded - I'm the leader
|
|
self.become_leader()
|
|
|
|
def become_leader(self):
|
|
"""Declare self as leader"""
|
|
self.is_leader = True
|
|
self.leader = self.node_id
|
|
print(f"Node {self.node_id} is now LEADER")
|
|
|
|
# Broadcast COORDINATOR message to all lower nodes
|
|
for node in self.all_nodes:
|
|
if node < self.node_id:
|
|
self.send_coordinator_message(node)
|
|
|
|
def on_election_message(self, sender_id):
|
|
"""Handle ELECTION message from lower node"""
|
|
if sender_id < self.node_id:
|
|
# Respond OK and start own election
|
|
self.start_election()
|
|
return "OK"
|
|
|
|
return None
|
|
|
|
def on_coordinator_message(self, leader_id):
|
|
"""Handle COORDINATOR message"""
|
|
self.leader = leader_id
|
|
self.is_leader = False
|
|
print(f"Node {self.node_id} acknowledges {leader_id} as leader")
|
|
|
|
# Simulation
|
|
nodes = [BullyElection(i, [1, 2, 3, 4, 5]) for i in range(1, 6)]
|
|
|
|
# Node 3 starts election
|
|
nodes[2].start_election() # Node 5 becomes leader
|
|
|
|
# Node 5 crashes, Node 4 detects and starts election
|
|
nodes[3].start_election() # Node 4 becomes leader</code></pre>
|
|
<p><strong>Pros</strong>: Simple, eventually elects highest ID <strong>Cons</strong>: Many messages, not fault-tolerant during election</p>
|
|
<h3>2. Ring Algorithm</h3>
|
|
<p><strong>Approach</strong>: Pass election message around ring</p>
|
|
<pre><code class="lang-python">class RingElection:
|
|
"""Ring-based leader election"""
|
|
|
|
def __init__(self, node_id, next_node):
|
|
self.node_id = node_id
|
|
self.next_node = next_node # Next node in ring
|
|
self.leader = None
|
|
self.participating = False
|
|
|
|
def start_election(self):
|
|
"""Start election by sending message with own ID"""
|
|
self.participating = True
|
|
self.send_election_message([self.node_id])
|
|
|
|
def on_election_message(self, id_list):
|
|
"""Handle election message"""
|
|
if self.node_id in id_list:
|
|
# Message completed circle - elect leader
|
|
leader_id = max(id_list)
|
|
self.announce_leader(leader_id)
|
|
else:
|
|
# Add self and forward
|
|
id_list.append(self.node_id)
|
|
self.send_election_message(id_list)
|
|
|
|
def announce_leader(self, leader_id):
|
|
"""Announce elected leader"""
|
|
self.leader = leader_id
|
|
self.send_coordinator_message(leader_id)
|
|
|
|
def on_coordinator_message(self, leader_id):
|
|
"""Acknowledge leader"""
|
|
self.leader = leader_id
|
|
|
|
# Forward if not completed circle
|
|
if not self.participating:
|
|
self.send_coordinator_message(leader_id)
|
|
else:
|
|
self.participating = False</code></pre>
|
|
<p><strong>Pros</strong>: Fewer messages than bully <strong>Cons</strong>: Slow if ring is large, depends on ring structure</p>
|
|
<h3>3. Consensus-Based (RAFT, ZooKeeper)</h3>
|
|
<pre><code class="lang-python"># Using etcd (RAFT-based)
|
|
import etcd3
|
|
import time
|
|
|
|
class ConsensusLeaderElection:
|
|
"""Leader election using etcd"""
|
|
|
|
def __init__(self, node_id):
|
|
self.node_id = node_id
|
|
self.etcd = etcd3.client()
|
|
self.lease = None
|
|
self.is_leader = False
|
|
|
|
def campaign(self):
|
|
"""Attempt to become leader"""
|
|
# Create lease
|
|
self.lease = self.etcd.lease(ttl=60)
|
|
|
|
# Try to create leader key with our ID
|
|
success, _ = self.etcd.transaction(
|
|
compare=[
|
|
self.etcd.transactions.version('/leader') == 0
|
|
],
|
|
success=[
|
|
self.etcd.transactions.put('/leader', self.node_id, lease=self.lease)
|
|
],
|
|
failure=[]
|
|
)
|
|
|
|
if success:
|
|
self.is_leader = True
|
|
self._start_keepalive()
|
|
return True
|
|
|
|
return False
|
|
|
|
def _start_keepalive(self):
|
|
"""Keep lease alive"""
|
|
def keepalive_loop():
|
|
while self.is_leader:
|
|
self.lease.refresh()
|
|
time.sleep(20)
|
|
|
|
threading.Thread(target=keepalive_loop, daemon=True).start()
|
|
|
|
def resign(self):
|
|
"""Resign from leadership"""
|
|
if self.is_leader and self.lease:
|
|
self.lease.revoke()
|
|
self.is_leader = False
|
|
|
|
def watch_leader(self, callback):
|
|
"""Watch for leader changes"""
|
|
watch_id = self.etcd.add_watch_callback('/leader', callback)
|
|
return watch_id
|
|
|
|
# Usage
|
|
election = ConsensusLeaderElection('node1')
|
|
|
|
if election.campaign():
|
|
print("I am the leader!")
|
|
try:
|
|
# Do leader work
|
|
while True:
|
|
lead()
|
|
time.sleep(1)
|
|
except KeyboardInterrupt:
|
|
election.resign()
|
|
else:
|
|
# Watch for leader changes
|
|
election.watch_leader(lambda event: print(f"New leader: {event.value}"))</code></pre>
|
|
<hr>
|
|
<h2>Split-Brain Prevention</h2>
|
|
<h3>Problem</h3>
|
|
<pre><code>Network partition:
|
|
[Node A] | [Node B, C]
|
|
|
|
Both sides elect leader → Two leaders!</code></pre>
|
|
<h3>Solution: Quorum</h3>
|
|
<pre><code class="lang-python">class QuorumElection:
|
|
"""Elect leader only with majority quorum"""
|
|
|
|
def __init__(self, node_id, all_nodes):
|
|
self.node_id = node_id
|
|
self.all_nodes = all_nodes
|
|
self.quorum_size = len(all_nodes) // 2 + 1
|
|
|
|
def campaign(self):
|
|
"""Campaign with quorum requirement"""
|
|
votes = {self.node_id} # Vote for self
|
|
|
|
# Request votes from others
|
|
for node in self.all_nodes:
|
|
if node != self.node_id:
|
|
if self.request_vote(node):
|
|
votes.add(node)
|
|
|
|
# Become leader only if quorum
|
|
if len(votes) >= self.quorum_size:
|
|
self.become_leader()
|
|
return True
|
|
|
|
return False
|
|
|
|
# Guarantees at most one leader per term</code></pre>
|
|
<hr>
|
|
<h2>Practical Patterns</h2>
|
|
<h3>Pattern 1: Active-Passive Failover</h3>
|
|
<pre><code class="lang-python">class ActivePassiveService:
|
|
"""Service with leader election"""
|
|
|
|
def __init__(self, node_id):
|
|
self.node_id = node_id
|
|
self.election = ConsensusLeaderElection(node_id)
|
|
|
|
def run(self):
|
|
"""Run service with leadership"""
|
|
while True:
|
|
if self.election.campaign():
|
|
# I'm the leader - do active work
|
|
self.do_leader_work()
|
|
else:
|
|
# I'm a follower - standby
|
|
self.do_follower_work()
|
|
|
|
def do_leader_work(self):
|
|
"""Active work (only leader)"""
|
|
while self.election.is_leader:
|
|
process_jobs()
|
|
time.sleep(1)
|
|
|
|
def do_follower_work(self):
|
|
"""Passive work (followers)"""
|
|
time.sleep(5) # Wait for potential leadership</code></pre>
|
|
<h3>Pattern 2: Distributed Cron</h3>
|
|
<pre><code class="lang-python">class DistributedCron:
|
|
"""Only leader executes scheduled jobs"""
|
|
|
|
def __init__(self, node_id, schedule):
|
|
self.election = ConsensusLeaderElection(node_id)
|
|
self.schedule = schedule
|
|
|
|
def run(self):
|
|
while True:
|
|
if self.election.is_leader:
|
|
for job in self.schedule.due_jobs():
|
|
self.execute(job)
|
|
|
|
time.sleep(1)
|
|
|
|
def execute(self, job):
|
|
"""Execute job (leader only)"""
|
|
print(f"Leader executing: {job}")
|
|
job.run()</code></pre>
|
|
<hr>
|
|
<h2>Best Practices</h2>
|
|
<h3>1. Use Fencing Tokens</h3>
|
|
<pre><code class="lang-python"># Leader includes generation/term number
|
|
class FencedLeader:
|
|
def __init__(self):
|
|
self.generation = 0
|
|
|
|
def become_leader(self):
|
|
self.generation += 1
|
|
return self.generation
|
|
|
|
def perform_action(self, action, generation):
|
|
"""Resource validates generation"""
|
|
if generation < self.last_generation:
|
|
raise StaleLeaderError()</code></pre>
|
|
<h3>2. Handle Leadership Loss</h3>
|
|
<pre><code class="lang-python">class GracefulLeader:
|
|
def do_leader_work(self):
|
|
while self.is_leader:
|
|
try:
|
|
work()
|
|
except LeadershipLostError:
|
|
self.cleanup()
|
|
break</code></pre>
|
|
<h3>3. Lease-Based Leadership</h3>
|
|
<pre><code class="lang-python"># Lease expires if leader crashes
|
|
# Prevents indefinite wait for crashed leader</code></pre>
|
|
<hr>
|
|
<h2>Related Skills</h2>
|
|
<ul><li><code>distributed-systems-consensus-raft</code> - RAFT consensus</li><li><code>distributed-systems-distributed-locks</code> - Distributed locking</li><li><code>distributed-systems-eventual-consistency</code> - Consistency models</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-27</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/distributed-systems-leader-election.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |