kukuy 1.4.0

package/src/core/RoundRobinAlgorithm.js

@@ -0,0 +1,60 @@
+class RoundRobinAlgorithm {
+  constructor(serverPool) {
+    this.serverPool = serverPool;
+    this.currentIndex = 0;
+  }
+
+  selectServer(servers = null) {
+    // Obtener servidores disponibles (si se pasan servers específicos, usarlos; sino, usar todos)
+    let availableServers = servers || this.serverPool.getHealthyServers();
+
+    // Filtrar servidores activos
+    availableServers = availableServers.filter(server => server.active !== false);
+
+    if (availableServers.length === 0) {
+      return null;
+    }
+
+    // Intentar encontrar un servidor disponible usando round robin
+    // Si el servidor actual no está disponible, buscar el siguiente disponible
+    for (let i = 0; i < availableServers.length; i++) {
+      const candidateIndex = (this.currentIndex + i) % availableServers.length;
+      const candidateServer = availableServers[candidateIndex];
+
+      // Verificar si el servidor candidato está realmente disponible
+      if (this.isServerAvailable(candidateServer)) {
+        this.currentIndex = candidateIndex + 1; // Preparar para la próxima selección
+        return candidateServer;
+      }
+    }
+
+    // Si ningún servidor está disponible, devolver null
+    return null;
+  }
+
+  // Método para verificar si un servidor está disponible
+  isServerAvailable(server) {
+    // Un servidor está disponible si:
+    // 1. Está marcado como healthy
+    // 2. Está activo
+    // 3. No ha superado el número máximo de intentos fallidos
+    return server.healthy && server.active && server.failedAttempts < 5;
+  }
+
+  // Método para seleccionar un servidor con reintento automático
+  async selectServerWithRetry(servers = null, maxRetries = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      const server = this.selectServer(servers);
+      if (server) {
+        return server;
+      }
+      // Si no hay servidores disponibles, esperar un poco antes de reintentar
+      if (attempt < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, 100)); // Esperar 100ms
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = { RoundRobinAlgorithm };

package/src/core/ServerPool.js

@@ -0,0 +1,77 @@
+const { HealthChecker } = require('../utils/HealthChecker');
+
+class ServerPool {
+  constructor() {
+    this.servers = [];
+    this.healthChecker = new HealthChecker();
+    this.nextId = 1;
+  }
+
+  addServer(serverConfig) {
+    const server = {
+      id: this.nextId++,
+      url: serverConfig.url,
+      protocol: serverConfig.url.startsWith('https') ? 'https:' : 'http:',
+      host: new URL(serverConfig.url).host,
+      weight: serverConfig.weight || 1,
+      active: serverConfig.active !== false, // Por defecto activo
+      tags: serverConfig.tags || [],
+      failedAttempts: 0,
+      lastChecked: Date.now(),
+      healthy: true
+    };
+
+    this.servers.push(server);
+    return server;
+  }
+
+  addServers(serversConfig) {
+    serversConfig.forEach(serverConfig => {
+      this.addServer(serverConfig);
+    });
+  }
+
+  getServers() {
+    return this.servers;
+  }
+
+  getHealthyServers() {
+    return this.servers.filter(server => server.healthy && server.active);
+  }
+
+  getServersByTag(tag) {
+    return this.servers.filter(server => server.tags.includes(tag));
+  }
+
+  markServerAsFailed(serverId) {
+    const server = this.servers.find(s => s.id === serverId);
+    if (server) {
+      server.failedAttempts++;
+      server.healthy = false;
+      
+      // Programar verificación de salud después de un tiempo
+      setTimeout(() => {
+        this.healthChecker.checkServerHealth(server)
+          .then(isHealthy => {
+            if (isHealthy) {
+              server.healthy = true;
+              server.failedAttempts = 0;
+              server.lastChecked = Date.now();
+            } else {
+              server.lastChecked = Date.now();
+              // Si ha fallado demasiadas veces, mantenerlo inactivo
+              if (server.failedAttempts > 5) {
+                server.active = false;
+              }
+            }
+          });
+      }, 30000); // Reintento cada 30 segundos
+    }
+  }
+
+  getServerById(serverId) {
+    return this.servers.find(server => server.id === serverId);
+  }
+}
+
+module.exports = { ServerPool };

package/src/dashboard/WebDashboard.js

@@ -0,0 +1,150 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+
+class WebDashboard {
+  constructor(balancerInstance) {
+    this.balancer = balancerInstance;
+    this.port = process.env.DASHBOARD_PORT || 8082;
+  }
+
+  start() {
+    const server = http.createServer((req, res) => {
+      const parsedUrl = url.parse(req.url, true);
+      const pathname = parsedUrl.pathname;
+
+      // Rutas de la API
+      if (pathname === '/api/status') {
+        this.handleStatusRequest(res);
+      } else if (pathname === '/api/metrics') {
+        this.handleMetricsRequest(res);
+      } else if (pathname === '/api/servers') {
+        this.handleServersRequest(res);
+      } else if (pathname === '/api/server-stats') {
+        this.handleServerStatsRequest(res);
+      } else if (pathname === '/api/config') {
+        this.handleConfigRequest(res);
+      } else {
+        // Servir archivos estáticos
+        this.serveStaticFile(req, res, pathname);
+      }
+    });
+
+    server.listen(this.port, () => {
+      console.log(`Panel web del balanceador escuchando en puerto ${this.port}`);
+    });
+  }
+
+  handleStatusRequest(res) {
+    const status = {
+      running: true,
+      algorithm: this.balancer.algorithmManager.getCurrentAlgorithm()?.getName() || 'unknown',
+      uptime: Date.now() - this.balancer.startTime,
+      timestamp: new Date().toISOString()
+    };
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(status));
+  }
+
+  handleMetricsRequest(res) {
+    const metrics = this.balancer.metricsCollector.getMetrics();
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(metrics));
+  }
+
+  handleServersRequest(res) {
+    const servers = this.balancer.serverPool.getServers().map(server => ({
+      id: server.id,
+      url: server.url,
+      protocol: server.protocol,
+      host: server.host,
+      weight: server.weight,
+      active: server.active,
+      tags: server.tags,
+      failedAttempts: server.failedAttempts,
+      lastChecked: server.lastChecked,
+      healthy: server.healthy,
+      status: server.healthy ? 'online' : 'offline'
+    }));
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ servers }));
+  }
+
+  handleServerStatsRequest(res) {
+    // Obtener estadísticas detalladas por servidor
+    const serverStats = this.balancer.metricsCollector.getServerStats();
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ serverStats }));
+  }
+
+  handleConfigRequest(res) {
+    // Devolver la configuración necesaria para el cliente web
+    const config = {
+      websocketPort: process.env.WEBSOCKET_PORT || 8083,  // Puerto WebSocket por defecto
+      algorithm: this.balancer.algorithmManager.getCurrentAlgorithmName ?
+                 this.balancer.algorithmManager.getCurrentAlgorithmName() :
+                 'roundrobin',
+      httpPort: process.env.BALANCER_HTTP_PORT || 8081,
+      dashboardPort: process.env.DASHBOARD_PORT || 8082
+    };
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(config));
+  }
+
+  serveStaticFile(req, res, pathname) {
+    let filePath = path.join(__dirname, '../../webpage', pathname);
+
+    // Si la ruta es '/', servir index.html
+    if (pathname === '/') {
+      filePath = path.join(__dirname, '../../webpage', 'index.html');
+    }
+
+    // Mapeo de extensiones a tipos MIME
+    const mimeTypes = {
+      '.html': 'text/html',
+      '.css': 'text/css',
+      '.js': 'application/javascript',
+      '.json': 'application/json',
+      '.png': 'image/png',
+      '.jpg': 'image/jpg',
+      '.gif': 'image/gif',
+      '.svg': 'image/svg+xml',
+      '.wav': 'audio/wav',
+      '.mp4': 'video/mp4',
+      '.woff': 'application/font-woff',
+      '.ttf': 'application/font-ttf',
+      '.eot': 'application/vnd.ms-fontobject',
+      '.otf': 'application/font-otf',
+      '.wasm': 'application/wasm'
+    };
+
+    const extname = String(path.extname(filePath)).toLowerCase();
+    const contentType = mimeTypes[extname] || 'application/octet-stream';
+
+    fs.readFile(filePath, (err, content) => {
+      if (err) {
+        if (err.code === 'ENOENT') {
+          // Archivo no encontrado
+          res.writeHead(404);
+          res.end('404 Not Found');
+        } else {
+          // Otro error
+          res.writeHead(500);
+          res.end(`Error interno del servidor: ${err.code}`);
+        }
+      } else {
+        // Archivo encontrado
+        res.writeHead(200, { 'Content-Type': contentType });
+        res.end(content, 'utf-8');
+      }
+    });
+  }
+}
+
+module.exports = { WebDashboard };

