kukuy 1.4.0 → 1.6.0

package/src/core/ServerPool.js

@@ -3,8 +3,12 @@ const { HealthChecker } = require('../utils/HealthChecker');
 class ServerPool {
   constructor() {
     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.nextId = 1;
+    this.cacheValid = false; // Indicador de validez de caché
   }
 
   addServer(serverConfig) {
@@ -22,6 +26,12 @@ class ServerPool {
     };
 
     this.servers.push(server);
+    this.serversById.set(server.id, server);
+
+    // Actualizar cachés
+    this.updateTagCache(server);
+    this.cacheValid = false;
+
     return server;
   }
 
@@ -36,19 +46,39 @@ class ServerPool {
   }
 
   getHealthyServers() {
-    return this.servers.filter(server => server.healthy && server.active);
+    if (!this.cacheValid) {
+      this.healthyServers = this.servers.filter(server => server.healthy && server.active);
+      this.cacheValid = true;
+    }
+    return this.healthyServers;
   }
 
   getServersByTag(tag) {
-    return this.servers.filter(server => server.tags.includes(tag));
+    if (this.serversByTag.has(tag)) {
+      return this.serversByTag.get(tag);
+    }
+    return [];
+  }
+
+  // Actualiza la caché de servidores por tag
+  updateTagCache(server) {
+    for (const tag of server.tags) {
+      if (!this.serversByTag.has(tag)) {
+        this.serversByTag.set(tag, []);
+      }
+      this.serversByTag.get(tag).push(server);
+    }
   }
 
   markServerAsFailed(serverId) {
-    const server = this.servers.find(s => s.id === serverId);
+    const server = this.serversById.get(serverId);
     if (server) {
       server.failedAttempts++;
       server.healthy = false;
-      
+
+      // Invalidar caché porque un servidor cambió de estado
+      this.cacheValid = false;
+
       // Programar verificación de salud después de un tiempo
       setTimeout(() => {
         this.healthChecker.checkServerHealth(server)
@@ -57,11 +87,17 @@ class ServerPool {
               server.healthy = true;
               server.failedAttempts = 0;
               server.lastChecked = Date.now();
+
+              // Invalidar caché porque un servidor cambió de estado
+              this.cacheValid = false;
             } else {
               server.lastChecked = Date.now();
               // Si ha fallado demasiadas veces, mantenerlo inactivo
               if (server.failedAttempts > 5) {
                 server.active = false;
+
+                // Invalidar caché porque un servidor cambió de estado
+                this.cacheValid = false;
               }
             }
           });
@@ -70,7 +106,12 @@ class ServerPool {
   }
 
   getServerById(serverId) {
-    return this.servers.find(server => server.id === serverId);
+    return this.serversById.get(serverId);
+  }
+
+  // Método para invalidar la caché manualmente si es necesario
+  invalidateCache() {
+    this.cacheValid = false;
   }
 }
 

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

package/src/plugins/PluginManager.js

@@ -0,0 +1,183 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * PluginInstance represents a loaded plugin instance
+ */
+class PluginInstance {
+  constructor(name, manifest, module, balancer) {
+    this.name = name;
+    this.manifest = manifest;
+    this.module = module;
+    this.balancer = balancer;
+    this.isActive = false;
+  }
+
+  async activate() {
+    if (typeof this.module.init === 'function') {
+      await this.module.init(this.balancer);
+    }
+    this.isActive = true;
+  }
+
+  async deactivate() {
+    if (typeof this.module.deinit === 'function') {
+      await this.module.deinit(this.balancer);
+    }
+    this.isActive = false;
+  }
+}
+
+/**
+ * PluginManager handles the discovery and loading of plugins
+ */
+class PluginManager {
+  constructor(balancer) {
+    this.balancer = balancer;
+    this.plugins = new Map();
+    this.pluginPath = process.env.PLUGINS_DIR || './kukuy-plugins';
+  }
+
+  /**
+   * Check if a path is a directory
+   * @param {string} filePath - Path to check
+   * @returns {boolean} - True if path is a directory
+   */
+  isDirectory(filePath) {
+    try {
+      const stat = fs.statSync(filePath);
+      return stat.isDirectory();
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Load all plugins from the plugins directory
+   */
+  async loadPlugins() {
+    if (!fs.existsSync(this.pluginPath)) {
+      console.log(`Plugin directory not found: ${this.pluginPath}`);
+      return;
+    }
+
+    const pluginDirs = fs.readdirSync(this.pluginPath)
+      .filter(item => this.isDirectory(path.join(this.pluginPath, item)));
+
+    console.log(`Found ${pluginDirs.length} potential plugins in ${this.pluginPath}`);
+
+    for (const pluginDir of pluginDirs) {
+      await this.loadPlugin(pluginDir);
+    }
+  }
+
+  /**
+   * Load a single plugin
+   * @param {string} pluginDir - Name of the plugin directory
+   */
+  async loadPlugin(pluginDir) {
+    const pluginPath = path.join(this.pluginPath, pluginDir);
+    const manifestPath = path.join(pluginPath, 'manifest.json');
+
+    if (!fs.existsSync(manifestPath)) {
+      console.warn(`Plugin ${pluginDir} does not have manifest.json, skipping...`);
+      return;
+    }
+
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      
+      if (!this.validateManifest(manifest)) {
+        console.error(`Invalid manifest for plugin ${pluginDir}`);
+        return;
+      }
+
+      // Check Kukuy version compatibility
+      if (!this.isCompatibleVersion(manifest.kukuyVersion)) {
+        console.error(`Plugin ${pluginDir} requires incompatible Kukuy version: ${manifest.kukuyVersion}`);
+        return;
+      }
+
+      if (!manifest.enabled) {
+        console.log(`Plugin ${pluginDir} is disabled`);
+        return;
+      }
+
+      const mainPath = path.join(pluginPath, manifest.main || 'index.js');
+      if (!fs.existsSync(mainPath)) {
+        console.error(`Main file not found for plugin ${pluginDir}: ${mainPath}`);
+        return;
+      }
+
+      // Resolve the path to avoid conflicts with other requires
+      const pluginModule = require(path.resolve(mainPath));
+      const pluginInstance = new PluginInstance(pluginDir, manifest, pluginModule, this.balancer);
+      
+      this.plugins.set(pluginDir, pluginInstance);
+      await pluginInstance.activate();
+      
+      console.log(`Plugin ${pluginDir} loaded successfully`);
+    } catch (error) {
+      console.error(`Error loading plugin ${pluginDir}:`, error);
+    }
+  }
+
+  /**
+   * Validate the plugin manifest
+   * @param {Object} manifest - The manifest object to validate
+   * @returns {boolean} - True if manifest is valid
+   */
+  validateManifest(manifest) {
+    const requiredFields = ['name', 'version', 'description', 'main'];
+    const isValid = requiredFields.every(field => manifest.hasOwnProperty(field));
+    
+    if (!isValid) {
+      console.error('Missing required fields in manifest:', requiredFields.filter(field => !manifest.hasOwnProperty(field)));
+    }
+    
+    return isValid;
+  }
+
+  /**
+   * Check if the plugin is compatible with current Kukuy version
+   * @param {string} requiredVersion - Version requirement from manifest
+   * @returns {boolean} - True if compatible
+   */
+  isCompatibleVersion(requiredVersion) {
+    if (!requiredVersion) {
+      // If no version specified, assume compatibility
+      return true;
+    }
+
+    // Simple version check - in a real implementation, you'd want to use semver
+    const currentVersion = require('../../package.json').version;
+    
+    // For now, just check if the major version matches or if it's a compatible range
+    if (requiredVersion.startsWith('^')) {
+      const requiredMajor = requiredVersion.slice(1).split('.')[0];
+      const currentMajor = currentVersion.split('.')[0];
+      return currentMajor === requiredMajor;
+    } else if (requiredVersion.startsWith('~')) {
+      const [reqMajor, reqMinor] = requiredVersion.slice(1).split('.');
+      const [curMajor, curMinor] = currentVersion.split('.');
+      return currentMajor === reqMajor && currentMinor === reqMinor;
+    } else {
+      return currentVersion === requiredVersion;
+    }
+  }
+
+  /**
+   * Get information about loaded plugins
+   * @returns {Array} - Array of plugin information
+   */
+  getLoadedPlugins() {
+    return Array.from(this.plugins.values()).map(plugin => ({
+      name: plugin.name,
+      version: plugin.manifest.version,
+      description: plugin.manifest.description,
+      isActive: plugin.isActive
+    }));
+  }
+}
+
+module.exports = { PluginManager };

package/src/utils/HealthChecker.js

@@ -15,34 +15,40 @@ class HealthChecker {
         port: parsedUrl.port,
         path: '/health', // Ruta estándar para verificación de salud
         method: 'GET',
-        timeout: this.timeout
+        timeout: this.timeout,
+        // Agregar headers para identificar la solicitud de health check
+        headers: {
+          'User-Agent': 'Kukuy-Health-Check/1.0'
+        }
       };
 
       return new Promise((resolve) => {
-        const request = server.protocol === 'https:' 
+        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;
           resolve(isHealthy);
         });
 
         request.on('error', (err) => {
-          console.error(`Error verificando salud de ${server.url}: ${err.message}`);
+          // No imprimir errores de health check en consola para evitar spam
           resolve(false);
         });
 
         request.on('timeout', () => {
-          console.error(`Timeout verificando salud de ${server.url}`);
+          // No imprimir errores de timeout de health check en consola
           resolve(false);
         });
 
         request.end();
       });
     } catch (error) {
-      console.error(`Error en la verificación de salud: ${error.message}`);
       return false;
     }
   }