kukuy 1.4.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kukuy",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Balanceador de carga Backend",
   "main": "kukuy.js",
   "scripts": {
@@ -9,6 +9,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
+    "backend",
     "load-balancer",
     "round-robin",
     "ip-hash",
@@ -22,5 +23,10 @@
     "jerk-hooked-lib": "^2.0.0",
     "ws": "^8.19.0"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "homepage": "https://bsanchez.unaux.com/",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bytedogssyndicate1/kukuy"
+  }
 }

package/servers_real.json

@@ -14,6 +14,11 @@
       "url": "http://localhost:5445",
       "weight": 1,
       "tags": ["backend"]
+    },
+    {
+      "url": "http://localhost:6666",
+      "weight": 1,
+      "tags": ["backend"]
     }
   ]
 }

package/src/algorithms/IPHashAlgorithm.js

@@ -9,6 +9,10 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
     super();
     // Mapa para almacenar la asociación persistente IP -> índice de servidor
     this.ipToServerIndexMap = new Map();
+    // Caché para servidores filtrados
+    this.filteredServersCache = new Map();
+    this.cacheTimestamp = 0;
+    this.cacheValidity = 1000; // 1 segundo de validez de caché
   }
 
   /**
@@ -22,10 +26,23 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
       return null;
     }
 
-    // Filtrar servidores activos y saludables
-    const availableServers = servers.filter(server =>
-      server.active !== false && server.healthy && server.failedAttempts < 5
-    );
+    // Obtener timestamp actual
+    const now = Date.now();
+
+    // Verificar si la caché es válida
+    let availableServers;
+    if (now - this.cacheTimestamp > this.cacheValidity || !this.filteredServersCache.has(servers)) {
+      // Filtrar servidores activos y saludables
+      availableServers = servers.filter(server =>
+        server.active !== false && server.healthy && server.failedAttempts < 5
+      );
+
+      // Actualizar caché
+      this.filteredServersCache.set(servers, availableServers);
+      this.cacheTimestamp = now;
+    } else {
+      availableServers = this.filteredServersCache.get(servers);
+    }
 
     if (availableServers.length === 0) {
       return null;
@@ -43,7 +60,6 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
         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
@@ -61,9 +77,6 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
 
     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;
   }
 
@@ -104,12 +117,11 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
    */
   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
+    const len = str.length;
+    for (let i = 0; i < len; i++) {
+      hash = ((hash << 5) - hash) + str.charCodeAt(i);
     }