package/src/dashboard/WebSocketServer.js

@@ -0,0 +1,114 @@
+const WebSocket = require('ws');
+const { ProfessionalMetrics } = require('../utils/ProfessionalMetrics');
+
+class WebSocketServer {
+  constructor(balancerInstance) {
+    this.balancer = balancerInstance;
+    this.wss = null;
+    this.clients = new Set();
+  }
+
+  start(port = 8083) {
+    this.wss = new WebSocket.Server({ port });
+    
+    this.wss.on('connection', (ws) => {
+      // Agregar nuevo cliente
+      this.clients.add(ws);
+      console.log(`Cliente WebSocket conectado. Total: ${this.clients.size}`);
+      
+      // Enviar datos inmediatamente al conectar
+      this.sendCurrentMetrics(ws);
+      
+      // Manejar desconexión
+      ws.on('close', () => {
+        this.clients.delete(ws);
+        console.log(`Cliente WebSocket desconectado. Total: ${this.clients.size}`);
+      });
+      
+      // Manejar errores
+      ws.on('error', (error) => {
+        console.error('Error en WebSocket:', error);
+        this.clients.delete(ws);
+      });
+    });
+    
+    console.log(`Servidor WebSocket iniciado en puerto ${port}`);
+    
+    // Iniciar envío periódico de datos
+    this.startPeriodicBroadcast();
+  }
+  
+  sendCurrentMetrics(ws) {
+    try {
+      const metrics = this.balancer.metricsCollector.getMetrics();
+      const serverStats = this.balancer.metricsCollector.getServerStats();
+      const status = {
+        running: true,
+        algorithm: this.balancer.algorithmManager.getCurrentAlgorithm()?.getName() || 'unknown',
+        uptime: Date.now() - this.balancer.startTime,
+        timestamp: new Date().toISOString()
+      };
+      
+      const data = {
+        type: 'metrics_update',
+        timestamp: Date.now(),
+        metrics,
+        serverStats,
+        status
+      };
+      
+      ws.send(JSON.stringify(data));
+    } catch (error) {
+      console.error('Error enviando métricas:', error);
+    }
+  }
+  
+  broadcastMetrics() {
+    if (this.clients.size === 0) return;
+    
+    try {
+      const metrics = this.balancer.metricsCollector.getMetrics();
+      const serverStats = this.balancer.metricsCollector.getServerStats();
+      const status = {
+        running: true,
+        algorithm: this.balancer.algorithmManager.getCurrentAlgorithm()?.getName() || 'unknown',
+        uptime: Date.now() - this.balancer.startTime,
+        timestamp: new Date().toISOString()
+      };
+      
+      const data = {
+        type: 'metrics_update',
+        timestamp: Date.now(),
+        metrics,
+        serverStats,
+        status
+      };
+      
+      const jsonData = JSON.stringify(data);
+      
+      // Enviar a todos los clientes conectados
+      for (const client of this.clients) {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(jsonData);
+        }
+      }
+    } catch (error) {
+      console.error('Error en broadcast de métricas:', error);
+    }
+  }
+  
+  startPeriodicBroadcast(interval = 2000) { // Enviar cada 2 segundos
+    setInterval(() => {
+      this.broadcastMetrics();
+    }, interval);
+  }
+  
+  close() {
+    if (this.wss) {
+      this.wss.close();
+      this.clients.clear();
+    }
+  }
+}
+
+module.exports = { WebSocketServer };

