kukuy 1.5.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

@@ -0,0 +1,41 @@
+/**
+ * Plugin de ejemplo para Kukuy
+ * Demuestra cómo crear un plugin que se carga automáticamente
+ */
+
+async function init(balancer) {
+  console.log('Inicializando plugin de ejemplo...');
+  
+  const extension = balancer.getPostStartupExtension();
+  
+  // Registrar un filtro de ejemplo
+  extension.registerFilter('request_processing', async (data) => {
+    const { req, res } = data;
+    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);
+  
+  // Registrar un hook para cuando se recibe una solicitud
+  extension.registerHook('onRequestReceived', async ({ req, res }) => {
+    console.log(`Plugin: Solicitud recibida - ${req.method} ${req.url}`);
+  }, 5);
+  
+  // Registrar un hook para cuando se envía la respuesta
+  extension.registerHook('onResponseSent', async ({ req, res, serverRes, responseTime }) => {
+    console.log(`Plugin: Respuesta enviada para ${req.url} en ${responseTime}ms`);
+  }, 5);
+  
+  console.log('Plugin de ejemplo inicializado correctamente');
+}
+
+async function deinit(balancer) {
+  console.log('Desactivando plugin de ejemplo...');
+}
+
+module.exports = { init, deinit };

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

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