kukuy 1.4.0

package/src/algorithms/IPHashAlgorithm.js

@@ -0,0 +1,131 @@
+const { LoadBalancingAlgorithm } = require('./LoadBalancingAlgorithm');
+
+/**
+ * Algoritmo IPHash para balanceo de carga
+ * Asegura que las solicitudes del mismo cliente vayan siempre al mismo servidor
+ */
+class IPHashAlgorithm extends LoadBalancingAlgorithm {
+  constructor() {
+    super();
+    // Mapa para almacenar la asociación persistente IP -> índice de servidor
+    this.ipToServerIndexMap = new Map();
+  }
+
+  /**
+   * Selecciona un servidor usando el algoritmo IPHash
+   * @param {Array} servers - Lista de servidores disponibles
+   * @param {Object} requestContext - Contexto de la solicitud (contiene la IP del cliente)
+   * @returns {Object|null} Servidor seleccionado o null si no hay disponibles
+   */
+  selectServer(servers, requestContext = {}) {
+    if (!servers || servers.length === 0) {
+      return null;
+    }
+
+    // Filtrar servidores activos y saludables
+    const availableServers = servers.filter(server =>
+      server.active !== false && server.healthy && server.failedAttempts < 5
+    );
+
+    if (availableServers.length === 0) {
+      return null;
+    }
+
+    // Obtener la IP del cliente del contexto de la solicitud
+    const clientIP = this.getClientIP(requestContext);
+
+    // Verificar si ya tenemos una asociación para esta IP
+    let serverIndex;
+    if (this.ipToServerIndexMap.has(clientIP)) {
+      serverIndex = this.ipToServerIndexMap.get(clientIP);
+      // Verificar que el servidor en ese índice aún esté disponible
+      if (serverIndex < availableServers.length) {
+        const cachedServer = availableServers[serverIndex];
+        if (cachedServer && cachedServer.healthy && cachedServer.active) {
+          // Servidor sigue disponible, usarlo
+          console.log(`IPHash: IP=${clientIP} reutilizando servidor previamente asignado (índice ${serverIndex})`);
+          return cachedServer;
+        } else {
+          // Servidor ya no está disponible, eliminar la asociación
+          this.ipToServerIndexMap.delete(clientIP);
+        }
+      }
+    }
+
+    // Si no hay asociación o el servidor ya no está disponible, crear una nueva
+    const hash = this.simpleHash(clientIP);
+    serverIndex = hash % availableServers.length;
+
+    // Guardar la asociación para futuras solicitudes
+    this.ipToServerIndexMap.set(clientIP, serverIndex);
+
+    const selectedServer = availableServers[serverIndex];
+
+    // Log para mostrar el mapa de hash
+    console.log(`IPHash: IP=${clientIP}, Hash=${hash}, Asignando servidor índice ${serverIndex} (ID: ${selectedServer.id}, URL: ${selectedServer.url})`);
+
+    return selectedServer;
+  }
+
+  /**
+   * Obtiene la IP del cliente del contexto de la solicitud
+   * @param {Object} requestContext - Contexto de la solicitud
+   * @returns {string} IP del cliente
+   */
+  getClientIP(requestContext) {
+    // Buscar IP en diferentes posiciones posibles
+    const req = requestContext.req || {};
+
+    // Prioridad de fuentes de IP:
+    // 1. Cabecera X-Forwarded-For
+    // 2. Cabecera X-Real-IP
+    // 3. Remote Address
+    const forwardedFor = req.headers?.['x-forwarded-for'];
+    if (forwardedFor) {
+      // Tomar la primera IP de la lista (cliente original)
+      return forwardedFor.split(',')[0].trim();
+    }
+
+    const realIp = req.headers?.['x-real-ip'];
+    if (realIp) {
+      return realIp.trim();
+    }
+
+    // En entornos locales, connection.remoteAddress o socket.remoteAddress contendrán la IP
+    return req.connection?.remoteAddress ||
+           req.socket?.remoteAddress ||
+           '127.0.0.1';
+  }
+
+  /**
+   * Función hash simple para convertir una cadena en un número
+   * @param {string} str - Cadena a hashear
+   * @returns {number} Valor numérico del hash
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convertir a 32-bit integer
+    }
+    return Math.abs(hash);
+  }
+
+  /**
+   * Obtiene el mapa de IP a servidor para logging
+   * @returns {Map} Mapa de IPs a índices de servidores
+   */
+  getIPToServerMap() {
+    return this.ipToServerIndexMap;
+  }
+
+  /**
+   * Nombre del algoritmo
+   */
+  getName() {
+    return 'iphash';
+  }
+}
+
+module.exports = { IPHashAlgorithm };

