kukuy 1.6.0 → 1.9.0

package/kukuy-plugins/health-checker/manifest.json

@@ -0,0 +1,16 @@
+{
+  "name": "Verificador de Salud Periódica",
+  "version": "1.0.0",
+  "description": "Plugin para verificar periódicamente la salud de los servidores backend",
+  "author": "Sistema Kukuy",
+  "main": "index.js",
+  "kukuyVersion": "^1.6.0",
+  "hooks": [
+    "onHealthCheckStart",
+    "onHealthCheckComplete",
+    "onHealthCheckError",
+    "onHealthCheckTimeout",
+    "onHealthCheckException"
+  ],
+  "enabled": true
+}

package/kukuy-plugins/health-monitor/index.js

@@ -0,0 +1,58 @@
+/**
+ * Plugin de Monitor de Salud de Servidores para Kukuy
+ * Monitorea eventos de verificación de salud de servidores backend
+ */
+
+async function init(balancer) {
+  console.log('Inicializando plugin de monitor de salud de servidores...');
+
+  const extension = balancer.getPostStartupExtension();
+
+  // Hook que se ejecuta cuando comienza la verificación de salud de un servidor
+  extension.registerHook('onHealthCheckStart', async ({ server, checkTime }) => {
+    console.log(`[HEALTH-MONITOR] Iniciando verificación de salud para servidor: ${server.url} (${checkTime})`);
+  }, 5);
+
+  // Hook que se ejecuta cuando se completa la verificación de salud
+  extension.registerHook('onHealthCheckComplete', async ({ server, isHealthy, statusCode, checkTime }) => {
+    const status = isHealthy ? 'SALUDABLE' : 'NO SALUDABLE';
+    console.log(`[HEALTH-MONITOR] Verificación completada para ${server.url} - Estado: ${status} - Código: ${statusCode} (${checkTime})`);
+    
+    // Aquí podrías agregar lógica adicional como alertas o métricas personalizadas
+    if (!isHealthy) {
+      console.warn(`[HEALTH-MONITOR] ¡Alerta! Servidor ${server.url} no está saludable`);
+    }
+  }, 5);
+
+  // Hook que se ejecuta cuando ocurre un error durante la verificación de salud
+  extension.registerHook('onHealthCheckError', async ({ server, error, checkTime }) => {
+    console.error(`[HEALTH-MONITOR] Error en verificación de salud para ${server.url}: ${error.message} (${checkTime})`);
+    
+    // Lógica para manejar errores de verificación
+    console.warn(`[HEALTH-MONITOR] ¡Error crítico! Servidor ${server.url} no pudo ser verificado`);
+  }, 10); // Prioridad alta para errores
+
+  // Hook que se ejecuta cuando ocurre un timeout durante la verificación de salud
+  extension.registerHook('onHealthCheckTimeout', async ({ server, checkTime }) => {
+    console.warn(`[HEALTH-MONITOR] Timeout en verificación de salud para ${server.url} (${checkTime})`);
+    
+    // Lógica para manejar timeouts
+    console.warn(`[HEALTH-MONITOR] ¡Timeout! Servidor ${server.url} no respondió a tiempo`);
+  }, 10); // Prioridad alta para timeouts
+
+  // Hook que se ejecuta cuando ocurre una excepción durante la verificación de salud
+  extension.registerHook('onHealthCheckException', async ({ server, error, checkTime }) => {
+    console.error(`[HEALTH-MONITOR] Excepción en verificación de salud para ${server.url}: ${error.message} (${checkTime})`);
+    
+    // Lógica para manejar excepciones
+    console.error(`[HEALTH-MONITOR] ¡Excepción crítica! Error inesperado verificando ${server.url}`);
+  }, 10); // Prioridad alta para excepciones
+
+  console.log('Plugin de monitor de salud de servidores inicializado correctamente');
+}
+
+async function deinit(balancer) {
+  console.log('Desactivando plugin de monitor de salud de servidores...');
+}
+
+module.exports = { init, deinit };

package/kukuy-plugins/health-monitor/manifest.json

@@ -0,0 +1,16 @@
+{
+  "name": "Monitor de Salud de Servidores",
+  "version": "1.0.0",
+  "description": "Plugin para monitorear eventos de verificación de salud de servidores backend",
+  "author": "Sistema Kukuy",
+  "main": "index.js",
+  "kukuyVersion": "^1.6.0",
+  "hooks": [
+    "onHealthCheckStart", 
+    "onHealthCheckComplete", 
+    "onHealthCheckError", 
+    "onHealthCheckTimeout", 
+    "onHealthCheckException"
+  ],
+  "enabled": true
+}

package/kukuy-plugins/redirect-plugin/index.js

