CAP Theorem Explained Practically

import time
import asyncio
from typing import List, Optional

class CAPAwareService:
    def __init__(self, nodes: List[str], consistency_mode: str = 'CP'):
        self.nodes = nodes
        self.consistency_mode = consistency_mode  # 'CP' or 'AP'
        self.healthy_nodes = set(nodes)
        self.partition_threshold = len(nodes) // 2 + 1
        
    async def write_data(self, key: str, value: str) -> bool:
        if self.consistency_mode == 'CP':
            return await self._cp_write(key, value)
        else:
            return await self._ap_write(key, value)
            
    async def _cp_write(self, key: str, value: str) -> bool:
        """CP: Require majority of nodes to be healthy"""
        if len(self.healthy_nodes) < self.partition_threshold:
            raise PartitionException("Cannot maintain consistency during partition")
        
        # Write to majority of nodes synchronously
        successful_writes = 0
        for node in list(self.healthy_nodes)[:self.partition_threshold]:
            if await self._write_to_node(node, key, value):
                successful_writes += 1
                
        return successful_writes >= self.partition_threshold
        
    async def _ap_write(self, key: str, value: str) -> bool:
        """AP: Write to any available node"""
        for node in self.healthy_nodes:
            if await self._write_to_node(node, key, value):
                # Trigger async replication to other nodes
                asyncio.create_task(self._replicate_async(key, value, node))
                return True
        
        raise Exception("No healthy nodes available")
        
    async def _write_to_node(self, node: str, key: str, value: str) -> bool:
        try:
            # Simulate network call with timeout
            await asyncio.wait_for(
                self._network_call(node, key, value), 
                timeout=1.0
            )
            return True
        except asyncio.TimeoutError:
            self.healthy_nodes.discard(node)
            return False
            
    async def _replicate_async(self, key: str, value: str, exclude_node: str):
        """Background replication for AP systems"""
        for node in self.healthy_nodes:
            if node != exclude_node:
                try:
                    await self._write_to_node(node, key, value)
                except:
                    pass  # Best effort replication