package/src/algorithms/LoadBalancingAlgorithm.js

@@ -0,0 +1,23 @@
+/**
+ * Interfaz base para algoritmos de balanceo de carga
+ */
+class LoadBalancingAlgorithm {
+  /**
+   * Selecciona un servidor para manejar una solicitud
+   * @param {Array} servers - Lista de servidores disponibles
+   * @param {Object} requestContext - Contexto de la solicitud (opcional)
+   * @returns {Object|null} Servidor seleccionado o null si no hay disponibles
+   */
+  selectServer(servers, requestContext = {}) {
+    throw new Error('Método selectServer debe ser implementado por la subclase');
+  }
+
+  /**
+   * Nombre del algoritmo
+   */
+  getName() {
+    throw new Error('Método getName debe ser implementado por la subclase');
+  }
+}
+
+module.exports = { LoadBalancingAlgorithm };

package/src/algorithms/RoundRobinAlgorithm.js

@@ -0,0 +1,67 @@
+const { LoadBalancingAlgorithm } = require('./LoadBalancingAlgorithm');
+
+/**
+ * Algoritmo RoundRobin para balanceo de carga
+ * Basado en la lógica mejorada implementada previamente en el balanceador
+ */
+class RoundRobinAlgorithm extends LoadBalancingAlgorithm {
+  constructor() {
+    super();
+    this.currentIndex = 0;
+  }
+
+  /**
+   * Selecciona un servidor usando el algoritmo RoundRobin
+   * @param {Array} servers - Lista de servidores disponibles
+   * @param {Object} requestContext - Contexto de la solicitud (opcional)
+   * @returns {Object|null} Servidor seleccionado o null si no hay disponibles
+   */
+  selectServer(servers, requestContext = {}) {
+    if (!servers || servers.length === 0) {
+      return null;
+    }
+
+    // Filtrar servidores activos y saludables
+    const availableServers = servers.filter(server => 
+      server.active !== false && server.healthy && server.failedAttempts < 5
+    );
+
+    if (availableServers.length === 0) {
+      return null;
+    }
+
+    // Intentar encontrar un servidor disponible usando round robin
+    // Si el servidor actual no está disponible, buscar el siguiente disponible
+    for (let i = 0; i < availableServers.length; i++) {
+      const candidateIndex = (this.currentIndex + i) % availableServers.length;
+      const candidateServer = availableServers[candidateIndex];
+      
+      // Verificar si el servidor candidato está realmente disponible
+      if (this.isServerAvailable(candidateServer)) {
+        this.currentIndex = candidateIndex + 1; // Preparar para la próxima selección
+        return candidateServer;
+      }
+    }
+    
+    // Si ningún servidor está disponible, devolver null
+    return null;
+  }
+
+  // Método para verificar si un servidor está disponible
+  isServerAvailable(server) {
+    // Un servidor está disponible si:
+    // 1. Está marcado como healthy
+    // 2. Está activo
+    // 3. No ha superado el número máximo de intentos fallidos
+    return server.healthy && server.active && server.failedAttempts < 5;
+  }
+
+  /**
+   * Nombre del algoritmo
+   */
+  getName() {
+    return 'roundrobin';
+  }
+}
+
+module.exports = { RoundRobinAlgorithm };

package/src/config/ConfigManager.js

@@ -0,0 +1,37 @@
+class ConfigManager {
+  static instance = null;
+
+  constructor() {
+    if (ConfigManager.instance) {
+      return ConfigManager.instance;
+    }
+
+    this.httpPort = parseInt(process.env.BALANCER_HTTP_PORT) || 8080;
+    this.httpsPort = process.env.BALANCER_HTTPS_PORT ? parseInt(process.env.BALANCER_HTTPS_PORT) : null;
+    this.configFilePath = process.env.CONFIG_FILE_PATH || './servers.json';
+    this.routesFilePath = process.env.ROUTES_FILE_PATH || './routes.json';
+    this.sslCertPath = process.env.SSL_CERT_PATH;
+    this.sslKeyPath = process.env.SSL_KEY_PATH;
+    this.healthCheckInterval = parseInt(process.env.HEALTH_CHECK_INTERVAL) || 30000;
+    this.logLevel = process.env.LOG_LEVEL || 'info';
+
+    ConfigManager.instance = this;
+  }
+
+  static getInstance() {
+    if (!ConfigManager.instance) {
+      ConfigManager.instance = new ConfigManager();
+    }
+    return ConfigManager.instance;
+  }
+
+  get(key) {
+    return this[key];
+  }
+
+  set(key, value) {
+    this[key] = value;
+  }
+}
+
+module.exports = { ConfigManager };

