Distributed Consensus & Coordination

import random
import time
from enum import Enum

class NodeState(Enum):
    FOLLOWER = "follower"
    CANDIDATE = "candidate"
    LEADER = "leader"

class RaftNode:
    def __init__(self, node_id, cluster_size):
        self.node_id = node_id
        self.state = NodeState.FOLLOWER
        self.current_term = 0
        self.voted_for = None
        self.log = []  # List of (term, value) tuples
        self.commit_index = -1
        self.cluster_size = cluster_size
        self.votes_received = 0

    def start_election(self):
        """Follower timeout হলে election শুরু করে"""
        self.state = NodeState.CANDIDATE
        self.current_term += 1
        self.voted_for = self.node_id  # নিজেকে vote
        self.votes_received = 1
        print(f"Node {self.node_id}: Starting election for term {self.current_term}")

    def receive_vote(self, from_node, term, vote_granted):
        if term == self.current_term and self.state == NodeState.CANDIDATE:
            if vote_granted:
                self.votes_received += 1
                quorum = (self.cluster_size // 2) + 1
                if self.votes_received >= quorum:
                    self.become_leader()

    def become_leader(self):
        self.state = NodeState.LEADER
        print(f"✅ Node {self.node_id}: Became LEADER for term {self.current_term}")
        print(f"   Votes: {self.votes_received}/{self.cluster_size}")

    def append_entry(self, value):
        """Leader শুধু এটা call করতে পারে"""
        if self.state != NodeState.LEADER:
            raise Exception("Only leader can append entries")
        self.log.append((self.current_term, value))
        print(f"Leader Node {self.node_id}: Appended '{value}' to log")

# Simulation
nodes = [RaftNode(i, 5) for i in range(5)]

# Node 2 starts election
nodes[2].start_election()

# 3 nodes vote yes (quorum = 3/5)
nodes[2].receive_vote(0, 1, True)
nodes[2].receive_vote(1, 1, True)
nodes[2].receive_vote(3, 1, True)  # This triggers becoming leader

# Leader now writes
nodes[2].append_entry("balance=10000")
nodes[2].append_entry("transfer=5000")

// npm install etcd3
const { Etcd3 } = require('etcd3');

const client = new Etcd3({ hosts: 'localhost:2379' });

async function processOrderWithLock(orderId) {
    // Distributed lock — শুধু একটা server এই order process করবেন
    const lock = client.lock(`order/${orderId}`);

    try {
        await lock.acquire();
        console.log(`🔒 Lock acquired for order ${orderId}`);

        // Critical section — duplicate processing impossible
        const existing = await client.get(`processed/${orderId}`);
        if (existing) {
            console.log(`⚠️ Order ${orderId} already processed!`);
            return;
        }

        // Process the order
        console.log(`✅ Processing order ${orderId}...`);
        await new Promise(resolve => setTimeout(resolve, 1000));

        // Mark as processed
        await client.put(`processed/${orderId}`).value('true');
        console.log(`🎉 Order ${orderId} processed successfully!`);

    } finally {
        await lock.release();
        console.log(`🔓 Lock released for order ${orderId}`);
    }
}

// Multiple services try to process same order simultaneously
// Only ONE will succeed due to distributed lock
Promise.all([
    processOrderWithLock('order-123'),
    processOrderWithLock('order-123'),  // Duplicate — will be blocked
    processOrderWithLock('order-123'),  // Duplicate — will be blocked
]);