Load Balancing

upstream backend {
    # Least connections algorithm
    least_conn;

    # Weighted servers — server1 বেশি powerful
    server 192.168.1.10:3000 weight=3;
    server 192.168.1.11:3000 weight=1;
    server 192.168.1.12:3000 weight=1;

    # Health check settings
    # max_fails: এতবার fail হলে server বাদ দিন
    # fail_timeout: এই সময়ের মধ্যে fail হলে count করুন
    server 192.168.1.13:3000 max_fails=3 fail_timeout=30s;
}

server {
    listen 80;

    location / {
        proxy_pass http://backend;
        proxy_connect_timeout 5s;
        proxy_read_timeout 30s;

        # Health check endpoint
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    # Active health check (Nginx Plus feature)
    # location /health {
    #     health_check interval=5s fails=3 passes=2;
    # }
}

import itertools
import requests
import threading
import time

class RoundRobinLoadBalancer:
    def __init__(self, servers: list[str]):
        self.servers = servers
        self.healthy_servers = list(servers)
        self._cycle = itertools.cycle(self.healthy_servers)
        self._lock = threading.Lock()

    def get_next_server(self) -> str | None:
        """Round Robin: পরবর্তী healthy server return করুন"""
        with self._lock:
            if not self.healthy_servers:
                return None  # সব server down!
            return next(self._cycle)

    def health_check(self):
        """প্রতি 5 সেকেন্ডে সব server check করুন"""
        while True:
            for server in self.servers:
                try:
                    response = requests.get(f"{server}/health", timeout=2)
                    if response.status_code == 200:
                        if server not in self.healthy_servers:
                            self.healthy_servers.append(server)
                            self._cycle = itertools.cycle(self.healthy_servers)
                            print(f"✅ {server} back online")
                except Exception:
                    if server in self.healthy_servers:
                        self.healthy_servers.remove(server)
                        self._cycle = itertools.cycle(self.healthy_servers)
                        print(f"❌ {server} removed — unhealthy")
            time.sleep(5)

    def forward_request(self, request_data: dict) -> dict:
        """Request কে next available server এ forward করুন"""
        server = self.get_next_server()
        if not server:
            return {"error": "No healthy servers available", "status": 503}
        try:
            response = requests.post(f"{server}/handle", json=request_data, timeout=10)
            return response.json()
        except Exception as e:
            return {"error": str(e), "status": 500}


# Usage
lb = RoundRobinLoadBalancer([
    "http://server1:3000",
    "http://server2:3000",
    "http://server3:3000",
])

# Background এ health check চালাও
health_thread = threading.Thread(target=lb.health_check, daemon=True)
health_thread.start()

# Request handle করুন
result = lb.forward_request({"user_id": 123, "action": "get_profile"})

class LeastConnectionsLB {
    constructor(servers) {
        // প্রতিটা server এর active connection count track করুন
        this.servers = servers.map(server => ({
            url: server,
            connections: 0,
            healthy: true,
        }));
    }

    getServer() {
        // শুধু healthy servers এর মধ্যে least connections ওয়ালাটা নাও
        const healthyServers = this.servers.filter(s => s.healthy);

        if (healthyServers.length === 0) {
            throw new Error('No healthy servers available');
        }

        // Least connections server খুঁজুন
        return healthyServers.reduce((min, server) =>
            server.connections < min.connections ? server : min
        );
    }

    async handleRequest(requestData) {
        const server = this.getServer();

        // Connection শুরু হলে count বাড়াও
        server.connections++;
        console.log(`Routing to ${server.url} (connections: ${server.connections})`);

        try {
            const response = await fetch(`${server.url}/handle`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData),
            });
            return await response.json();
        } finally {
            // Request শেষ হলে count কমাও (success বা fail উভয় ক্ষেত্রে)
            server.connections--;
        }
    }

    markUnhealthy(serverUrl) {
        const server = this.servers.find(s => s.url === serverUrl);
        if (server) {
            server.healthy = false;
            console.log(`❌ ${serverUrl} marked as unhealthy`);
        }
    }

    markHealthy(serverUrl) {
        const server = this.servers.find(s => s.url === serverUrl);
        if (server) {
            server.healthy = true;
            server.connections = 0;
            console.log(`✅ ${serverUrl} back online`);
        }
    }
}

// Usage
const lb = new LeastConnectionsLB([
    'http://server1:3000',
    'http://server2:3000',
    'http://server3:3000',
]);

// Multiple concurrent requests — সবচেয়ে কম busy server পাবেন প্রতিটা
Promise.all([
    lb.handleRequest({ userId: 1 }),
    lb.handleRequest({ userId: 2 }),
    lb.handleRequest({ userId: 3 }),
]).then(results => console.log('All done:', results));