package/src/extensibility/CachingFilter.js

@@ -0,0 +1,134 @@
+class CachingFilter {
+  constructor(maxCacheSize = 100) {
+    this.cache = new Map();
+    this.maxCacheSize = maxCacheSize;
+    this.accessLog = new Map(); // Para implementar LRU
+  }
+
+  // Generar clave única para la caché basada en la solicitud
+  generateCacheKey(req) {
+    return `${req.method}:${req.url}:${JSON.stringify(req.headers)}`;
+  }
+
+  // Verificar si una solicitud es cacheable
+  isCacheable(req) {
+    // Solo GET requests son cacheables por defecto
+    return req.method === 'GET';
+  }
+
+  // Aplicar el filtro de caché
+  async apply(req, res, additionalData = {}) {
+    if (!this.isCacheable(req)) {
+      // Si no es cacheable, continuar con la cadena
+      return { allowed: true, cached: false };
+    }
+
+    const cacheKey = this.generateCacheKey(req);
+    const now = Date.now();
+
+    // Verificar si está en caché y no ha expirado
+    if (this.cache.has(cacheKey)) {
+      const cachedData = this.cache.get(cacheKey);
+      
+      // Verificar si no ha expirado (por ejemplo, 5 minutos)
+      if (now - cachedData.timestamp < 300000) { // 5 minutos en milisegundos
+        // Enviar respuesta desde caché
+        res.writeHead(cachedData.statusCode, cachedData.headers);
+        res.end(cachedData.body);
+        
+        return { 
+          allowed: true, 
+          cached: true, 
+          cacheHit: true,
+          cacheKey 
+        };
+      } else {
+        // Eliminar entrada expirada
+        this.cache.delete(cacheKey);
+        this.accessLog.delete(cacheKey);
+      }
+    }
+
+    // Si no está en caché, permitir que la solicitud continúe
+    // y almacenar la respuesta para futuras solicitudes
+    const originalWriteHead = res.writeHead;
+    const originalEnd = res.end;
+    const filter = this;
+
+    // Interceptamos la respuesta para almacenarla
+    res.writeHead = function(statusCode, headers) {
+      res.cachedStatusCode = statusCode;
+      res.cachedHeaders = headers;
+      return originalWriteHead.call(this, statusCode, headers);
+    };
+
+    res.end = function(chunk) {
+      if (chunk && !res.finished) {
+        // Almacenar en caché antes de enviar la respuesta
+        filter.storeInCache(cacheKey, {
+          statusCode: res.cachedStatusCode || 200,
+          headers: res.cachedHeaders || {},
+          body: chunk,
+          timestamp: now
+        });
+      }
+      return originalEnd.call(this, chunk);
+    };
+
+    return { 
+      allowed: true, 
+      cached: false,
+      cacheKey
+    };
+  }
+
+  storeInCache(cacheKey, data) {
+    // Si excede el tamaño máximo, eliminar el menos recientemente usado
+    if (this.cache.size >= this.maxCacheSize) {
+      const oldestKey = this.getLeastRecentlyUsedKey();
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        this.accessLog.delete(oldestKey);
+      }
+    }
+
+    this.cache.set(cacheKey, data);
+    this.accessLog.set(cacheKey, Date.now());
+  }
+
+  getLeastRecentlyUsedKey() {
+    let oldestTime = Infinity;
+    let oldestKey = null;
+
+    for (const [key, time] of this.accessLog.entries()) {
+      if (time < oldestTime) {
+        oldestTime = time;
+        oldestKey = key;
+      }
+    }
+
+    return oldestKey;
+  }
+
+  // Limpiar entradas expiradas
+  clearExpiredEntries() {
+    const now = Date.now();
+    for (const [key, data] of this.cache.entries()) {
+      if (now - data.timestamp >= 300000) { // 5 minutos
+        this.cache.delete(key);
+        this.accessLog.delete(key);
+      }
+    }
+  }
+
+  // Obtener estadísticas de la caché
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxCacheSize,
+      utilization: (this.cache.size / this.maxCacheSize) * 100
+    };
+  }
+}
+
+module.exports = { CachingFilter };