package/src/config/RouteLoader.js

@@ -0,0 +1,36 @@
+const fs = require('fs');
+
+class RouteLoader {
+  constructor() {
+    this.routes = [];
+  }
+
+  loadRoutesFromFile(filePath) {
+    if (fs.existsSync(filePath)) {
+      const routesData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      this.routes = routesData.routes || [];
+      return this.routes;
+    } else {
+      console.warn(`Archivo de rutas ${filePath} no encontrado`);
+      this.routes = [];
+      return [];
+    }
+  }
+
+  getRoutes() {
+    return this.routes;
+  }
+
+  addRoute(route) {
+    this.routes.push(route);
+  }
+
+  findMatchingRoute(url, method) {
+    return this.routes.find(route => {
+      const routeRegex = new RegExp(route.path.replace(/\*/g, '.*'));
+      return routeRegex.test(url) && (route.methods.includes(method) || route.methods.includes('*'));
+    });
+  }
+}
+
+module.exports = { RouteLoader };

package/src/core/Balancer.js

@@ -0,0 +1,353 @@
+/*
+ * KUKUY
+ * Copyright (C) 2026 Desarrollador
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+const fs = require('fs');
+const url = require('url');
+const { HookManager } = require('../extensibility/HookManager');
+const { FilterChain } = require('../extensibility/FilterChain');
+const { ServerPool } = require('./ServerPool');
+const { AlgorithmManager } = require('../algorithms/AlgorithmManager');
+const { ConfigManager } = require('../config/ConfigManager');
+const { Logger } = require('../utils/Logger');
+const { BalancerLogger } = require('../utils/BalancerLogger');
+const { RouteLoader } = require('../config/RouteLoader');
+const { HttpBalancer } = require('../protocol/HttpBalancer');
+const { HttpsBalancer } = require('../protocol/HttpsBalancer');
+const { ProfessionalMetrics } = require('../utils/ProfessionalMetrics');
+const { WebDashboard } = require('../dashboard/WebDashboard');
+const { WebSocketServer } = require('../dashboard/WebSocketServer');
+
+class Balancer {
+  constructor() {
+    this.config = ConfigManager.getInstance();
+    this.hookManager = new HookManager();
+    this.filterChain = new FilterChain();
+    this.serverPool = new ServerPool();
+    this.algorithmManager = new AlgorithmManager();
+    this.routeLoader = new RouteLoader();
+    this.logger = new Logger();
+    this.balancerLogger = new BalancerLogger();
+    this.metricsCollector = new ProfessionalMetrics(); // Usar métricas profesionales
+    this.startTime = Date.now();
+
+    // Cargar configuración
+    this.loadConfiguration();
+
+    // Configurar algoritmo de balanceo basado en la configuración
+    this.configureLoadBalancingAlgorithm();
+
+    // Inicializar panel web
+    this.webDashboard = new WebDashboard(this);
+
+    // Inicializar servidor WebSocket para datos en tiempo real
+    this.webSocketServer = new WebSocketServer(this);
+  }
+
+  loadConfiguration() {
+    // Cargar servidores desde archivo de configuración
+    const configFile = process.env.CONFIG_FILE_PATH || './servers.json';
+    if (fs.existsSync(configFile)) {
+      const serversData = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      this.serverPool.addServers(serversData.servers);
+    } else {
+      this.logger.warn(`Archivo de configuración ${configFile} no encontrado`);
+    }
+
+    // Cargar rutas desde archivo de configuración usando RouteLoader
+    const routesFile = process.env.ROUTES_FILE_PATH || './routes.json';
+    this.routes = this.routeLoader.loadRoutesFromFile(routesFile);
+  }
+
+  configureLoadBalancingAlgorithm() {
+    // Obtener el algoritmo de balanceo desde la configuración
+    const algorithmName = process.env.LOAD_BALANCING_ALGORITHM || 'roundrobin';
+
+    // Intentar configurar el algoritmo
+    const success = this.algorithmManager.setCurrentAlgorithm(algorithmName);
+
+    if (success) {
+      this.logger.info(`Algoritmo de balanceo configurado: ${algorithmName}`);
+    } else {
+      this.logger.warn(`Algoritmo desconocido: ${algorithmName}. Usando roundrobin por defecto.`);
+      this.algorithmManager.setCurrentAlgorithm('roundrobin');
+    }
+  }
+
+  start() {
+    // Crear servidor HTTP usando HttpBalancer
+    if (this.config.httpPort) {
+      this.httpBalancer = new HttpBalancer(this.config.httpPort, this.handleRequest.bind(this));
+      this.httpServer = this.httpBalancer.start();
+    }
+
+    // Crear servidor HTTPS usando HttpsBalancer si está configurado
+    if (this.config.httpsPort && this.config.sslCertPath && this.config.sslKeyPath) {
+      this.httpsBalancer = new HttpsBalancer(
+        this.config.httpsPort,
+        this.config.sslCertPath,
+        this.config.sslKeyPath,
+        this.handleRequest.bind(this)
+      );
+      this.httpsServer = this.httpsBalancer.start();
+    }
+
+    // Iniciar panel web
+    this.webDashboard.start();
+
+    // Iniciar servidor WebSocket para datos en tiempo real
+    const wsPort = process.env.WEBSOCKET_PORT || 8083;
+    this.webSocketServer.start(wsPort);
+  }
+
+  async handleRequest(clientReq, clientRes) {
+    try {
+      // Aplicar filters antes de procesar la solicitud
+      const filterData = { req: clientReq, res: clientRes, allowed: true, statusCode: 200, message: '' };
+      const filteredResult = await this.filterChain.applyFilters('request', clientReq, clientRes);
+
+      if (!filteredResult || !filteredResult.allowed) {
+        const statusCode = filteredResult?.statusCode || 403;
+        const message = filteredResult?.message || 'Forbidden';
+        clientRes.writeHead(statusCode);
+        clientRes.end(message);
+        return;
+      }
+
+      // Emitir hook cuando se recibe una solicitud
+      await this.hookManager.executeHooks('onRequestReceived', { req: clientReq, res: clientRes });
+
+      // Determinar la ruta objetivo
+      const targetServer = await this.getTargetServer(clientReq.url, clientReq.method, clientReq);
+
+      if (!targetServer) {
+        clientRes.writeHead(404);
+        clientRes.end('No available servers');
+        return;
+      }
+
+      // Emitir hook después de seleccionar servidor
+      await this.hookManager.executeHooks('onServerSelected', {
+        req: clientReq,
+        res: clientRes,
+        server: targetServer
+      });
+
+      // Reenviar solicitud al servidor backend
+      this.proxyRequest(clientReq, clientRes, targetServer);
+
+    } catch (error) {
+      this.logger.error(`Error manejando solicitud: ${error.message}`);
+
+      // Emitir hook cuando ocurre un error
+      await this.hookManager.executeHooks('onServerError', {
+        req: clientReq,
+        res: clientRes,
+        error
+      });
+
+      clientRes.writeHead(500);
+      clientRes.end('Internal Server Error');
+    }
+  }
+
+  async getTargetServer(requestUrl, method, clientReq = null) {
+    // Usar RouteLoader para encontrar la ruta coincidente
+    const matchedRoute = this.routeLoader.findMatchingRoute(requestUrl, method);
+
+    // Crear contexto de solicitud para algoritmos que lo necesiten (como IPHash)
+    const requestContext = {
+      req: clientReq,
+      url: requestUrl,
+      method: method
+    };
+
+    if (matchedRoute && matchedRoute.target) {
+      // Si hay una ruta específica, usar solo los servidores definidos para esa ruta
+      const routeServers = this.serverPool.getHealthyServers().filter(server =>
+        server.tags && server.tags.includes(matchedRoute.target)
+      );
+      if (routeServers.length > 0) {
+        return this.algorithmManager.selectServer(routeServers, requestContext);
+      }
+    }
+
+    // Si no hay ruta específica o no hay servidores para esa ruta, usar todos los servidores
+    const allServers = this.serverPool.getHealthyServers();
+    return this.algorithmManager.selectServer(allServers, requestContext);
+  }
+
+  async proxyRequest(clientReq, clientRes, initialTargetServer) {
+    const startTime = Date.now();
+    let targetServer = initialTargetServer;
+    let retryCount = 0;
+    const maxRetries = this.serverPool.getHealthyServers().length; // Máximo de reintentos según servidores saludables
+
+    // Intentar enviar la solicitud con reintento si el servidor inicial falla
+    while (retryCount <= maxRetries) {
+      try {
+        const parsedUrl = url.parse(targetServer.url);
+        const targetOptions = {
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: clientReq.url,
+          method: clientReq.method,
+          headers: clientReq.headers
+        };
+
+        const httpModule = targetServer.protocol === 'https:' ? require('https') : require('http');
+        const proxyReq = httpModule.request(targetOptions);
+
+        // Registrar intento de conexión a servidor target
+        this.balancerLogger.logTargetSelection(targetServer, 'round_robin');
+
+        // Enviar cuerpo de la solicitud
+        clientReq.pipe(proxyReq);
+
+        // Resolver la promesa cuando se complete la solicitud
+        return new Promise((resolve, reject) => {
+          proxyReq.on('response', (serverRes) => {
+            // Copiar headers de la respuesta
+            clientRes.writeHead(serverRes.statusCode, serverRes.headers);
+
+            // Enviar cuerpo de la respuesta al cliente
+            serverRes.pipe(clientRes);
+
+            // Calcular tiempo de respuesta
+            const responseTime = Date.now() - startTime;
+
+            // Registrar métricas profesionales
+            this.metricsCollector.recordRequest(
+              clientReq.method,
+              clientReq.url,
+              targetServer.id,
+              responseTime,
+              serverRes.statusCode,
+              serverRes.statusCode < 400
+            );
+
+            // Registrar servidor online
+            this.balancerLogger.logOnlineTarget(targetServer, {
+              url: clientReq.url,
+              method: clientReq.method,
+              responseTime,
+              statusCode: serverRes.statusCode
+            });
+
+            // Actualizar estado del servidor en las métricas
+            this.metricsCollector.updateServerStatus(targetServer.id, 'online');
+
+            // Emitir hook cuando se envía la respuesta
+            this.hookManager.executeHooks('onResponseSent', {
+              req: clientReq,
+              res: clientRes,
+              serverRes,
+              server: targetServer,
+              responseTime
+            });
+
+            resolve(); // Resolver la promesa al completar la solicitud
+          });
+
+          proxyReq.on('error', async (err) => {
+            const responseTime = Date.now() - startTime;
+
+            this.logger.error(`Error conectando con servidor ${targetServer.url}: ${err.message}`);
+
+            // Registrar servidor offline
+            this.balancerLogger.logOfflineTarget(targetServer, err, {
+              url: clientReq.url,
+              method: clientReq.method,
+              responseTime
+            });
+
+            // Actualizar estado del servidor en las métricas
+            this.metricsCollector.updateServerStatus(targetServer.id, 'offline');
+
+            // Registrar métricas profesionales para error
+            this.metricsCollector.recordRequest(
+              clientReq.method,
+              clientReq.url,
+              targetServer.id,
+              responseTime,
+              502,
+              false
+            );
+
+            // Marcar servidor como fallido
+            this.serverPool.markServerAsFailed(targetServer.id);
+
+            // Emitir hook cuando ocurre un error con el servidor
+            await this.hookManager.executeHooks('onServerError', {
+              req: clientReq,
+              res: clientRes,
+              server: targetServer,
+              error: err,
+              responseTime
+            });
+
+            // Si hay más servidores disponibles, reintentar con otro servidor
+            if (retryCount < maxRetries) {
+              retryCount++;
+
+              // Obtener un nuevo servidor objetivo (excluyendo el que falló)
+              const availableServers = this.serverPool.getHealthyServers().filter(s => s.id !== targetServer.id);
+              if (availableServers.length > 0) {
+                // Seleccionar un nuevo servidor
+                targetServer = availableServers[(retryCount - 1) % availableServers.length];
+                console.log(`Reintentando con servidor alternativo: ${targetServer.url}`);
+
+                // Volver a intentar la solicitud con el nuevo servidor
+                setTimeout(() => {
+                  this.proxyRequest(clientReq, clientRes, targetServer).then(resolve).catch(reject);
+                }, 10); // Pequeña pausa antes de reintentar
+
+                return; // Salir para evitar resolver/rechazar la promesa dos veces
+              }
+            }
+
+            // Si no hay más reintentos posibles, enviar error al cliente
+            if (!clientRes.headersSent) {
+              clientRes.writeHead(502);
+              clientRes.end('Bad Gateway');
+            }
+
+            resolve(); // Resolver para evitar múltiples llamadas
+          });
+        });
+      } catch (error) {
+        console.error('Error en proxyRequest:', error);
+        if (!clientRes.headersSent) {
+          clientRes.writeHead(500);
+          clientRes.end('Internal Server Error');
+        }
+        return;
+      }
+    }
+  }
+
+  stop() {
+    if (this.httpBalancer) {
+      this.httpBalancer.stop();
+    }
+    if (this.httpsBalancer) {
+      this.httpsBalancer.stop();
+    }
+  }
+}
+
+module.exports = { Balancer };