Load Balancing

1// ============================================
2// Load Balancing — Algorithm Implementations
3// ============================================
4
5// ---------- Round Robin ----------
6class RoundRobinBalancer {
7  constructor(servers) {
8    this.servers = servers;
9    this.currentIndex = 0;
10  }
11
12  getServer() {
13    const server = this.servers[this.currentIndex];
14    this.currentIndex = (this.currentIndex + 1) % this.servers.length;
15    return server;
16  }
17}
18
19// ---------- Weighted Round Robin ----------
20class WeightedRoundRobin {
21  constructor(servers) {
22    this.servers = servers; // [{host, weight}]
23    this.currentIndex = 0;
24    this.currentWeight = 0;
25    this.maxWeight = Math.max(...servers.map(s => s.weight));
26    this.gcd = this.calculateGCD();
27  }
28
29  getServer() {
30    while (true) {
31      this.currentIndex = (this.currentIndex + 1) % this.servers.length;
32      if (this.currentIndex === 0) {
33        this.currentWeight -= this.gcd;
34        if (this.currentWeight <= 0) this.currentWeight = this.maxWeight;
35      }
36      if (this.servers[this.currentIndex].weight >= this.currentWeight) {
37        return this.servers[this.currentIndex];
38      }
39    }
40  }
41
42  calculateGCD() {
43    const weights = this.servers.map(s => s.weight);
44    return weights.reduce((a, b) => {
45      while (b) { [a, b] = [b, a % b]; }
46      return a;
47    });
48  }
49}
50
51// ---------- Least Connections ----------
52class LeastConnectionsBalancer {
53  constructor(servers) {
54    this.servers = servers.map(s => ({ ...s, connections: 0 }));
55  }
56
57  getServer() {
58    const server = this.servers.reduce((min, s) =>
59      s.connections < min.connections ? s : min
60    );
61    server.connections++;
62    return server;
63  }
64
65  releaseConnection(server) {
66    server.connections = Math.max(0, server.connections - 1);
67  }
68}
69
70// ---------- Health-Checked Load Balancer ----------
71class HealthCheckedLB {
72  constructor(servers, healthCheckInterval = 5000) {
73    this.servers = servers.map(s => ({ ...s, healthy: true, failCount: 0 }));
74    this.balancer = new RoundRobinBalancer(this.getHealthyServers());
75    setInterval(() => this.runHealthChecks(), healthCheckInterval);
76  }
77
78  getHealthyServers() {
79    return this.servers.filter(s => s.healthy);
80  }
81
82  async runHealthChecks() {
83    for (const server of this.servers) {
84      try {
85        const res = await fetch(`http://\${server.host}/health`, { timeout: 2000 });
86        if (res.ok) {
87          server.failCount = 0;
88          if (!server.healthy) {
89            server.healthy = true;
90            console.log(`✅ \${server.host} is back HEALTHY`);
91          }
92        } else { throw new Error('Unhealthy'); }
93      } catch (e) {
94        server.failCount++;
95        if (server.failCount >= 3 && server.healthy) {
96          server.healthy = false;
97          console.log(`❌ \${server.host} marked UNHEALTHY`);
98        }
99      }
100    }
101    this.balancer = new RoundRobinBalancer(this.getHealthyServers());
102  }
103
104  route() { return this.balancer.getServer(); }
105}
106
107// Demo
108const rr = new RoundRobinBalancer(['server-1', 'server-2', 'server-3']);
109console.log([1,2,3,4,5,6].map(() => rr.getServer()));
110
111const wrr = new WeightedRoundRobin([
112  { host: 'big-server', weight: 5 },
113  { host: 'small-server', weight: 1 },
114]);
115const counts = {};
116for (let i = 0; i < 60; i++) {
117  const s = wrr.getServer().host;
118  counts[s] = (counts[s] || 0) + 1;
119}
120console.log('Weighted distribution:', counts);