kukuy 1.5.0 → 1.9.0

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,13 +31,15 @@ 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.serverPool = new ServerPool();
+    this.hookManager = new ExtendedHookManager();
+    this.filterChain = new ExtendedFilterChain();
+    this.serverPool = new ServerPool(this);
     this.algorithmManager = new AlgorithmManager();
     this.routeLoader = new RouteLoader();
     this.logger = new Logger();
@@ -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,13 +172,19 @@ 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();
+
+    // Imprimir información sobre los plugins disponibles y activos
+    this.pluginManager.printPluginsInfo();
   }
 
   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);
+      const filteredResult = await this.filterChain.applyFilters('request_processing', clientReq, clientRes);
 
       if (!filteredResult || !filteredResult.allowed) {
         const statusCode = filteredResult?.statusCode || 403;
@@ -128,27 +194,16 @@ class Balancer {
         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');
+      // Verificar si el filtro indicó que la respuesta se sirvió desde caché
+      if (filteredResult?.cached && filteredResult?.cacheHit) {
+        // La respuesta ya fue enviada desde el filtro de caché, terminamos aquí
+        // No debemos continuar con ningún otro procesamiento
         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);
+      // Si llegamos aquí, no hubo cache hit, continuar con el flujo normal
+      // y permitir que se ejecuten los hooks y se contacte al servidor backend
+      await this.processRequestNormally(clientReq, clientRes);
 
     } catch (error) {
       this.logger.error(`Error manejando solicitud: ${error.message}`);
@@ -165,6 +220,36 @@ class Balancer {
     }
   }
 
+  async processRequestNormally(clientReq, clientRes) {
+    // 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
+    });
+
+    // Verificar si después de los hooks la respuesta ya fue enviada
+    // (esto cubre el caso de onServerError u otros hooks que puedan enviar respuesta desde la caché)
+    if (clientRes.headersSent) {
+      return;
+    }
+
+    // Reenviar solicitud al servidor backend
+    this.proxyRequest(clientReq, clientRes, targetServer);
+  }
+
   async getTargetServer(requestUrl, method, clientReq = null) {
     // Usar RouteLoader para encontrar la ruta coincidente
     const matchedRoute = this.routeLoader.findMatchingRoute(requestUrl, method);
@@ -220,12 +305,6 @@ class Balancer {
         clientReq.pipe(proxyReq);
 
         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;
 
@@ -250,16 +329,66 @@ class Balancer {
           // Actualizar estado del servidor en las métricas
           this.metricsCollector.updateServerStatus(server.id, 'online');
 
-          // Emitir hook cuando se envía la respuesta
-          this.hookManager.executeHooks('onResponseSent', {
-            req: clientReq,
-            res: clientRes,
-            serverRes,
-            server,
-            responseTime
+          // Capturar el cuerpo de la respuesta para posibles plugins
+          let responseData = [];
+
+          serverRes.on('data', (chunk) => {
+            responseData.push(chunk);
           });
 
-          resolve(); // Resolver la promesa al completar la solicitud
+          serverRes.on('end', () => {
+            const responseBody = Buffer.concat(responseData);
+
+            // Emitir hook antes de enviar la respuesta al cliente
+            // Esto permite a los plugins interceptar la respuesta
+            this.hookManager.executeHooks('onResponseReady', {
+              req: clientReq,
+              res: clientRes,
+              serverRes,
+              responseBody,
+              server,
+              responseTime
+            }).then(() => {
+              // Si algún plugin ha manejado la respuesta, no la enviamos aquí
+              if (!clientRes.headersSent) {
+                // Copiar headers de la respuesta
+                clientRes.writeHead(serverRes.statusCode, serverRes.headers);
+
+                // Enviar cuerpo de la respuesta al cliente
+                clientRes.end(responseBody);
+              }
+
+              // Emitir hook cuando se envía la respuesta
+              this.hookManager.executeHooks('onResponseSent', {
+                req: clientReq,
+                res: clientRes,
+                serverRes,
+                server,
+                responseTime
+              });
+
+              resolve(); // Resolver la promesa al completar la solicitud
+            }).catch(err => {
+              console.error('Error ejecutando hook onResponseReady:', err);
+
+              // En caso de error, enviar la respuesta de todas formas
+              if (!clientRes.headersSent) {
+                clientRes.writeHead(serverRes.statusCode, serverRes.headers);
+                clientRes.end(responseBody);
+              }
+
+              // Emitir hook cuando se envía la respuesta
+              this.hookManager.executeHooks('onResponseSent', {
+                req: clientReq,
+                res: clientRes,
+                serverRes,
+                server,
+                responseTime
+              });
+
+              resolve(); // Resolver la promesa al completar la solicitud
+            });
+          });
         });
 
         proxyReq.on('error', async (err) => {
@@ -350,6 +479,14 @@ class Balancer {
       this.httpsBalancer.stop();
     }
   }
+
+  /**
+   * Get the post-startup extension API
+   * @returns {PostStartupExtension} The extension API
+   */
+  getPostStartupExtension() {
+    return this.postStartupExtension;
+  }
 }
 
 module.exports = { Balancer };

package/src/core/ServerPool.js

@@ -1,12 +1,12 @@
 const { HealthChecker } = require('../utils/HealthChecker');
 
 class ServerPool {
-  constructor() {
+  constructor(balancer = null) {
     this.servers = [];
     this.healthyServers = []; // Caché de servidores saludables
     this.serversById = new Map(); // Acceso rápido por ID
     this.serversByTag = new Map(); // Caché de servidores por tag
-    this.healthChecker = new HealthChecker();
+    this.healthChecker = new HealthChecker(balancer);
     this.nextId = 1;
     this.cacheValid = false; // Indicador de validez de caché
   }

package/src/extensibility/ExtendedFilterChain.js

@@ -0,0 +1,90 @@
+const { FilterChain } = require('./FilterChain');
+
+/**
+ * Extended FilterChain that allows registering filters after startup
+ */
+class ExtendedFilterChain {
+  constructor() {
+    // Create a new instance of the original FilterChain
+    this.originalFilterChain = new FilterChain();
+
+    // Storage for post-startup filters
+    this.postStartupFilters = {
+      request_processing: [] // Using the same hook type as original
+    };
+  }
+
+  /**
+   * Register a filter after startup
+   * @param {string} type - Type of filter ('request_processing' for now)
+   * @param {Function} filterFunction - The filter function to register
+   * @param {number} priority - Priority of the filter (lower numbers execute first)
+   */
+  registerFilter(type, filterFunction, priority = 0) {
+    if (!this.postStartupFilters[type]) {
+      this.postStartupFilters[type] = [];
+    }
+
+    // Insert filter according to priority
+    const filterObj = {
+      fn: filterFunction,
+      priority,
+      id: this.generateId()
+    };
+
+    this.postStartupFilters[type].push(filterObj);
+    this.postStartupFilters[type].sort((a, b) => a.priority - b.priority);
+
+    // Also add to the original hook system
+    this.originalFilterChain.addFilter(type, filterFunction);
+
+    console.log(`Filter registered for ${type} with priority ${priority}`);
+  }
+
+  /**
+   * Unregister a specific filter
+   * @param {string} type - Type of filter
+   * @param {string} filterId - ID of the filter to remove
+   */
+  unregisterFilter(type, filterId) {
+    if (this.postStartupFilters[type]) {
+      this.postStartupFilters[type] = this.postStartupFilters[type].filter(f => f.id !== filterId);
+    }
+  }
+
+  /**
+   * Apply all filters of a specific type
+   * @param {string} type - Type of filter
+   * @param {Object} req - Request object
+   * @param {Object} res - Response object
+   * @param {Object} additionalData - Additional data to pass to filters
+   * @returns {Object} Result of filter processing
+   */
+  async applyFilters(type, req, res, additionalData = {}) {
+    // Apply filters using the original system which now includes post-startup filters
+    return await this.originalFilterChain.applyFilters(type, req, res, additionalData);
+  }
+
+  /**
+   * Generate a unique ID
+   * @returns {string} Unique identifier
+   */
+  generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).substr(2);
+  }
+
+  // Proxy other methods to the original FilterChain
+  addFilter(filterName, filterFunction) {
+    this.originalFilterChain.addFilter(filterName, filterFunction);
+  }
+
+  applySpecificFilter(filterName, data) {
+    return this.originalFilterChain.applySpecificFilter(filterName, data);
+  }
+
+  getCacheStats() {
+    return this.originalFilterChain.getCacheStats();
+  }
+}
+
+module.exports = { ExtendedFilterChain };

package/src/extensibility/ExtendedHookManager.js

@@ -0,0 +1,87 @@
+const { HookManager } = require('./HookManager');
+
+/**
+ * Extended HookManager that allows registering hooks after startup
+ */
+class ExtendedHookManager {
+  constructor() {
+    // Create a new instance of the original HookManager
+    this.originalHookManager = new HookManager();
+
+    // Storage for post-startup hooks
+    this.postStartupHooks = {};
+  }
+
+  /**
+   * Register a hook after startup
+   * @param {string} hookName - Name of the hook
+   * @param {Function} callback - The callback function to register
+   * @param {number} priority - Priority of the hook (lower numbers execute first)
+   */
+  registerHook(hookName, callback, priority = 0) {
+    if (!this.postStartupHooks[hookName]) {
+      this.postStartupHooks[hookName] = [];
+    }
+
+    const hookObj = {
+      callback,
+      priority,
+      id: this.generateId()
+    };
+
+    this.postStartupHooks[hookName].push(hookObj);
+    this.postStartupHooks[hookName].sort((a, b) => a.priority - b.priority);
+
+    // Add to the original hook system
+    this.originalHookManager.addHook(hookName, callback);
+
+    console.log(`Hook registered: ${hookName} with priority ${priority}`);
+  }
+
+  /**
+   * Unregister a specific hook
+   * @param {string} hookName - Name of the hook
+   * @param {string} hookId - ID of the hook to remove
+   */
+  unregisterHook(hookName, hookId) {
+    if (this.postStartupHooks[hookName]) {
+      this.postStartupHooks[hookName] = this.postStartupHooks[hookName].filter(h => h.id !== hookId);
+    }
+  }
+
+  /**
+   * Execute all hooks for a specific event
+   * @param {string} hookName - Name of the hook
+   * @param {Object} data - Data to pass to the hooks
+   */
+  async executeHooks(hookName, data) {
+    // Execute hooks using the original system which now includes post-startup hooks
+    return await this.originalHookManager.executeHooks(hookName, data);
+  }
+
+  /**
+   * Generate a unique ID
+   * @returns {string} Unique identifier
+   */
+  generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).substr(2);
+  }
+
+  // Proxy other methods to the original HookManager
+  addHook(hookName, callback) {
+    this.originalHookManager.addHook(hookName, callback);
+  }
+
+  executeHooks(hookName, data) {
+    return this.originalHookManager.executeHooks(hookName, data);
+  }
+
+  getRegisteredHooks() {
+    return Object.keys(this.postStartupHooks).reduce((acc, hookName) => {
+      acc[hookName] = this.postStartupHooks[hookName].length;
+      return acc;
+    }, {});
+  }
+}
+
+module.exports = { ExtendedHookManager };

package/src/extensibility/FilterChain.js

@@ -35,14 +35,6 @@ class FilterChain {
   }
 
   async applyFilters(type, req, res, additionalData = {}) {
-    // Verificar si la solicitud puede ser atendida desde caché
-    const cacheResult = await this.cachingFilter.apply(req, res, additionalData);
-
-    // Si fue un hit de caché, retornar inmediatamente
-    if (cacheResult.cached && cacheResult.cacheHit) {
-      return cacheResult;
-    }
-
     // Usar el sistema de filtros de la librería para otros filtros
     // Creamos un objeto combinado para pasar al filtro
     const filterData = { req, res, ...additionalData, allowed: true, statusCode: 200, message: '' };
@@ -51,7 +43,8 @@ class FilterChain {
     const processedData = this.hooks.applyFilters('request_processing', filterData);
 
     // Devolver el resultado procesado
-    return { ...processedData, ...cacheResult };
+    // Nota: El manejo de caché ahora se delega a los plugins registrados
+    return processedData;
   }
 
   // Filtro de autenticación básico

package/src/extensibility/HookManager.js

@@ -11,6 +11,7 @@ class HookManager {
     const hookNames = [
       'onRequestReceived',
       'onServerSelected',
+      'onResponseReady',
       'onResponseSent',
       'onServerError'
     ];

package/src/extensibility/PostStartupExtension.js

@@ -0,0 +1,97 @@
+/**
+ * API for registering extensions after Kukuy startup
+ */
+class PostStartupExtension {
+  constructor(balancer) {
+    this.balancer = balancer;
+  }
+
+  /**
+   * Register a filter after startup
+   * @param {string} type - Type of filter ('request_processing' for now)
+   * @param {Function} filterFunction - The filter function to register
+   * @param {number} priority - Priority of the filter (lower numbers execute first)
+   */
+  registerFilter(type, filterFunction, priority = 0) {
+    if (this.balancer.filterChain && typeof this.balancer.filterChain.registerFilter === 'function') {
+      this.balancer.filterChain.registerFilter(type, filterFunction, priority);
+    } else {
+      console.error('FilterChain no disponible o registerFilter no es una función');
+    }
+  }
+
+  /**
+   * Unregister a filter
+   * @param {string} type - Type of filter
+   * @param {string} filterId - ID of the filter to remove
+   */
+  unregisterFilter(type, filterId) {
+    if (this.balancer.filterChain && typeof this.balancer.filterChain.unregisterFilter === 'function') {
+      this.balancer.filterChain.unregisterFilter(type, filterId);
+    } else {
+      console.error('FilterChain no disponible o unregisterFilter no es una función');
+    }
+  }
+
+  /**
+   * Register a hook after startup
+   * @param {string} hookName - Name of the hook
+   * @param {Function} callback - The callback function to register
+   * @param {number} priority - Priority of the hook (lower numbers execute first)
+   */
+  registerHook(hookName, callback, priority = 0) {
+    if (this.balancer.hookManager && typeof this.balancer.hookManager.registerHook === 'function') {
+      this.balancer.hookManager.registerHook(hookName, callback, priority);
+    } else {
+      console.error('HookManager no disponible o registerHook no es una función');
+    }
+  }
+
+  /**
+   * Unregister a hook
+   * @param {string} hookName - Name of the hook
+   * @param {string} hookId - ID of the hook to remove
+   */
+  unregisterHook(hookName, hookId) {
+    if (this.balancer.hookManager && typeof this.balancer.hookManager.unregisterHook === 'function') {
+      this.balancer.hookManager.unregisterHook(hookName, hookId);
+    } else {
+      console.error('HookManager no disponible o unregisterHook no es una función');
+    }
+  }
+
+  /**
+   * Get access to system components
+   * @param {string} componentName - Name of the component to access
+   * @returns {Object} The requested component or null
+   */
+  getComponent(componentName) {
+    switch(componentName) {
+      case 'serverPool':
+        return this.balancer.serverPool;
+      case 'algorithmManager':
+        return this.balancer.algorithmManager;
+      case 'metricsCollector':
+        return this.balancer.metricsCollector;
+      case 'config':
+        return this.balancer.config;
+      case 'routeLoader':
+        return this.balancer.routeLoader;
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Get information about registered hooks
+   * @returns {Object} Information about registered hooks
+   */
+  getRegisteredHooks() {
+    if (this.balancer.hookManager && typeof this.balancer.hookManager.getRegisteredHooks === 'function') {
+      return this.balancer.hookManager.getRegisteredHooks();
+    }
+    return {};
+  }
+}
+
+module.exports = { PostStartupExtension };