CAP Theorem & Consistency

-- Cassandra তে per-query consistency level configure করা যায়!
-- এটাই practical CAP flexibility

-- QUORUM: majority nodes (N/2+1) agree করলেন success
-- 3 nodes থাকলে QUORUM = 2 nodes agree করতে হবে
INSERT INTO accounts (id, balance)
VALUES (uuid(), 10000)
USING CONSISTENCY QUORUM;   -- Strong-ish, balanced

-- ONE: শুধু একটা node respond করলেনই success (fastest)
SELECT * FROM user_activity WHERE user_id = 101
CONSISTENCY ONE;            -- Fast, eventually consistent

-- ALL: সব nodes confirm করতে হবে (strongest, slowest)
UPDATE accounts SET balance = balance - 5000
WHERE account_id = 101
CONSISTENCY ALL;            -- Critical financial op

import asyncio, time, random

class Node:
    def __init__(self, node_id):
        self.node_id = node_id
        self.data = {}       # Local state
        self.peers = []

    async def write(self, key, value):
        # AP: Local write, async sync — fire and forget
        self.data[key] = {'value': value, 'ts': time.time()}
        print(f"[{self.node_id}] Wrote {key}={value} (local)")
        asyncio.create_task(self._propagate(key))  # Async!

    async def read(self, key):
        # May return stale data!
        entry = self.data.get(key)
        val = entry['value'] if entry else None
        print(f"[{self.node_id}] Read {key}={val}")
        return val

    async def _propagate(self, key):
        # Simulate network delay (0.5-3 seconds)
        await asyncio.sleep(random.uniform(0.5, 3.0))
        for peer in self.peers:
            await peer._sync(key, self.data[key])

    async def _sync(self, key, entry):
        # Last-Write-Wins conflict resolution
        existing = self.data.get(key)
        if not existing or existing['ts'] < entry['ts']:
            self.data[key] = entry
            print(f"[{self.node_id}] Synced {key}={entry['value']}")

async def demo():
    a, b = Node("A"), Node("B")
    a.peers = [b]; b.peers = [a]

    await a.write("likes", 100)
    await b.read("likes")    # None! Not synced yet
    await asyncio.sleep(4)  # Wait for propagation
    await b.read("likes")    # 100 — eventually consistent!

asyncio.run(demo())