aetherframework-cluster 1.0.0

package/src/core/LoadBalancer.js

@@ -0,0 +1,531 @@
+// packages/cluster/src/core/LoadBalancer.js
+import { EventEmitter } from 'events';
+
+/**
+ * Load Balancer - Distributes requests across worker processes
+ * Supports multiple load balancing algorithms: round-robin, least-connections, ip-hash, weighted
+ */
+class LoadBalancer extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      algorithm: options.algorithm || 'round-robin', // round-robin, least-connections, ip-hash, weighted
+      stickySessions: options.stickySessions || false,
+      sessionTimeout: options.sessionTimeout || 30000, // 30 seconds
+      maxConnectionsPerWorker: options.maxConnectionsPerWorker || 1000,
+      healthCheckInterval: options.healthCheckInterval || 10000, // 10 seconds
+      ...options
+    };
+    
+    this.workers = new Map();
+    this.connections = new Map();
+    this.currentIndex = 0;
+    this.sessionMap = new Map();
+    this.healthCheckInterval = null;
+    this.workerWeights = new Map();
+  }
+  
+  /**
+   * Add a worker to the load balancer
+   * @param {number} pid - Process ID
+   * @param {Object} options - Worker options
+   * @returns {Object} Worker object
+   */
+  addWorker(pid, options = {}) {
+    const worker = {
+      pid,
+      weight: options.weight || 1,
+      connections: 0,
+      isHealthy: true,
+      lastHealthCheck: Date.now(),
+      addedAt: Date.now(),
+      metadata: options.metadata || {}
+    };
+    
+    this.workers.set(pid, worker);
+    this.connections.set(pid, 0);
+    this.workerWeights.set(pid, worker.weight);
+    
+    console.log(`✅ Worker ${pid} added to load balancer`);
+    this.emit('worker:added', { pid, worker });
+    
+    // Start health checks
+    this.startHealthChecks();
+    
+    return worker;
+  }
+  
+  /**
+   * Remove a worker from the load balancer
+   * @param {number} pid - Process ID
+   * @returns {boolean} Success status
+   */
+  removeWorker(pid) {
+    const worker = this.workers.get(pid);
+    if (!worker) {
+      return false;
+    }
+    
+    this.workers.delete(pid);
+    this.connections.delete(pid);
+    this.workerWeights.delete(pid);
+    
+    // Clean up session mappings
+    for (const [sessionId, workerPid] of this.sessionMap.entries()) {
+      if (workerPid === pid) {
+        this.sessionMap.delete(sessionId);
+      }
+    }
+    
+    console.log(`🗑️ Worker ${pid} removed from load balancer`);
+    this.emit('worker:removed', { pid, worker });
+    
+    return true;
+  }
+  
+  /**
+   * Get the next available worker for a request
+   * @param {string} sessionId - Session ID for sticky sessions
+   * @param {string} clientIp - Client IP for IP hash algorithm
+   * @returns {number|null} PID of the selected worker
+   */
+  getNextWorker(sessionId = null, clientIp = null) {
+    // If sticky sessions enabled and session exists, return cached worker
+    if (sessionId && this.options.stickySessions) {
+      const cachedWorker = this.sessionMap.get(sessionId);
+      if (cachedWorker && this.isWorkerHealthy(cachedWorker)) {
+        this.incrementConnections(cachedWorker);
+        return cachedWorker;
+      }
+    }
+    
+    const healthyWorkers = this.getHealthyWorkers();
+    
+    if (healthyWorkers.length === 0) {
+      console.warn('⚠️ No healthy workers available');
+      this.emit('error:noHealthyWorkers');
+      return null;
+    }
+    
+    let selectedWorker;
+    
+    switch (this.options.algorithm) {
+      case 'round-robin':
+        selectedWorker = this.roundRobin(healthyWorkers);
+        break;
+      case 'least-connections':
+        selectedWorker = this.leastConnections(healthyWorkers);
+        break;
+      case 'ip-hash':
+        selectedWorker = this.ipHash(healthyWorkers, clientIp);
+        break;
+      case 'weighted':
+        selectedWorker = this.weightedRoundRobin(healthyWorkers);
+        break;
+      default:
+        selectedWorker = this.roundRobin(healthyWorkers);
+    }
+    
+    // Cache session to worker mapping if sticky sessions enabled
+    if (sessionId && this.options.stickySessions) {
+      this.sessionMap.set(sessionId, selectedWorker);
+      
+      // Set session expiration
+      setTimeout(() => {
+        this.sessionMap.delete(sessionId);
+      }, this.options.sessionTimeout);
+    }
+    
+    // Increment connection count
+    this.incrementConnections(selectedWorker);
+    
+    this.emit('worker:selected', { 
+      pid: selectedWorker, 
+      algorithm: this.options.algorithm,
+      sessionId,
+      clientIp 
+    });
+    
+    return selectedWorker;
+  }
+  
+  /**
+   * Round-robin load balancing algorithm
+   * @param {Array} workers - Array of worker PIDs
+   * @returns {number} Selected worker PID
+   */
+  roundRobin(workers) {
+    if (this.currentIndex >= workers.length) {
+      this.currentIndex = 0;
+    }
+    
+    const worker = workers[this.currentIndex];
+    this.currentIndex++;
+    
+    return worker;
+  }
+  
+  /**
+   * Least connections load balancing algorithm
+   * @param {Array} workers - Array of worker PIDs
+   * @returns {number} Selected worker PID
+   */
+  leastConnections(workers) {
+    let minConnections = Infinity;
+    let selectedWorker = null;
+    
+    for (const workerPid of workers) {
+      const connections = this.connections.get(workerPid) || 0;
+      if (connections < minConnections) {
+        minConnections = connections;
+        selectedWorker = workerPid;
+      }
+    }
+    
+    return selectedWorker;
+  }
+  
+  /**
+   * IP hash load balancing algorithm
+   * @param {Array} workers - Array of worker PIDs
+   * @param {string} ip - Client IP address
+   * @returns {number} Selected worker PID
+   */
+  ipHash(workers, ip = '') {
+    if (!ip) {
+      return this.roundRobin(workers);
+    }
+    
+    // Simple IP hash algorithm
+    let hash = 0;
+    for (let i = 0; i < ip.length; i++) {
+      hash = ((hash << 5) - hash) + ip.charCodeAt(i);
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    
+    const index = Math.abs(hash) % workers.length;
+    return workers[index];
+  }
+  
+  /**
+   * Weighted round-robin load balancing algorithm
+   * @param {Array} workers - Array of worker PIDs
+   * @returns {number} Selected worker PID
+   */
+  weightedRoundRobin(workers) {
+    const weightedWorkers = [];
+    
+    for (const workerPid of workers) {
+      const worker = this.workers.get(workerPid);
+      const weight = worker.weight || 1;
+      
+      for (let i = 0; i < weight; i++) {
+        weightedWorkers.push(workerPid);
+      }
+    }
+    
+    if (this.currentIndex >= weightedWorkers.length) {
+      this.currentIndex = 0;
+    }
+    
+    const worker = weightedWorkers[this.currentIndex];
+    this.currentIndex++;
+    
+    return worker;
+  }
+  
+  /**
+   * Check if a worker is healthy
+   * @param {number} workerPid - Worker process ID
+   * @returns {boolean} Health status
+   */
+  isWorkerHealthy(workerPid) {
+    const worker = this.workers.get(workerPid);
+    if (!worker) {
+      return false;
+    }
+    
+    // Check connection limit
+    const connections = this.connections.get(workerPid) || 0;
+    if (connections >= this.options.maxConnectionsPerWorker) {
+      return false;
+    }
+    
+    // Check health status
+    if (!worker.isHealthy) {
+      return false;
+    }
+    
+    // Check last health check time
+    const timeSinceLastCheck = Date.now() - worker.lastHealthCheck;
+    if (timeSinceLastCheck > this.options.healthCheckInterval * 2) {
+      return false; // No health check for 2 intervals, consider unhealthy
+    }
+    
+    return true;
+  }
+  
+  /**
+   * Get list of healthy workers
+   * @returns {Array} Array of healthy worker PIDs
+   */
+  getHealthyWorkers() {
+    const healthyWorkers = [];
+    
+    for (const [pid, worker] of this.workers.entries()) {
+      if (this.isWorkerHealthy(pid)) {
+        healthyWorkers.push(pid);
+      }
+    }
+    
+    return healthyWorkers;
+  }
+  
+  /**
+   * Increment connection count for a worker
+   * @param {number} workerPid - Worker process ID
+   */
+  incrementConnections(workerPid) {
+    const current = this.connections.get(workerPid) || 0;
+    this.connections.set(workerPid, current + 1);
+    
+    // Update worker connection count
+    const worker = this.workers.get(workerPid);
+    if (worker) {
+      worker.connections = current + 1;
+      worker.lastRequestTime = Date.now();
+    }
+    
+    this.emit('connection:incremented', { pid: workerPid, connections: current + 1 });
+  }
+  
+  /**
+   * Decrement connection count for a worker
+   * @param {number} workerPid - Worker process ID
+   */
+  decrementConnections(workerPid) {
+    const current = this.connections.get(workerPid) || 0;
+    if (current > 0) {
+      this.connections.set(workerPid, current - 1);
+      
+      // Update worker connection count
+      const worker = this.workers.get(workerPid);
+      if (worker) {
+        worker.connections = current - 1;
+      }
+    }
+    
+    this.emit('connection:decremented', { pid: workerPid, connections: Math.max(0, current - 1) });
+  }
+  
+  /**
+   * Update worker health status
+   * @param {number} workerPid - Worker process ID
+   * @param {boolean} isHealthy - Health status
+   */
+  updateWorkerHealth(workerPid, isHealthy) {
+    const worker = this.workers.get(workerPid);
+    if (worker) {
+      worker.isHealthy = isHealthy;
+      worker.lastHealthCheck = Date.now();
+      
+      console.log(`Worker ${workerPid} health updated: ${isHealthy ? 'healthy' : 'unhealthy'}`);
+      this.emit('worker:healthUpdated', { pid: workerPid, isHealthy });
+    }
+  }
+  
+  /**
+   * Start health checks for workers
+   */
+  startHealthChecks() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+    }
+    
+    this.healthCheckInterval = setInterval(() => {
+      this.performHealthChecks();
+    }, this.options.healthCheckInterval);
+    
+    console.log(`✅ Load balancer health checks started (interval: ${this.options.healthCheckInterval}ms)`);
+  }
+  
+  /**
+   * Perform health checks on all workers
+   */
+  performHealthChecks() {
+    for (const [pid, worker] of this.workers.entries()) {
+      // Check connection count
+      const connections = this.connections.get(pid) || 0;
+      const isOverloaded = connections >= this.options.maxConnectionsPerWorker;
+      
+      // Update health status
+      if (isOverloaded) {
+        this.updateWorkerHealth(pid, false);
+        this.emit('worker:overloaded', { pid, connections });
+      } else {
+        this.updateWorkerHealth(pid, true);
+      }
+    }
+    
+    this.emit('health:checkCompleted');
+  }
+  
+  /**
+   * Get load balancer statistics
+   * @returns {Object} Load balancer statistics
+   */
+  getStats() {
+    const totalWorkers = this.workers.size;
+    const healthyWorkers = this.getHealthyWorkers().length;
+    const totalConnections = Array.from(this.connections.values()).reduce((sum, count) => sum + count, 0);
+    
+    const workerStats = [];
+    for (const [pid, worker] of this.workers.entries()) {
+      const connections = this.connections.get(pid) || 0;
+      workerStats.push({
+        pid,
+        weight: worker.weight,
+        connections,
+        isHealthy: worker.isHealthy,
+        lastHealthCheck: worker.lastHealthCheck,
+        lastRequestTime: worker.lastRequestTime,
+        uptime: Date.now() - worker.addedAt,
+        metadata: worker.metadata
+      });
+    }
+    
+    return {
+      algorithm: this.options.algorithm,
+      stickySessions: this.options.stickySessions,
+      sessionTimeout: this.options.sessionTimeout,
+      maxConnectionsPerWorker: this.options.maxConnectionsPerWorker,
+      totalWorkers,
+      healthyWorkers,
+      unhealthyWorkers: totalWorkers - healthyWorkers,
+      totalConnections,
+      averageConnectionsPerWorker: totalWorkers > 0 ? totalConnections / totalWorkers : 0,
+      workers: workerStats,
+      sessionCount: this.sessionMap.size,
+      currentIndex: this.currentIndex,
+      timestamp: new Date().toISOString()
+    };
+  }
+  
+  /**
+   * Reset the load balancer
+   */
+  reset() {
+    this.currentIndex = 0;
+    this.connections.clear();
+    this.sessionMap.clear();
+    
+    // Reset all worker connection counts
+    for (const [pid, worker] of this.workers.entries()) {
+      worker.connections = 0;
+    }
+    
+    console.log('🔄 Load balancer reset');
+    this.emit('loadBalancer:reset');
+  }
+  
+  /**
+   * Stop the load balancer
+   */
+  stop() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+    
+    console.log('🛑 Load balancer stopped');
+    this.emit('loadBalancer:stopped');
+  }
+  
+  /**
+   * Update worker weight
+   * @param {number} pid - Worker process ID
+   * @param {number} weight - New weight
+   */
+  updateWorkerWeight(pid, weight) {
+    const worker = this.workers.get(pid);
+    if (worker) {
+      worker.weight = Math.max(1, weight);
+      this.workerWeights.set(pid, worker.weight);
+      
+      console.log(`Worker ${pid} weight updated to ${weight}`);
+      this.emit('worker:weightUpdated', { pid, weight });
+    }
+  }
+  
+  /**
+   * Get worker by PID
+   * @param {number} pid - Worker process ID
+   * @returns {Object|null} Worker object
+   */
+  getWorker(pid) {
+    const worker = this.workers.get(pid);
+    if (!worker) return null;
+    
+    return {
+      ...worker,
+      connections: this.connections.get(pid) || 0,
+      isHealthy: this.isWorkerHealthy(pid)
+    };
+  }
+  
+  /**
+   * Get all workers
+   * @returns {Array} Array of worker objects
+   */
+  getAllWorkers() {
+    const workers = [];
+    
+    for (const [pid, worker] of this.workers.entries()) {
+      workers.push(this.getWorker(pid));
+    }
+    
+    return workers;
+  }
+  
+  /**
+   * Get session to worker mapping
+   * @param {string} sessionId - Session ID
+   * @returns {number|null} Worker PID
+   */
+  getSessionWorker(sessionId) {
+    return this.sessionMap.get(sessionId) || null;
+  }
+  
+  /**
+   * Clear expired sessions
+   * @returns {number} Number of cleared sessions
+   */
+  clearExpiredSessions() {
+    const now = Date.now();
+    let cleared = 0;
+    
+    // Note: In a real implementation, we would track session creation time
+    // For now, we'll just clear old sessions periodically
+    const sessionCount = this.sessionMap.size;
+    if (sessionCount > 1000) {
+      // Clear 10% of oldest sessions if we have too many
+      const sessionsToClear = Math.floor(sessionCount * 0.1);
+      const keys = Array.from(this.sessionMap.keys()).slice(0, sessionsToClear);
+      
+      for (const key of keys) {
+        this.sessionMap.delete(key);
+        cleared++;
+      }
+    }
+    
+    if (cleared > 0) {
+      console.log(`Cleared ${cleared} expired sessions`);
+      this.emit('sessions:cleared', { count: cleared });
+    }
+    
+    return cleared;
+  }
+}
+
+export default LoadBalancer;