kukuy 1.5.0 → 1.9.0

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

@@ -0,0 +1,168 @@
+const http = require('http');
+const https = require('https');
+const url = require('url');
+
+let healthCheckIntervalId = null;
+
+async function init(balancer) {
+  console.log('Inicializando plugin de verificación de salud periódica...');
+
+  const config = balancer.config;
+  const healthCheckInterval = config.healthCheckInterval || 30000; // 30 segundos por defecto
+  const serverPool = balancer.serverPool;
+
+  // Función para verificar la salud de un servidor
+  async function checkServerHealth(server) {
+    try {
+      const parsedUrl = url.parse(server.url);
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: '/health', // Ruta estándar para verificación de salud
+        method: 'GET',
+        timeout: 5000, // 5 segundos de timeout
+        // Agregar headers para identificar la solicitud de health check
+        headers: {
+          'User-Agent': 'Kukuy-Health-Check/1.0'
+        }
+      };
+
+      // Emitir hook antes de realizar el check
+      await executeHook(balancer, 'onHealthCheckStart', { server, checkTime: new Date() });
+
+      return new Promise((resolve) => {
+        const request = server.protocol === 'https:'
+          ? https.request(options)
+          : http.request(options);
+
+        request.on('response', (res) => {
+          // Consumir el cuerpo de la respuesta para liberar recursos
+          res.resume();
+
+          // Considerar saludable si obtenemos una respuesta exitosa
+          const isHealthy = res.statusCode >= 200 && res.statusCode < 400;
+
+          // Actualizar estado del servidor
+          server.healthy = isHealthy;
+          server.lastChecked = Date.now();
+
+          // Emitir hook después de completar el check
+          executeHook(balancer, 'onHealthCheckComplete', {
+            server,
+            isHealthy,
+            statusCode: res.statusCode,
+            checkTime: new Date()
+          }).then(() => {
+            // Resolver la promesa después de emitir el hook
+            resolve(isHealthy);
+          }).catch(() => {
+            // En caso de error al emitir el hook, resolver igualmente
+            resolve(isHealthy);
+          });
+        });
+
+        request.on('error', (err) => {
+          // Actualizar estado del servidor
+          server.healthy = false;
+          server.lastChecked = Date.now();
+
+          // Emitir hook cuando ocurre un error en el check
+          executeHook(balancer, 'onHealthCheckError', {
+            server,
+            error: err,
+            checkTime: new Date()
+          }).then(() => {
+            resolve(false);
+          }).catch(() => {
+            resolve(false);
+          });
+        });
+
+        request.on('timeout', () => {
+          // Actualizar estado del servidor
+          server.healthy = false;
+          server.lastChecked = Date.now();
+
+          // Emitir hook cuando ocurre un timeout en el check
+          executeHook(balancer, 'onHealthCheckTimeout', {
+            server,
+            checkTime: new Date()
+          }).then(() => {
+            resolve(false);
+          }).catch(() => {
+            resolve(false);
+          });
+        });
+
+        request.end();
+      });
+    } catch (error) {
+      // Emitir hook cuando ocurre una excepción
+      await executeHook(balancer, 'onHealthCheckException', {
+        server,
+        error,
+        checkTime: new Date()
+      });
+      
+      // Actualizar estado del servidor
+      server.healthy = false;
+      server.lastChecked = Date.now();
+      
+      return false;
+    }
+  }
+
+  // Función para verificar la salud de todos los servidores
+  async function checkAllServersHealth() {
+    console.log('[HEALTH-CHECKER] Iniciando verificación de salud periódica...');
+    
+    const servers = serverPool.getServers();
+    
+    for (const server of servers) {
+      console.log(`[HEALTH-CHECKER] Verificando salud de ${server.url}...`);
+      await checkServerHealth(server);
+    }
+    
+    // Invalidar la caché de servidores saludables después de la verificación
+    serverPool.invalidateCache();
+    
+    console.log('[HEALTH-CHECKER] Verificación de salud periódica completada.');
+  }
+
+  // Iniciar verificación de salud periódica
+  healthCheckIntervalId = setInterval(checkAllServersHealth, healthCheckInterval);
+  
+  console.log(`[HEALTH-CHECKER] Verificación de salud periódica iniciada. Intervalo: ${healthCheckInterval}ms`);
+
+  // Realizar una verificación inmediata
+  await checkAllServersHealth();
+}
+
+async function deinit(balancer) {
+  console.log('Desactivando plugin de verificación de salud periódica...');
+  
+  // Detener la verificación de salud periódica
+  if (healthCheckIntervalId) {
+    clearInterval(healthCheckIntervalId);
+    healthCheckIntervalId = null;
+    console.log('[HEALTH-CHECKER] Verificación de salud periódica detenida.');
+  }
+}
+
+/**
+ * Execute a hook if the balancer reference is available
+ * @param {Object} balancer - Reference to the balancer
+ * @param {string} hookName - Name of the hook to execute
+ * @param {Object} data - Data to pass to the hook
+ */
+async function executeHook(balancer, hookName, data) {
+  if (balancer && balancer.hookManager) {
+    try {
+      await balancer.hookManager.executeHooks(hookName, data);
+    } catch (error) {
+      console.error(`Error executing ${hookName} hook:`, error);
+    }
+  }
+}
+
+module.exports = { init, deinit };

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.5.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",
@@ -14,7 +14,11 @@
     "ip-hash",
     "proxy",
     "http",
-    "https"
+    "https",
+    "hooks",
+    "filters",
+    "cache",
+    "plugins"
   ],
   "author": "Benjamín Sánchez Cárdenas",
   "license": "GPL-3.0-or-later",

package/servers_real.json

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