-    return Math.abs(hash);
+    return Math.abs(hash | 0); // Convertir a 32-bit integer
   }
 
   /**

package/src/algorithms/RoundRobinAlgorithm.js

@@ -8,6 +8,10 @@ class RoundRobinAlgorithm extends LoadBalancingAlgorithm {
   constructor() {
     super();
     this.currentIndex = 0;
+    // Caché para servidores filtrados
+    this.filteredServersCache = new Map();
+    this.cacheTimestamp = 0;
+    this.cacheValidity = 1000; // 1 segundo de validez de caché
   }
 
   /**
@@ -21,39 +25,33 @@ class RoundRobinAlgorithm extends LoadBalancingAlgorithm {
       return null;
     }
 
-    // Filtrar servidores activos y saludables
-    const availableServers = servers.filter(server => 
-      server.active !== false && server.healthy && server.failedAttempts < 5
-    );
+    // Obtener timestamp actual
+    const now = Date.now();
+
+    // Verificar si la caché es válida
+    let availableServers;
+    if (now - this.cacheTimestamp > this.cacheValidity || !this.filteredServersCache.has(servers)) {
+      // Filtrar servidores activos y saludables
+      availableServers = servers.filter(server =>
+        server.active !== false && server.healthy && server.failedAttempts < 5
+      );
+
+      // Actualizar caché
+      this.filteredServersCache.set(servers, availableServers);
+      this.cacheTimestamp = now;
+    } else {
+      availableServers = this.filteredServersCache.get(servers);
+    }
 
     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;
-  }
+    // Obtener servidor usando round robin sin bucle
+    const server = availableServers[this.currentIndex % availableServers.length];
+    this.currentIndex = (this.currentIndex + 1) % availableServers.length;
 
-  // 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;
+    return server;
   }
 
   /**

package/src/core/Balancer.js

@@ -18,8 +18,8 @@
 
 const fs = require('fs');
 const url = require('url');
-const { HookManager } = require('../extensibility/HookManager');
-const { FilterChain } = require('../extensibility/FilterChain');
+const { ExtendedHookManager } = require('../extensibility/ExtendedHookManager');
+const { ExtendedFilterChain } = require('../extensibility/ExtendedFilterChain');
 const { ServerPool } = require('./ServerPool');
 const { AlgorithmManager } = require('../algorithms/AlgorithmManager');
 const { ConfigManager } = require('../config/ConfigManager');
@@ -31,12 +31,14 @@ const { HttpsBalancer } = require('../protocol/HttpsBalancer');
 const { ProfessionalMetrics } = require('../utils/ProfessionalMetrics');
 const { WebDashboard } = require('../dashboard/WebDashboard');
 const { WebSocketServer } = require('../dashboard/WebSocketServer');
+const { PostStartupExtension } = require('../extensibility/PostStartupExtension');
+const { PluginManager } = require('../plugins/PluginManager');
 
 class Balancer {
   constructor() {
     this.config = ConfigManager.getInstance();
-    this.hookManager = new HookManager();
-    this.filterChain = new FilterChain();
+    this.hookManager = new ExtendedHookManager();
+    this.filterChain = new ExtendedFilterChain();
     this.serverPool = new ServerPool();
     this.algorithmManager = new AlgorithmManager();
     this.routeLoader = new RouteLoader();
@@ -56,6 +58,64 @@ class Balancer {
 
     // Inicializar servidor WebSocket para datos en tiempo real
     this.webSocketServer = new WebSocketServer(this);
+
+    // Inicializar sistema de extensión post-inicio
+    this.postStartupExtension = new PostStartupExtension(this);
+
+    // Activar plugin de depuración si está habilitado
+    this.initializeDebugPlugin();
+
+    // Inicializar sistema de plugins
+    this.pluginManager = new PluginManager(this);
+  }
+
+  initializeDebugPlugin() {
+    // Verificar si el plugin de depuración está habilitado
+    const debugEnabled = process.env.DEBUG_REQUEST_HEADERS === 'true' ||
+                         process.env.KUKUY_DEBUG_HEADERS === 'true';
+
+    if (debugEnabled) {
+      // Registrar hooks para mostrar encabezados y servidor de destino
+
+      // Hook para mostrar encabezados cuando se recibe una solicitud
+      this.hookManager.addHook('onRequestReceived', ({ req, res }) => {
+        console.log('\n--- Nueva Solicitud Recibida ---');
+        console.log(`Método: ${req.method}`);
+        console.log(`URL: ${req.url}`);
+        console.log('Encabezados:');
+
+        // Mostrar todos los encabezados de la solicitud
+        for (const [header, value] of Object.entries(req.headers)) {
+          console.log(`  ${header}: ${value}`);
+        }
+
+        console.log('-----------------------------\n');
+      });
+
+      // Hook para mostrar el servidor de destino asignado
+      this.hookManager.addHook('onServerSelected', ({ req, res, server }) => {
+        console.log('\n--- Servidor de Destino Asignado ---');
+        console.log(`Solicitud: ${req.method} ${req.url}`);
+        console.log(`Servidor destino: ${server.url}`);
+        console.log(`ID del servidor: ${server.id}`);
+        console.log(`Protocolo: ${server.protocol}`);
+        console.log(`Host: ${server.host}`);
+        console.log(`Etiquetas: ${server.tags.join(', ') || 'ninguna'}`);
+        console.log('----------------------------------\n');
+      });
+
+      // Hook para mostrar información cuando se envía la respuesta
+      this.hookManager.addHook('onResponseSent', ({ req, res, serverRes, responseTime }) => {
+        console.log('\n--- Respuesta Enviada ---');
+        console.log(`Solicitud: ${req.method} ${req.url}`);
+        console.log(`Código de estado: ${serverRes.statusCode}`);
+        console.log(`Tiempo de respuesta: ${responseTime}ms`);
+        console.log('------------------------\n');
+      });
+
+      console.log('Plugin de depuración de solicitud activado');
+      console.log('Mostrando encabezados de solicitud y servidores de destino en stdout');
+    }
   }
 
   loadConfiguration() {
@@ -88,7 +148,7 @@ class Balancer {
     }
   }
 
-  start() {
+  async start() {
     // Crear servidor HTTP usando HttpBalancer
     if (this.config.httpPort) {
       this.httpBalancer = new HttpBalancer(this.config.httpPort, this.handleRequest.bind(this));
@@ -112,6 +172,9 @@ class Balancer {
     // Iniciar servidor WebSocket para datos en tiempo real
     const wsPort = process.env.WEBSOCKET_PORT || 8083;
     this.webSocketServer.start(wsPort);
+
+    // Cargar plugins después de iniciar componentes principales
+    await this.pluginManager.loadPlugins();
   }
 
   async handleRequest(clientReq, clientRes) {
@@ -178,11 +241,12 @@ class Balancer {
 
     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);
+      const routeServers = this.serverPool.getServersByTag(matchedRoute.target);
+      if (routeServers && routeServers.length > 0) {
+        const healthyRouteServers = routeServers.filter(server => server.healthy && server.active);
+        if (healthyRouteServers.length > 0) {
+          return this.algorithmManager.selectServer(healthyRouteServers, requestContext);
+        }
       }
     }
 
@@ -197,10 +261,10 @@ class Balancer {
     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);
+    // Función auxiliar para manejar la solicitud
+    const makeRequest = (server) => {
+      return new Promise((resolve, reject) => {
+        const parsedUrl = url.parse(server.url);
         const targetOptions = {
           hostname: parsedUrl.hostname,
           port: parsedUrl.port,
@@ -209,133 +273,134 @@ class Balancer {
           headers: clientReq.headers
         };
 
-        const httpModule = targetServer.protocol === 'https:' ? require('https') : require('http');
+        const httpModule = server.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');
+        this.balancerLogger.logTargetSelection(server, '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('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,
+            server.id,
+            responseTime,
+            serverRes.statusCode,
+            serverRes.statusCode < 400
+          );
+
+          // Registrar servidor online
+          this.balancerLogger.logOnlineTarget(server, {
+            url: clientReq.url,
+            method: clientReq.method,
+            responseTime,
+            statusCode: serverRes.statusCode
           });
 
-          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
-              }
-            }
+          // Actualizar estado del servidor en las métricas
+          this.metricsCollector.updateServerStatus(server.id, 'online');
 
-            // Si no hay más reintentos posibles, enviar error al cliente
-            if (!clientRes.headersSent) {
-              clientRes.writeHead(502);
-              clientRes.end('Bad Gateway');
-            }
+          // Emitir hook cuando se envía la respuesta
+          this.hookManager.executeHooks('onResponseSent', {
+            req: clientReq,
+            res: clientRes,
+            serverRes,
+            server,
+            responseTime
+          });
 
-            resolve(); // Resolver para evitar múltiples llamadas
+          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 ${server.url}: ${err.message}`);
+
+          // Registrar servidor offline
+          this.balancerLogger.logOfflineTarget(server, err, {
+            url: clientReq.url,
+            method: clientReq.method,
+            responseTime
+          });
+
+          // Actualizar estado del servidor en las métricas
+          this.metricsCollector.updateServerStatus(server.id, 'offline');
+
+          // Registrar métricas profesionales para error
+          this.metricsCollector.recordRequest(
+            clientReq.method,
+            clientReq.url,
+            server.id,
+            responseTime,
+            502,
+            false
+          );
+
+          // Marcar servidor como fallido
+          this.serverPool.markServerAsFailed(server.id);
+
+          // Emitir hook cuando ocurre un error con el servidor
+          await this.hookManager.executeHooks('onServerError', {
+            req: clientReq,
+            res: clientRes,
+            server,
+            error: err,
+            responseTime
           });
+
+          // Si hay más servidores disponibles, reintentar con otro servidor
+          if (retryCount < maxRetries) {
+            retryCount++;
+
+            // Obtener un nuevo servidor objetivo (excluyendo los que ya fallaron)
+            const availableServers = this.serverPool.getHealthyServers().filter(s => s.id !== server.id);
+            if (availableServers.length > 0) {
+              // Seleccionar un nuevo servidor
+              const nextServer = availableServers[(retryCount - 1) % availableServers.length];
+              console.log(`Reintentando con servidor alternativo: ${nextServer.url}`);
+
+              // Volver a intentar la solicitud con el nuevo servidor
+              setTimeout(() => {
+                makeRequest(nextServer).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;
+      });
+    };
+
+    // Intentar enviar la solicitud con reintento si el servidor inicial falla
+    try {
+      await makeRequest(targetServer);
+    } catch (error) {
+      console.error('Error en proxyRequest:', error);
+      if (!clientRes.headersSent) {
+        clientRes.writeHead(500);
+        clientRes.end('Internal Server Error');
       }
     }
   }
@@ -348,6 +413,14 @@ class Balancer {
       this.httpsBalancer.stop();
     }
   }
+
+  /**
+   * Get the post-startup extension API
+   * @returns {PostStartupExtension} The extension API
+   */
+  getPostStartupExtension() {
+    return this.postStartupExtension;
+  }
 }
 
 module.exports = { Balancer };