package/src/extensibility/FilterChain.js

@@ -0,0 +1,93 @@
+/*
+ * KUKUY
+ * Copyright (C) 2026 Desarrollador
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+const HookSystem = require('jerk-hooked-lib');
+const { CachingFilter } = require('./CachingFilter');
+
+class FilterChain {
+  constructor() {
+    this.hooks = new HookSystem();
+    this.cachingFilter = new CachingFilter();
+    this.setupDefaultFilters();
+  }
+
+  setupDefaultFilters() {
+    // Registrar filtros predeterminados
+    this.hooks.addFilter('request_processing', this.authenticationFilter.bind(this));
+    this.hooks.addFilter('request_processing', this.rateLimitFilter.bind(this));
+    this.hooks.addFilter('request_processing', this.loggingFilter.bind(this));
+    // El caching filter se aplica de manera especial, no en la cadena estándar
+  }
+
+  async applyFilters(type, req, res, additionalData = {}) {
+    // Verificar si la solicitud puede ser atendida desde caché
+    const cacheResult = await this.cachingFilter.apply(req, res, additionalData);
+
+    // Si fue un hit de caché, retornar inmediatamente
+    if (cacheResult.cached && cacheResult.cacheHit) {
+      return cacheResult;
+    }
+
+    // Usar el sistema de filtros de la librería para otros filtros
+    // Creamos un objeto combinado para pasar al filtro
+    const filterData = { req, res, ...additionalData, allowed: true, statusCode: 200, message: '' };
+
+    // Aplicar filtros según el tipo
+    const processedData = this.hooks.applyFilters('request_processing', filterData);
+
+    // Devolver el resultado procesado
+    return { ...processedData, ...cacheResult };
+  }
+
+  // Filtro de autenticación básico
+  authenticationFilter(data) {
+    // Aquí iría la lógica de autenticación
+    // Por ahora, permitimos todas las solicitudes
+    return data; // Devolvemos el mismo objeto con posibles modificaciones
+  }
+
+  // Filtro de límite de tasa básico
+  rateLimitFilter(data) {
+    // Aquí iría la lógica de límite de tasa
+    // Por ahora, permitimos todas las solicitudes
+    return data;
+  }
+
+  // Filtro de logging básico
+  loggingFilter(data) {
+    console.log(`${new Date().toISOString()} - ${data.req.method} ${data.req.url}`);
+    return data;
+  }
+
+  // Método para añadir nuevos filtros
+  addFilter(filterName, filterFunction) {
+    this.hooks.addFilter(filterName, filterFunction);
+  }
+
+  // Método para aplicar un filtro específico
+  applySpecificFilter(filterName, data) {
+    return this.hooks.applyFilters(filterName, data);
+  }
+
+  // Obtener estadísticas de la caché
+  getCacheStats() {
+    return this.cachingFilter.getStats();
+  }
+}
+
+module.exports = { FilterChain };

package/src/extensibility/HookManager.js

@@ -0,0 +1,48 @@
+const HookSystem = require('jerk-hooked-lib');
+
+class HookManager {
+  constructor() {
+    this.hooks = new HookSystem();
+    this.registerDefaultHooks();
+  }
+
+  registerDefaultHooks() {
+    // Definir hooks predeterminados
+    const hookNames = [
+      'onRequestReceived',
+      'onServerSelected',
+      'onResponseSent',
+      'onServerError'
+    ];
+
+    // Los hooks se registran implícitamente al usar addAction
+    // No es necesario registro explícito en esta librería
+  }
+
+  async executeHooks(hookName, data) {
+    // En esta librería, usamos doAction para ejecutar hooks
+    // Pasamos el objeto data como argumento
+    this.hooks.doAction(hookName, data);
+  }
+
+  addHook(hookName, callback) {
+    // En esta librería, usamos addAction para añadir hooks
+    this.hooks.addAction(hookName, callback);
+  }
+
+  removeHook(hookName, callback) {
+    // Para remover hooks, necesitamos un ID único
+    // Esta operación puede no estar disponible directamente en esta librería
+    console.warn(`Remoción de hook no implementada directamente para: ${hookName}`);
+  }
+
+  hasHook(hookName) {
+    return this.hooks.hasAction(hookName);
+  }
+
+  getHookCount(hookName) {
+    return this.hooks.actionsCount(hookName);
+  }
+}
+
+module.exports = { HookManager };