kukuy 1.6.0 → 1.9.0

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

@@ -0,0 +1,477 @@
+const crypto = require('crypto');
+
+// Almacenamiento de la caché en memoria
+let cacheStorage = new Map();
+let cacheMetadata = new Map(); // Almacenar metadatos como TTL, tamaño, etc.
+
+// Configuración del plugin
+let pluginConfig = {
+  maxCacheSize: 100, // Número máximo de entradas
+  defaultTTL: 300000, // Tiempo de vida por defecto (5 minutos en ms)
+  enableCompression: false,
+  cacheableMethods: ['GET'],
+  cacheableStatusCodes: [200, 201, 204]
+};
+
+// Variable para almacenar temporalmente las solicitudes que están siendo procesadas
+let activeRequests = new Map();
+
+/**
+ * Inicializa el plugin de cache
+ * @param {Object} balancer - Instancia del balanceador
+ */
+async function init(balancer) {
+  console.log('Inicializando plugin de cache robusto...');
+
+  const extension = balancer.getPostStartupExtension();
+
+  // Registrar filtro para procesar solicitudes con la máxima prioridad
+  extension.registerFilter('request_processing', requestProcessingFilter, 0);
+
+  // Registrar hook para cuando se recibe una solicitud
+  extension.registerHook('onRequestReceived', onRequestReceivedHook, 0);
+
+  // Registrar hook para cuando se selecciona un servidor
+  extension.registerHook('onServerSelected', onServerSelectedHook, 0);
+
+  // Registrar hook para cuando la respuesta está lista para ser enviada
+  extension.registerHook('onResponseReady', onResponseReadyHook, 0);
+
+  // Registrar hook para cuando se envía la respuesta
+  extension.registerHook('onResponseSent', onResponseSentHook, 0);
+
+  // Registrar hook para cuando ocurre un error con el servidor
+  extension.registerHook('onServerError', onServerErrorHook, 0);
+
+  // Configurar el plugin con valores del entorno
+  configurePluginFromEnv();
+
+  // Iniciar tarea de limpieza periódica de entradas expiradas
+  startCacheCleanupTask();
+
+  console.log('Plugin de cache robusto inicializado correctamente');
+}
+
+/**
+ * Configura el plugin con valores del entorno
+ */
+function configurePluginFromEnv() {
+  if (process.env.CACHE_MAX_SIZE) {
+    pluginConfig.maxCacheSize = parseInt(process.env.CACHE_MAX_SIZE) || pluginConfig.maxCacheSize;
+  }
+
+  if (process.env.CACHE_DEFAULT_TTL) {
+    pluginConfig.defaultTTL = parseInt(process.env.CACHE_DEFAULT_TTL) || pluginConfig.defaultTTL;
+  }
+
+  if (process.env.CACHE_ENABLE_COMPRESSION) {
+    pluginConfig.enableCompression = process.env.CACHE_ENABLE_COMPRESSION === 'true';
+  }
+
+  if (process.env.CACHEABLE_METHODS) {
+    pluginConfig.cacheableMethods = process.env.CACHEABLE_METHODS.split(',');
+  }
+
+  if (process.env.CACHEABLE_STATUS_CODES) {
+    pluginConfig.cacheableStatusCodes = process.env.CACHEABLE_STATUS_CODES.split(',').map(Number);
+  }
+}
+
+/**
+ * Filtro para procesar solicitudes
+ * @param {Object} data - Datos de la solicitud
+ * @returns {Object} - Resultado del procesamiento
+ */
+async function requestProcessingFilter(data) {
+  const { req, res } = data;
+
+  // Verificar si la solicitud es cacheable
+  if (!isRequestCacheable(req)) {
+    return { allowed: true, cached: false };
+  }
+
+  // Generar clave de caché
+  const cacheKey = generateCacheKey(req);
+
+  // Verificar si está en caché
+  if (cacheStorage.has(cacheKey)) {
+    const cachedEntry = cacheStorage.get(cacheKey);
+    const metadata = cacheMetadata.get(cacheKey);
+
+    // Verificar si no ha expirado
+    if (Date.now() < metadata.expiryTime) {
+      // Enviar respuesta desde caché
+      res.writeHead(cachedEntry.statusCode, cachedEntry.headers);
+      res.end(cachedEntry.body);
+
+      console.log(`\x1b[32m[CACHE-HIT]\x1b[0m Solicitud ${req.method} ${req.url} servida desde caché`);
+      console.log(`\x1b[33m           \x1b[0m → Status: ${cachedEntry.statusCode}, Size: ${cachedEntry.body.length} bytes, TTL restante: ${Math.floor((metadata.expiryTime - Date.now())/1000)}s`);
+      console.log(`\x1b[33m           \x1b[0m → NO SE CONTACTÓ AL SERVIDOR BACKEND`);
+
+      return {
+        allowed: true,
+        cached: true,
+        cacheHit: true,
+        cacheKey
+      };
+    } else {
+      // Eliminar entrada expirada
+      cacheStorage.delete(cacheKey);
+      cacheMetadata.delete(cacheKey);
+      console.log(`\x1b[31m[CACHE-EXPIRED]\x1b[0m Entrada expirada eliminada para ${cacheKey}`);
+    }
+  }
+
+  // No está en caché, permitir que continúe
+  console.log(`\x1b[36m[CACHE-MISS]\x1b[0m Solicitud ${req.method} ${req.url} no está en caché`);
+  console.log(`\x1b[33m           \x1b[0m → SE PROCESARÁ NORMALMENTE Y SE CONTACTARÁ AL SERVIDOR BACKEND`);
+
+  // Guardar la clave de caché en la solicitud para usarla más tarde
+  if (req) {
+    req.cacheKey = cacheKey;
+  }
+
+  return {
+    allowed: true,
+    cached: false,
+    cacheKey
+  };
+}
+
+/**
+ * Hook para cuando se recibe una solicitud
+ * @param {Object} params - Parámetros del hook
+ */
+async function onRequestReceivedHook({ req, res }) {
+  console.log(`[CACHE-PLUGIN] Solicitud recibida: ${req.method} ${req.url}`);
+
+  // Podríamos hacer alguna lógica aquí si es necesario
+}
+
+/**
+ * Hook para cuando se selecciona un servidor
+ * @param {Object} params - Parámetros del hook
+ */
+async function onServerSelectedHook({ req, res, server }) {
+  console.log(`[CACHE-PLUGIN] Servidor seleccionado: ${server.url} para ${req.method} ${req.url}`);
+
+  // Podríamos hacer alguna lógica aquí si es necesario
+}
+
+/**
+ * Hook para cuando la respuesta está lista para ser enviada
+ * @param {Object} params - Parámetros del hook
+ */
+async function onResponseReadyHook({ req, res, serverRes, responseBody, server, responseTime }) {
+  console.log(`\x1b[35m[CACHE-STORE-PREPARING]\x1b[0m Respuesta lista para ${req.url}, tamaño: ${responseBody.length} bytes, código: ${serverRes.statusCode}`);
+  console.log(`\x1b[33m                    \x1b[0m → Proveniente del servidor: ${server.url}`);
+
+  // Verificar si la solicitud original tenía una clave de caché
+  if (req && req.cacheKey) {
+    // Verificar si la respuesta es cacheable
+    if (isResponseCacheable(req, serverRes)) {
+      // Crear entrada de caché
+      const cacheEntry = {
+        statusCode: serverRes.statusCode,
+        headers: { ...serverRes.headers },
+        body: responseBody
+      };
+
+      // Determinar TTL desde headers o usar valor por defecto
+      let ttl = pluginConfig.defaultTTL;
+      if (serverRes.headers['cache-control']) {
+        const cc = serverRes.headers['cache-control'];
+        const maxAgeMatch = cc.match(/max-age=(\d+)/);
+        if (maxAgeMatch) {
+          ttl = parseInt(maxAgeMatch[1]) * 1000; // Convertir a ms
+        }
+      }
+
+      // Crear metadatos
+      const metadata = {
+        expiryTime: Date.now() + ttl,
+        size: responseBody.length,
+        createdAt: Date.now(),
+        ttl: ttl
+      };
+
+      // Verificar límites de caché
+      if (cacheStorage.size >= pluginConfig.maxCacheSize) {
+        // Implementar LRU (eliminar la entrada menos recientemente usada)
+        evictLRUCacheEntry();
+      }
+
+      // Almacenar en caché
+      cacheStorage.set(req.cacheKey, cacheEntry);
+      cacheMetadata.set(req.cacheKey, metadata);
+
+      console.log(`\x1b[32m[CACHE-STORED]\x1b[0m     Almacenada respuesta para ${req.method} ${req.url}`);
+      console.log(`\x1b[33m             \x1b[0m     → TTL: ${ttl}ms, tamaño: ${responseBody.length} bytes`);
+      console.log(`\x1b[33m             \x1b[0m     → Ahora esta respuesta se servirá desde caché`);
+    } else {
+      console.log(`\x1b[31m[CACHE-SKIPPED]\x1b[0m    La respuesta no es cacheable, omitiendo almacenamiento`);
+    }
+  }
+}
+
+/**
+ * Hook para cuando se envía la respuesta
+ * @param {Object} params - Parámetros del hook
+ */
+async function onResponseSentHook({ req, res, serverRes, responseTime, server }) {
+  console.log(`[CACHE-PLUGIN] Respuesta enviada para ${req.url}, tiempo: ${responseTime}ms, código: ${serverRes.statusCode}`);
+
+  // Verificar si la solicitud original tenía una clave de caché
+  if (req && req.cacheKey) {
+    // Verificar si la respuesta es cacheable
+    if (isResponseCacheable(req, serverRes)) {
+      // Almacenar la respuesta en caché
+      storeResponseInCache(req, serverRes, req.cacheKey);
+    }
+  }
+}
+
+/**
+ * Hook para cuando ocurre un error con el servidor
+ * @param {Object} params - Parámetros del hook
+ */
+async function onServerErrorHook(params) {
+  // Extraer parámetros con valores por defecto para evitar errores
+  const { req, res, server, error, responseTime } = params || {};
+
+  // Verificar que req exista antes de continuar
+  if (!req) {
+    console.log(`[CACHE-PLUGIN] Error recibido sin solicitud válida`);
+    return;
+  }
+
+  const serverUrl = server ? server.url : 'desconocido';
+  const errorMessage = error ? error.message || error : 'desconocido';
+
+  console.log(`[CACHE-PLUGIN] Error con servidor ${serverUrl} para ${req.url}: ${errorMessage}`);
+
+  // Solo intentar servir desde caché si no se han enviado headers aún
+  if (res && !res.headersSent) {
+    const cacheKey = generateCacheKey(req);
+
+    if (cacheStorage.has(cacheKey)) {
+      const cachedEntry = cacheStorage.get(cacheKey);
+      const metadata = cacheMetadata.get(cacheKey);
+
+      // Verificar si no ha expirado o si está dentro de un periodo de grace period
+      // (por ejemplo, permitir servir contenido ligeramente expirado mientras se intenta reconectar)
+      const gracePeriod = 300000; // 5 minutos extra como grace period
+      if (Date.now() < metadata.expiryTime + gracePeriod) {
+        // Enviar respuesta desde caché como fallback
+        res.writeHead(cachedEntry.statusCode, cachedEntry.headers);
+        res.end(cachedEntry.body);
+
+        console.log(`\x1b[33m[CACHE-FALLBACK]\x1b[0m Solicitud ${req.method} ${req.url} servida desde caché como fallback`);
+        console.log(`\x1b[33m              \x1b[0m → Servidor backend no disponible, usando versión en caché`);
+
+        return; // No continuar con el manejo de error estándar
+      }
+    }
+  }
+
+  console.log(`\x1b[31m[CACHE-NONE-AVAILABLE]\x1b[0m No hay versión en caché disponible para ${req.url}, servidor no disponible`);
+}
+
+/**
+ * Verifica si una solicitud es cacheable
+ * @param {Object} req - Objeto de solicitud
+ * @returns {boolean} - Verdadero si es cacheable
+ */
+function isRequestCacheable(req) {
+  // Verificar método HTTP
+  if (!pluginConfig.cacheableMethods.includes(req.method)) {
+    return false;
+  }
+
+  // Verificar si tiene encabezados que indican no cachear
+  if (req.headers && req.headers['cache-control'] && req.headers['cache-control'].includes('no-cache')) {
+    return false;
+  }
+
+  if (req.headers && req.headers['pragma'] && req.headers['pragma'].includes('no-cache')) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Verifica si una respuesta es cacheable
+ * @param {Object} req - Objeto de solicitud
+ * @param {Object} res - Objeto de respuesta del servidor backend
+ * @returns {boolean} - Verdadero si es cacheable
+ */
+function isResponseCacheable(req, res) {
+  // Verificar si la solicitud era cacheable
+  if (!isRequestCacheable(req)) {
+    return false;
+  }
+
+  // Verificar código de estado
+  if (!pluginConfig.cacheableStatusCodes.includes(res.statusCode)) {
+    console.log(`[CACHE-DEBUG] Código de estado ${res.statusCode} no es cacheable`);
+    return false;
+  }
+
+  // Verificar encabezados de respuesta
+  if (res.headers && res.headers['cache-control'] && res.headers['cache-control'].includes('no-cache')) {
+    console.log('[CACHE-DEBUG] Header cache-control indica no-cache');
+    return false;
+  }
+
+  if (res.headers && res.headers['pragma'] && res.headers['pragma'].includes('no-cache')) {
+    console.log('[CACHE-DEBUG] Header pragma indica no-cache');
+    return false;
+  }
+
+    console.log(`[CACHE-DEBUG] Respuesta es cacheable: statusCode=${res.statusCode}`);
+  return true;
+}
+
+/**
+ * Genera una clave única para la caché basada en la solicitud
+ * @param {Object} req - Objeto de solicitud
+ * @returns {string} - Clave de caché
+ */
+function generateCacheKey(req) {
+  // Crear una representación única de la solicitud
+  const keyData = {
+    method: req.method,
+    url: req.url,
+    headers: {
+      accept: req.headers.accept,
+      'accept-encoding': req.headers['accept-encoding'],
+      'user-agent': req.headers['user-agent']
+    }
+  };
+
+  // Convertir a string y generar hash
+  const keyString = JSON.stringify(keyData);
+  return crypto.createHash('md5').update(keyString).digest('hex');
+}
+
+/**
+ * Almacena una respuesta en caché
+ * @param {Object} req - Objeto de solicitud
+ * @param {Object} serverRes - Objeto de respuesta del servidor backend
+ * @param {string} cacheKey - Clave de caché
+ */
+function storeResponseInCache(req, serverRes, cacheKey) {
+  // Debido a que no podemos interceptar directamente la respuesta en este punto,
+  // necesitamos una estrategia diferente. Vamos a usar el sistema de hooks
+  // del balanceador para interceptar la respuesta antes de que se envíe al cliente.
+  // Pero como no tenemos un hook específico para eso, vamos a implementar
+  // una solución alternativa registrando un middleware en el servidor proxy.
+  
+  // Esta implementación requiere una modificación en el sistema del balanceador
+  // para permitir la interceptación de la respuesta, lo cual no es posible
+  // directamente desde un plugin sin modificar el código base.
+  
+  // Por lo tanto, implementaremos una solución parcial que registra la intención
+  // de cachear la respuesta, y dejamos que el sistema principal maneje
+  // la captura de la respuesta.
+  
+  console.log(`[CACHE-DEFERRED] Se detectó que la respuesta para ${req.method} ${req.url} debería ser cacheada`);
+  console.log(`[CACHE-DEFERRED] Clave de caché: ${cacheKey}`);
+  
+  // En una implementación completa, aquí conectaríamos con un sistema
+  // que permite interceptar la respuesta del servidor backend antes
+  // de enviarla al cliente, pero eso requiere cambios en el código base.
+}
+
+/**
+ * Elimina la entrada menos recientemente usada de la caché
+ */
+function evictLRUCacheEntry() {
+  let oldestTime = Infinity;
+  let oldestKey = null;
+
+  for (const [key, metadata] of cacheMetadata.entries()) {
+    if (metadata.createdAt < oldestTime) {
+      oldestTime = metadata.createdAt;
+      oldestKey = key;
+    }
+  }
+
+  if (oldestKey) {
+    cacheStorage.delete(oldestKey);
+    cacheMetadata.delete(oldestKey);
+    console.log(`[CACHE-EVICTION] Entrada LRU eliminada: ${oldestKey}`);
+  }
+}
+
+/**
+ * Inicia la tarea de limpieza periódica de entradas expiradas
+ */
+function startCacheCleanupTask() {
+  // Limpiar entradas expiradas cada 5 minutos
+  setInterval(() => {
+    const initialSize = cacheStorage.size;
+    const now = Date.now();
+
+    for (const [key, metadata] of cacheMetadata.entries()) {
+      if (now >= metadata.expiryTime) {
+        cacheStorage.delete(key);
+        cacheMetadata.delete(key);
+      }
+    }
+
+    const removedCount = initialSize - cacheStorage.size;
+    if (removedCount > 0) {
+      console.log(`[CACHE-CLEANUP] Eliminadas ${removedCount} entradas expiradas. Tamaño actual: ${cacheStorage.size}`);
+    }
+  }, 300000); // 5 minutos
+}
+
+/**
+ * Obtiene estadísticas de la caché
+ * @returns {Object} - Estadísticas de la caché
+ */
+function getCacheStats() {
+  return {
+    size: cacheStorage.size,
+    maxSize: pluginConfig.maxCacheSize,
+    utilization: (cacheStorage.size / pluginConfig.maxCacheSize) * 100,
+    entries: Array.from(cacheStorage.keys())
+  };
+}
+
+/**
+ * Limpia toda la caché
+ */
+function clearCache() {
+  cacheStorage.clear();
+  cacheMetadata.clear();
+  console.log('[CACHE-CLEAR] Caché completamente limpiada');
+}
+
+/**
+ * Desinicializa el plugin
+ * @param {Object} balancer - Instancia del balanceador
+ */
+async function deinit(balancer) {
+  console.log('Desactivando plugin de cache robusto...');
+
+  // Limpiar recursos si es necesario
+  cacheStorage.clear();
+  cacheMetadata.clear();
+
+  console.log('Plugin de cache robusto desactivado correctamente');
+}
+
+// Exportar funciones
+module.exports = {
+  init,
+  deinit,
+  getCacheStats,
+  clearCache,
+  // Exportar también funciones útiles para otros módulos
+  isRequestCacheable,
+  isResponseCacheable,
+  generateCacheKey
+};

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

@@ -0,0 +1,17 @@
+{
+  "name": "Plugin de Cache Robusto",
+  "version": "1.0.0",
+  "description": "Plugin para implementar un sistema de cache robusto con hooks y filtros",
+  "author": "Sistema Kukuy",
+  "main": "index.js",
+  "kukuyVersion": "^1.6.0",
+  "hooks": [
+    "onRequestReceived",
+    "onResponseSent",
+    "onServerSelected"
+  ],
+  "filters": [
+    "request_processing"
+  ],
+  "enabled": true
+}

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

@@ -11,11 +11,13 @@ async function init(balancer) {
   // Registrar un filtro de ejemplo
   extension.registerFilter('request_processing', async (data) => {
     const { req, res } = data;
-    console.log(`Plugin: Procesando solicitud ${req.method} ${req.url}`);
-    
-    // Agregar un header personalizado
-    req.headers['x-plugin-example'] = 'activated';
-    
+    if (req && res) {
+      console.log(`Plugin: Procesando solicitud ${req.method} ${req.url}`);
+
+      // Agregar un header personalizado
+      req.headers['x-plugin-example'] = 'activated';
+    }
+
     return { allowed: true };
   }, 5);
   

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

@@ -2,10 +2,10 @@
   "name": "Plugin de Ejemplo",
   "version": "1.0.0",
   "description": "Plugin de ejemplo para demostrar la arquitectura de plugins",
-  "author": "Desarrollador",
+  "author": "kukuy",
   "main": "index.js",
   "kukuyVersion": "^1.6.0",
   "hooks": ["onRequestReceived", "onResponseSent"],
   "filters": ["request_processing"],
-  "enabled": true
+  "enabled": false
 }

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 };