kukuy 1.5.0 → 1.6.0

package/src/core/Balancer.js

@@ -18,8 +18,8 @@
 
 const fs = require('fs');
 const url = require('url');
-const { HookManager } = require('../extensibility/HookManager');
-const { FilterChain } = require('../extensibility/FilterChain');
+const { ExtendedHookManager } = require('../extensibility/ExtendedHookManager');
+const { ExtendedFilterChain } = require('../extensibility/ExtendedFilterChain');
 const { ServerPool } = require('./ServerPool');
 const { AlgorithmManager } = require('../algorithms/AlgorithmManager');
 const { ConfigManager } = require('../config/ConfigManager');
@@ -31,12 +31,14 @@ const { HttpsBalancer } = require('../protocol/HttpsBalancer');
 const { ProfessionalMetrics } = require('../utils/ProfessionalMetrics');
 const { WebDashboard } = require('../dashboard/WebDashboard');
 const { WebSocketServer } = require('../dashboard/WebSocketServer');
+const { PostStartupExtension } = require('../extensibility/PostStartupExtension');
+const { PluginManager } = require('../plugins/PluginManager');
 
 class Balancer {
   constructor() {
     this.config = ConfigManager.getInstance();
-    this.hookManager = new HookManager();
-    this.filterChain = new FilterChain();
+    this.hookManager = new ExtendedHookManager();
+    this.filterChain = new ExtendedFilterChain();
     this.serverPool = new ServerPool();
     this.algorithmManager = new AlgorithmManager();
     this.routeLoader = new RouteLoader();
@@ -56,6 +58,64 @@ class Balancer {
 
     // Inicializar servidor WebSocket para datos en tiempo real
     this.webSocketServer = new WebSocketServer(this);
+
+    // Inicializar sistema de extensión post-inicio
+    this.postStartupExtension = new PostStartupExtension(this);
+
+    // Activar plugin de depuración si está habilitado
+    this.initializeDebugPlugin();
+
+    // Inicializar sistema de plugins
+    this.pluginManager = new PluginManager(this);
+  }
+
+  initializeDebugPlugin() {
+    // Verificar si el plugin de depuración está habilitado
+    const debugEnabled = process.env.DEBUG_REQUEST_HEADERS === 'true' ||
+                         process.env.KUKUY_DEBUG_HEADERS === 'true';
+
+    if (debugEnabled) {
+      // Registrar hooks para mostrar encabezados y servidor de destino
+
+      // Hook para mostrar encabezados cuando se recibe una solicitud
+      this.hookManager.addHook('onRequestReceived', ({ req, res }) => {
+        console.log('\n--- Nueva Solicitud Recibida ---');
+        console.log(`Método: ${req.method}`);
+        console.log(`URL: ${req.url}`);
+        console.log('Encabezados:');
+
+        // Mostrar todos los encabezados de la solicitud
+        for (const [header, value] of Object.entries(req.headers)) {
+          console.log(`  ${header}: ${value}`);
+        }
+
+        console.log('-----------------------------\n');
+      });
+
+      // Hook para mostrar el servidor de destino asignado
+      this.hookManager.addHook('onServerSelected', ({ req, res, server }) => {
+        console.log('\n--- Servidor de Destino Asignado ---');
+        console.log(`Solicitud: ${req.method} ${req.url}`);
+        console.log(`Servidor destino: ${server.url}`);
+        console.log(`ID del servidor: ${server.id}`);
+        console.log(`Protocolo: ${server.protocol}`);
+        console.log(`Host: ${server.host}`);
+        console.log(`Etiquetas: ${server.tags.join(', ') || 'ninguna'}`);
+        console.log('----------------------------------\n');
+      });
+
+      // Hook para mostrar información cuando se envía la respuesta
+      this.hookManager.addHook('onResponseSent', ({ req, res, serverRes, responseTime }) => {
+        console.log('\n--- Respuesta Enviada ---');
+        console.log(`Solicitud: ${req.method} ${req.url}`);
+        console.log(`Código de estado: ${serverRes.statusCode}`);
+        console.log(`Tiempo de respuesta: ${responseTime}ms`);
+        console.log('------------------------\n');
+      });
+
+      console.log('Plugin de depuración de solicitud activado');
+      console.log('Mostrando encabezados de solicitud y servidores de destino en stdout');
+    }
   }
 
   loadConfiguration() {
@@ -88,7 +148,7 @@ class Balancer {
     }
   }
 
-  start() {
+  async start() {
     // Crear servidor HTTP usando HttpBalancer
     if (this.config.httpPort) {
       this.httpBalancer = new HttpBalancer(this.config.httpPort, this.handleRequest.bind(this));
@@ -112,6 +172,9 @@ class Balancer {
     // Iniciar servidor WebSocket para datos en tiempo real
     const wsPort = process.env.WEBSOCKET_PORT || 8083;
     this.webSocketServer.start(wsPort);
+
+    // Cargar plugins después de iniciar componentes principales
+    await this.pluginManager.loadPlugins();
   }
 
   async handleRequest(clientReq, clientRes) {
@@ -350,6 +413,14 @@ class Balancer {
       this.httpsBalancer.stop();
     }
   }
+
+  /**
+   * Get the post-startup extension API
+   * @returns {PostStartupExtension} The extension API
+   */
+  getPostStartupExtension() {
+    return this.postStartupExtension;
+  }
 }
 
 module.exports = { Balancer };

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