@@ -0,0 +1,172 @@
+/**
+ * Plugin de Redirección para Kukuy
+ * Permite implementar reglas de redirección personalizadas
+ */
+
+// Reglas de redirección
+let redirectRules = [
+  // Ejemplo: redirigir /old-path a /new-path permanentemente
+  // { pattern: /^\/old-path$/, target: '/new-path', type: 'permanent' },
+];
+
+/**
+ * Inicializa el plugin de redirección
+ * @param {Object} balancer - Instancia del balanceador
+ */
+async function init(balancer) {
+  console.log('Inicializando plugin de redirección...');
+
+  const extension = balancer.getPostStartupExtension();
+
+  // Registrar filtro para procesar solicitudes
+  extension.registerFilter('request_processing', requestProcessingFilter, 2);
+
+  // Registrar hook para cuando se recibe una solicitud
+  extension.registerHook('onRequestReceived', onRequestReceivedHook, 2);
+
+  // Cargar reglas de redirección desde el entorno
+  loadRedirectRulesFromEnv();
+
+  console.log('Plugin de redirección inicializado correctamente');
+}
+
+/**
+ * Carga reglas de redirección desde variables de entorno
+ */
+function loadRedirectRulesFromEnv() {
+  if (process.env.REDIRECT_RULES) {
+    try {
+      const rules = JSON.parse(process.env.REDIRECT_RULES);
+      redirectRules = [...redirectRules, ...rules];
+      console.log(`[REDIRECT-PLUGIN] Cargadas ${rules.length} reglas de redirección desde entorno`);
+    } catch (error) {
+      console.error('[REDIRECT-PLUGIN] Error al parsear reglas de redirección desde entorno:', error.message);
+    }
+  }
+}
+
+/**
+ * Filtro para procesar solicitudes
+ * @param {Object} data - Datos de la solicitud
+ * @returns {Object} - Resultado del procesamiento
+ */
+async function requestProcessingFilter(data) {
+  const { req, res } = data;
+
+  // Buscar una regla de redirección que coincida
+  for (const rule of redirectRules) {
+    if (rule.pattern instanceof RegExp) {
+      // Si el patrón es una expresión regular
+      if (rule.pattern.test(req.url)) {
+        // Encontramos una coincidencia, realizar la redirección
+        const target = typeof rule.target === 'function' 
+          ? rule.target(req.url) 
+          : rule.target;
+        
+        const statusCode = rule.type === 'permanent' ? 301 : 302;
+        
+        res.writeHead(statusCode, {
+          'Location': target,
+          'Content-Type': 'text/html'
+        });
+        
+        res.end(`<html><body>Redirigido a <a href="${target}">${target}</a></body></html>`);
+        
+        console.log(`[REDIRECT-PLUGIN] Redirección ${statusCode} de ${req.url} a ${target}`);
+        
+        return { 
+          allowed: false, // Indicar que no debe continuar con el procesamiento normal
+          redirected: true,
+          redirectUrl: target,
+          statusCode
+        };
+      }
+    } else if (typeof rule.pattern === 'string') {
+      // Si el patrón es una cadena, verificar coincidencia exacta o parcial
+      if (req.url === rule.pattern || (rule.partialMatch && req.url.startsWith(rule.pattern))) {
+        // Encontramos una coincidencia, realizar la redirección
+        const target = typeof rule.target === 'function' 
+          ? rule.target(req.url) 
+          : rule.target;
+        
+        const statusCode = rule.type === 'permanent' ? 301 : 302;
+        
+        res.writeHead(statusCode, {
+          'Location': target,
+          'Content-Type': 'text/html'
+        });
+        
+        res.end(`<html><body>Redirigido a <a href="${target}">${target}</a></body></html>`);
+        
+        console.log(`[REDIRECT-PLUGIN] Redirección ${statusCode} de ${req.url} a ${target}`);
+        
+        return { 
+          allowed: false, // Indicar que no debe continuar con el procesamiento normal
+          redirected: true,
+          redirectUrl: target,
+          statusCode
+        };
+      }
+    }
+  }
+
+  // No se encontró ninguna regla de redirección, continuar normalmente
+  return { allowed: true, redirected: false };
+}
+
+/**
+ * Hook para cuando se recibe una solicitud
+ * @param {Object} params - Parámetros del hook
+ */
+async function onRequestReceivedHook({ req, res }) {
+  console.log(`[REDIRECT-PLUGIN] Solicitud recibida: ${req.method} ${req.url}`);
+  
+  // Podríamos hacer alguna lógica aquí si es necesario
+}
+
+/**
+ * Agrega una nueva regla de redirección
+ * @param {Object} rule - Regla de redirección
+ */
+function addRedirectRule(rule) {
+  redirectRules.push(rule);
+  console.log(`[REDIRECT-PLUGIN] Añadida nueva regla de redirección: ${rule.pattern} -> ${rule.target}`);
+}
+
+/**
+ * Obtiene todas las reglas de redirección
+ * @returns {Array} - Array de reglas de redirección
+ */
+function getRedirectRules() {
+  return redirectRules;
+}
+
+/**
+ * Limpia todas las reglas de redirección
+ */
+function clearRedirectRules() {
+  redirectRules = [];
+  console.log('[REDIRECT-PLUGIN] Reglas de redirección limpiadas');
+}
+
+/**
+ * Desinicializa el plugin
+ * @param {Object} balancer - Instancia del balanceador
+ */
+async function deinit(balancer) {
+  console.log('Desactivando plugin de redirección...');
+  
+  // Limpiar recursos si es necesario
+  redirectRules = [];
+  
+  console.log('Plugin de redirección desactivado correctamente');
+}
+
+// Exportar funciones
+module.exports = { 
+  init, 
+  deinit, 
+  addRedirectRule,
+  getRedirectRules,
+  clearRedirectRules
+};

