Files
skills/public/distributed-systems-cap-theorem.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
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]>
2026-09-11 00:27:59 -07:00

475 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-cap-theorem</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-cap-theorem.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/distributed-systems-cap-theorem">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/distributed-systems-cap-theorem.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-cap-theorem</h1><p class="lede">CAP theorem fundamentals, consistency vs availability trade-offs, and practical implications for distributed system design</p><h1>CAP Theorem</h1>
<p><strong>Scope</strong>: CAP theorem, consistency-availability trade-offs, partition tolerance, system design implications <strong>Lines</strong>: ~290 <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>Designing distributed systems</li><li>Choosing databases (SQL vs NoSQL)</li><li>Understanding system trade-offs</li><li>Planning for network partitions</li><li>Evaluating consistency models</li><li>Selecting replication strategies</li><li>Making architecture decisions</li><li>Troubleshooting distributed system issues</li></ul>
<h2>Core Concepts</h2>
<h3>The CAP Theorem</h3>
<p><strong>Statement</strong>: In a distributed system, you can only guarantee <strong>two</strong> of three properties:</p>
<pre><code>C = Consistency
All nodes see the same data at the same time
A = Availability
Every request receives a response (success or failure)
P = Partition Tolerance
System continues despite network partitions</code></pre>
<p><strong>Reality</strong>: Network partitions <strong>will</strong> happen, so you must choose between:</p>
<ul><li><strong>CP</strong>: Consistency + Partition Tolerance (sacrifice availability)</li><li><strong>AP</strong>: Availability + Partition Tolerance (sacrifice consistency)</li></ul>
<h3>Why CAP?</h3>
<p><strong>Proof sketch</strong>:</p>
<pre><code>Given:
- Network partition splits nodes into two groups
- Client writes to one side
- Client reads from other side
If Consistent (C):
→ Must wait for partition to heal
→ System unavailable (violates A)
If Available (A):
→ Return potentially stale data
→ Not consistent (violates C)
Cannot have both C and A during partition (P)</code></pre>
<hr>
<h2>Consistency vs Availability</h2>
<h3>CP Systems (Consistency + Partition Tolerance)</h3>
<p><strong>Behavior during partition</strong>: Reject requests to maintain consistency</p>
<p><strong>Examples</strong>:</p>
<ul><li>Etcd (used by Kubernetes)</li><li>Consul</li><li>ZooKeeper</li><li>HBase</li><li>MongoDB (with majority writes)</li><li>Traditional SQL databases</li></ul>
<p><strong>When to choose</strong>:</p>
<ul><li>Financial transactions</li><li>Inventory management</li><li>Configuration management</li><li>Leader election</li><li>Distributed locks</li></ul>
<p><strong>Example</strong>:</p>
<pre><code class="lang-python"># CP system: Returns error if can&#x27;t guarantee consistency
try:
balance = bank_db.get_balance(account_id)
if balance &gt;= amount:
bank_db.withdraw(account_id, amount) # Blocks during partition
except ConsistencyError:
return &quot;Service temporarily unavailable&quot; # Better than wrong data</code></pre>
<h3>AP Systems (Availability + Partition Tolerance)</h3>
<p><strong>Behavior during partition</strong>: Always respond, may return stale data</p>
<p><strong>Examples</strong>:</p>
<ul><li>Cassandra</li><li>DynamoDB</li><li>Riak</li><li>CouchDB</li><li>DNS</li><li>Caching systems</li></ul>
<p><strong>When to choose</strong>:</p>
<ul><li>Social media feeds</li><li>Product catalogs</li><li>Analytics data</li><li>Logging systems</li><li>Caching layers</li><li>Content delivery</li></ul>
<p><strong>Example</strong>:</p>
<pre><code class="lang-python"># AP system: Always returns data, may be stale
user_profile = cache.get(user_id) # Returns even if stale
if user_profile is None:
user_profile = eventual_consistency_db.get(user_id) # Best effort</code></pre>
<hr>
<h2>Real-World Considerations</h2>
<h3>PACELC Extension</h3>
<p><strong>CAP is incomplete</strong>: Only describes behavior <strong>during</strong> partitions</p>
<p><strong>PACELC</strong> adds:</p>
<pre><code>If Partition (P):
Choose between Availability (A) and Consistency (C)
Else (E):
Choose between Latency (L) and Consistency (C)
Full framework:
- PA/EL: Prioritize availability and low latency (Cassandra)
- PA/EC: Prioritize availability, then consistency (DynamoDB)
- PC/EL: Prioritize consistency, then low latency (MongoDB)
- PC/EC: Prioritize consistency (traditional RDBMS)</code></pre>
<h3>Consistency Spectrum</h3>
<p><strong>Not binary</strong>:</p>
<pre><code>Strong Consistency (CP)
├─ Linearizability
├─ Sequential Consistency
└─ Causal Consistency
Eventual Consistency (AP)
├─ Read Your Writes
├─ Monotonic Reads
└─ Eventual</code></pre>
<hr>
<h2>System Examples</h2>
<h3>Example 1: Social Media Feed (AP)</h3>
<pre><code class="lang-python">class SocialMediaFeed:
&quot;&quot;&quot;AP system: Always available, eventually consistent&quot;&quot;&quot;
def post_update(self, user_id, content):
# Write to multiple regions asynchronously
for region in self.regions:
region.write_async(user_id, content) # Don&#x27;t wait
return {&quot;status&quot;: &quot;posted&quot;} # Immediate response
def get_feed(self, user_id):
# Read from nearest region
region = self.get_nearest_region()
posts = region.read(user_id) # May be slightly stale
return posts # Always returns something</code></pre>
<p><strong>Trade-off</strong>: User might not see their post immediately on different device (eventual consistency), but system is always available.</p>
<h3>Example 2: Bank Account (CP)</h3>
<pre><code class="lang-python">class BankAccount:
&quot;&quot;&quot;CP system: Strongly consistent, may be unavailable&quot;&quot;&quot;
def transfer(self, from_account, to_account, amount):
# Distributed transaction with 2PC
transaction = self.begin_transaction()
try:
# Both operations must succeed or both fail
transaction.debit(from_account, amount)
transaction.credit(to_account, amount)
transaction.commit() # Blocks until confirmed on all nodes
return {&quot;status&quot;: &quot;success&quot;}
except PartitionError:
transaction.rollback()
raise ServiceUnavailableError(&quot;Cannot guarantee consistency&quot;)
def get_balance(self, account_id):
# Read from majority quorum
return self.read_with_quorum(account_id) # Blocks if partition</code></pre>
<p><strong>Trade-off</strong>: System may become unavailable during network issues, but data is always correct.</p>
<h3>Example 3: Hybrid Approach</h3>
<pre><code class="lang-python">class HybridSystem:
&quot;&quot;&quot;Different consistency for different data&quot;&quot;&quot;
def write_user_profile(self, user_id, profile):
# AP: Profile updates can be eventually consistent
self.ap_store.write_async(user_id, profile)
return {&quot;status&quot;: &quot;updated&quot;}
def charge_payment(self, user_id, amount):
# CP: Payments must be strongly consistent
try:
result = self.cp_store.transaction(user_id, amount)
return {&quot;status&quot;: &quot;charged&quot;}
except PartitionError:
return {&quot;status&quot;: &quot;unavailable&quot;, &quot;retry&quot;: True}</code></pre>
<hr>
<h2>Database Classification</h2>
<h3>CP Databases</h3>
<pre><code>MongoDB (w=majority):
- Consistent reads from primary
- Blocks during partition
- Use for: Transactions, inventory
Etcd/Consul:
- Raft consensus
- Strong consistency
- Use for: Configuration, service discovery
HBase:
- Single master, consistent regions
- May be unavailable during failures
- Use for: Time-series, analytics requiring consistency</code></pre>
<h3>AP Databases</h3>
<pre><code>Cassandra:
- Tunable consistency (default AP)
- Eventually consistent
- Use for: Time-series, logging, IoT
DynamoDB:
- Eventually consistent reads (default)
- Strongly consistent reads (optional, higher latency)
- Use for: User profiles, session data
Riak:
- Eventual consistency
- High availability
- Use for: Content storage, caching</code></pre>
<hr>
<h2>Tunable Consistency</h2>
<h3>Cassandra Example</h3>
<pre><code class="lang-python">from cassandra.cluster import Cluster
from cassandra.query import SimpleStatement
from cassandra import ConsistencyLevel
cluster = Cluster([&#x27;node1&#x27;, &#x27;node2&#x27;, &#x27;node3&#x27;])
session = cluster.connect(&#x27;my_keyspace&#x27;)
# AP: Eventually consistent (fast)
statement = SimpleStatement(
&quot;SELECT * FROM users WHERE user_id = %s&quot;,
consistency_level=ConsistencyLevel.ONE # Read from any single node
)
# CP: Strongly consistent (slower)
statement = SimpleStatement(
&quot;SELECT * FROM users WHERE user_id = %s&quot;,
consistency_level=ConsistencyLevel.QUORUM # Read from majority
)
# Per-query choice based on use case</code></pre>
<hr>
<h2>Decision Framework</h2>
<h3>Choose CP When:</h3>
<pre><code>✅ Correctness is critical (financial, inventory)
✅ Can tolerate downtime
✅ Data conflicts must be prevented
✅ Transactions required
✅ Regulated industry (banking, healthcare)</code></pre>
<h3>Choose AP When:</h3>
<pre><code>✅ Availability is critical (user-facing)
✅ Can tolerate stale reads
✅ Conflicts can be resolved later
✅ High write throughput needed
✅ Global distribution required</code></pre>
<hr>
<h2>Common Misconceptions</h2>
<h3>Misconception 1: &quot;CAP means pick 2 of 3&quot;</h3>
<p><strong>Wrong</strong>: Network partitions happen, so it&#x27;s really &quot;CP or AP&quot;</p>
<p><strong>Correct</strong>: Choose consistency or availability <strong>during</strong> partitions</p>
<h3>Misconception 2: &quot;NoSQL = AP, SQL = CP&quot;</h3>
<p><strong>Wrong</strong>: Many NoSQL databases offer tunable consistency</p>
<p><strong>Examples</strong>:</p>
<ul><li>Cassandra: Can be CP with QUORUM consistency</li><li>MongoDB: Can be AP with w=1 writes</li><li>PostgreSQL: Can be AP with async replication</li></ul>
<h3>Misconception 3: &quot;AP means no consistency&quot;</h3>
<p><strong>Wrong</strong>: AP means eventual consistency, not no consistency</p>
<p><strong>Clarification</strong>: Updates propagate to all nodes, just not immediately</p>
<hr>
<h2>Testing CAP Properties</h2>
<h3>Partition Simulation</h3>
<pre><code class="lang-python">import subprocess
import time
def simulate_partition(node_ips):
&quot;&quot;&quot;Block network traffic between nodes&quot;&quot;&quot;
for ip in node_ips:
subprocess.run([
&#x27;iptables&#x27;, &#x27;-A&#x27;, &#x27;INPUT&#x27;, &#x27;-s&#x27;, ip, &#x27;-j&#x27;, &#x27;DROP&#x27;
])
def test_ap_system():
&quot;&quot;&quot;Test that system remains available during partition&quot;&quot;&quot;
simulate_partition([&#x27;192.168.1.2&#x27;])
# Should still respond (maybe stale)
response = api.get(&#x27;/data&#x27;)
assert response.status_code == 200 # Available
def test_cp_system():
&quot;&quot;&quot;Test that system maintains consistency during partition&quot;&quot;&quot;
simulate_partition([&#x27;192.168.1.2&#x27;])
# Should refuse to serve potentially inconsistent data
response = api.get(&#x27;/data&#x27;)
assert response.status_code in [503, 500] # Unavailable but consistent</code></pre>
<hr>
<h2>Related Skills</h2>
<ul><li><code>distributed-systems-eventual-consistency</code> - Consistency models</li><li><code>distributed-systems-replication-strategies</code> - Data replication</li><li><code>distributed-systems-consensus-raft</code> - Consensus algorithms</li><li><code>distributed-systems-conflict-resolution</code> - Handling conflicts</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-cap-theorem.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>