kukuy 1.5.0 → 1.9.0

package/src/plugins/PluginManager.js

@@ -0,0 +1,231 @@
+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
+    }));
+  }
+
+  /**
+   * Print information about available and loaded plugins to stdout
+   */
+  printPluginsInfo() {
+    console.log('\n========== INFORMACIÓN DE PLUGINS ==========');
+
+    if (!fs.existsSync(this.pluginPath)) {
+      console.log(`Directorio de plugins no encontrado: ${this.pluginPath}`);
+      console.log('=============================================\n');
+      return;
+    }
+
+    const allItems = fs.readdirSync(this.pluginPath);
+    const pluginDirs = allItems.filter(item => this.isDirectory(path.join(this.pluginPath, item)));
+
+    console.log(`Plugins encontrados en ${this.pluginPath}: ${pluginDirs.length}`);
+
+    for (const pluginDir of pluginDirs) {
+      const pluginPath = path.join(this.pluginPath, pluginDir);
+      const manifestPath = path.join(pluginPath, 'manifest.json');
+
+      if (fs.existsSync(manifestPath)) {
+        try {
+          const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+          if (this.plugins.has(pluginDir)) {
+            const plugin = this.plugins.get(pluginDir);
+            console.log(`✓ ACTIVO    - ${pluginDir} (v${manifest.version}): ${manifest.description}`);
+          } else {
+            if (manifest.enabled !== false) {
+              console.log(`○ DISPONIBLE - ${pluginDir} (v${manifest.version}): ${manifest.description}`);
+            } else {
+              console.log(`○ DESHABILITADO - ${pluginDir} (v${manifest.version}): ${manifest.description} (manifest: enabled=false)`);
+            }
+          }
+        } catch (error) {
+          console.log(`✗ ERROR     - ${pluginDir}: Error leyendo manifest.json`);
+        }
+      } else {
+        console.log(`✗ SIN MANIFEST - ${pluginDir}: No tiene archivo manifest.json`);
+      }
+    }
+
+    const loadedCount = this.plugins.size;
+    console.log(`\nTotal de plugins activos: ${loadedCount}`);
+    console.log('=============================================\n');
+  }
+}
+
+module.exports = { PluginManager };

package/src/utils/HealthChecker.js

@@ -3,8 +3,9 @@ const https = require('https');
 const url = require('url');
 
 class HealthChecker {
-  constructor() {
+  constructor(balancer = null) {
     this.timeout = 5000; // 5 segundos de timeout
+    this.balancer = balancer; // Referencia al balanceador para acceder a los hooks
   }
 
   async checkServerHealth(server) {
@@ -22,6 +23,9 @@ class HealthChecker {
         }
       };
 
+      // Emitir hook antes de realizar el check
+      await this.executeHook('onHealthCheckStart', { server, checkTime: new Date() });
+
       return new Promise((resolve) => {
         const request = server.protocol === 'https:'
           ? https.request(options)
@@ -33,25 +37,76 @@ class HealthChecker {
 
           // Considerar saludable si obtenemos una respuesta exitosa
           const isHealthy = res.statusCode >= 200 && res.statusCode < 400;
-          resolve(isHealthy);
+
+          // Emitir hook después de completar el check
+          this.executeHook('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) => {
-          // No imprimir errores de health check en consola para evitar spam
-          resolve(false);
+          // Emitir hook cuando ocurre un error en el check
+          this.executeHook('onHealthCheckError', {
+            server,
+            error: err,
+            checkTime: new Date()
+          }).then(() => {
+            // No imprimir errores de health check en consola para evitar spam
+            resolve(false);
+          }).catch(() => {
+            resolve(false);
+          });
         });
 
         request.on('timeout', () => {
-          // No imprimir errores de timeout de health check en consola
-          resolve(false);
+          // Emitir hook cuando ocurre un timeout en el check
+          this.executeHook('onHealthCheckTimeout', {
+            server,
+            checkTime: new Date()
+          }).then(() => {
+            // No imprimir errores de timeout de health check en consola
+            resolve(false);
+          }).catch(() => {
+            resolve(false);
+          });
         });
 
         request.end();
       });
     } catch (error) {
+      // Emitir hook cuando ocurre una excepción
+      await this.executeHook('onHealthCheckException', {
+        server,
+        error,
+        checkTime: new Date()
+      });
       return false;
     }
   }
+
+  /**
+   * Execute a hook if the balancer reference is available
+   * @param {string} hookName - Name of the hook to execute
+   * @param {Object} data - Data to pass to the hook
+   */
+  async executeHook(hookName, data) {
+    if (this.balancer && this.balancer.hookManager) {
+      try {
+        await this.balancer.hookManager.executeHooks(hookName, data);
+      } catch (error) {
+        console.error(`Error executing ${hookName} hook:`, error);
+      }
+    }
+  }
 }
 
 module.exports = { HealthChecker };