package/kukuy-plugins/redirect-plugin/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "Plugin de Redirección",
+  "version": "1.0.0",
+  "description": "Plugin para implementar redirecciones basadas en reglas personalizadas",
+  "author": "Sistema Kukuy",
+  "main": "index.js",
+  "kukuyVersion": "^1.6.0",
+  "hooks": [
+    "onRequestReceived"
+  ],
+  "filters": [
+    "request_processing"
+  ],
+  "enabled": false
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kukuy",
-  "version": "1.6.0",
-  "description": "Balanceador de carga Backend",
+  "version": "1.9.0",
+  "description": "Balanceador de carga con soporte para hooks, filtros y cache robusto",
   "main": "kukuy.js",
   "scripts": {
     "start": "node kukuy.js",
@@ -9,13 +9,16 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
-    "backend",
     "load-balancer",
     "round-robin",
     "ip-hash",
     "proxy",
     "http",
-    "https"
+    "https",
+    "hooks",
+    "filters",
+    "cache",
+    "plugins"
   ],
   "author": "Benjamín Sánchez Cárdenas",
   "license": "GPL-3.0-or-later",

package/src/core/Balancer.js

@@ -39,7 +39,7 @@ class Balancer {
     this.config = ConfigManager.getInstance();
     this.hookManager = new ExtendedHookManager();
     this.filterChain = new ExtendedFilterChain();
-    this.serverPool = new ServerPool();
+    this.serverPool = new ServerPool(this);
     this.algorithmManager = new AlgorithmManager();
     this.routeLoader = new RouteLoader();
     this.logger = new Logger();
@@ -175,13 +175,16 @@ class Balancer {
 
     // 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;
@@ -191,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}`);
@@ -228,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);
@@ -283,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;
 
@@ -313,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) => {

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/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/plugins/PluginManager.js

@@ -178,6 +178,54 @@ class PluginManager {
       isActive: plugin.isActive
     }));
   }
+
+  /**
+   * Print information about available and loaded plugins to stdout
+   */
+  printPluginsInfo() {
+    console.log('\n========== INFORMACIÓN DE PLUGINS ==========');
+
+    if (!fs.existsSync(this.pluginPath)) {
+      console.log(`Directorio de plugins no encontrado: ${this.pluginPath}`);
+      console.log('=============================================\n');
+      return;
+    }
+
+    const allItems = fs.readdirSync(this.pluginPath);
+    const pluginDirs = allItems.filter(item => this.isDirectory(path.join(this.pluginPath, item)));
+
+    console.log(`Plugins encontrados en ${this.pluginPath}: ${pluginDirs.length}`);
+
+    for (const pluginDir of pluginDirs) {
+      const pluginPath = path.join(this.pluginPath, pluginDir);
+      const manifestPath = path.join(pluginPath, 'manifest.json');
+
+      if (fs.existsSync(manifestPath)) {
+        try {
+          const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+          if (this.plugins.has(pluginDir)) {
+            const plugin = this.plugins.get(pluginDir);
+            console.log(`✓ ACTIVO    - ${pluginDir} (v${manifest.version}): ${manifest.description}`);
+          } else {
+            if (manifest.enabled !== false) {
+              console.log(`○ DISPONIBLE - ${pluginDir} (v${manifest.version}): ${manifest.description}`);
+            } else {
+              console.log(`○ DESHABILITADO - ${pluginDir} (v${manifest.version}): ${manifest.description} (manifest: enabled=false)`);
+            }
+          }
+        } catch (error) {
+          console.log(`✗ ERROR     - ${pluginDir}: Error leyendo manifest.json`);
+        }
+      } else {
+        console.log(`✗ SIN MANIFEST - ${pluginDir}: No tiene archivo manifest.json`);
+      }
+    }
+
+    const loadedCount = this.plugins.size;
+    console.log(`\nTotal de plugins activos: ${loadedCount}`);
+    console.log('=============================================\n');
+  }
 }
 
 module.exports = { PluginManager };