kukuy 1.4.0

package/src/protocol/HttpBalancer.js

@@ -0,0 +1,37 @@
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const { Logger } = require('../utils/Logger');
+
+class HttpBalancer {
+  constructor(port, requestHandler) {
+    this.port = port;
+    this.requestHandler = requestHandler;
+    this.logger = new Logger();
+    this.server = null;
+  }
+
+  start() {
+    this.server = http.createServer((req, res) => {
+      this.requestHandler(req, res);
+    });
+
+    this.server.listen(this.port, () => {
+      this.logger.info(`Balanceador HTTP escuchando en puerto ${this.port}`);
+    });
+
+    return this.server;
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.close();
+    }
+  }
+
+  isRunning() {
+    return this.server && this.server.listening;
+  }
+}
+
+module.exports = { HttpBalancer };

package/src/protocol/HttpsBalancer.js

@@ -0,0 +1,47 @@
+const https = require('https');
+const fs = require('fs');
+const { Logger } = require('../utils/Logger');
+
+class HttpsBalancer {
+  constructor(port, sslCertPath, sslKeyPath, requestHandler) {
+    this.port = port;
+    this.sslCertPath = sslCertPath;
+    this.sslKeyPath = sslKeyPath;
+    this.requestHandler = requestHandler;
+    this.logger = new Logger();
+    this.server = null;
+  }
+
+  start() {
+    if (!this.sslCertPath || !this.sslKeyPath) {
+      throw new Error('Rutas al certificado SSL y llave privada son requeridas para HTTPS');
+    }
+
+    const options = {
+      cert: fs.readFileSync(this.sslCertPath),
+      key: fs.readFileSync(this.sslKeyPath)
+    };
+
+    this.server = https.createServer(options, (req, res) => {
+      this.requestHandler(req, res);
+    });
+
+    this.server.listen(this.port, () => {
+      this.logger.info(`Balanceador HTTPS escuchando en puerto ${this.port}`);
+    });
+
+    return this.server;
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.close();
+    }
+  }
+
+  isRunning() {
+    return this.server && this.server.listening;
+  }
+}
+
+module.exports = { HttpsBalancer };

package/src/utils/BalancerLogger.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const { ConfigManager } = require('../config/ConfigManager');
+
+class BalancerLogger {
+  constructor() {
+    this.config = ConfigManager.getInstance();
+    this.logLevel = this.config.logLevel || 'info';
+    this.logFile = process.env.LOG_FILE_PATH || './balancer.log';
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3
+    };
+  }
+
+  log(level, message, metadata = {}) {
+    if (this.levels[level] <= this.levels[this.logLevel]) {
+      const timestamp = new Date().toISOString();
+      const logEntry = {
+        timestamp,
+        level: level.toUpperCase(),
+        message,
+        ...metadata
+      };
+
+      const logLine = JSON.stringify(logEntry) + '\n';
+      
+      // Imprimir en consola
+      console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}`, metadata);
+      
+      // Escribir en archivo de log
+      try {
+        fs.appendFileSync(this.logFile, logLine);
+      } catch (err) {
+        console.error('Error escribiendo en archivo de log:', err.message);
+      }
+    }
+  }
+
+  error(message, metadata = {}) {
+    this.log('error', message, metadata);
+  }
+
+  warn(message, metadata = {}) {
+    this.log('warn', message, metadata);
+  }
+
+  info(message, metadata = {}) {
+    this.log('info', message, metadata);
+  }
+
+  debug(message, metadata = {}) {
+    this.log('debug', message, metadata);
+  }
+
+  // Métodos específicos para el balanceador
+  logOnlineTarget(server, requestInfo = {}) {
+    this.info(`Servidor ONLINE - ID: ${server.id}, URL: ${server.url}`, {
+      eventType: 'target_online',
+      serverId: server.id,
+      serverUrl: server.url,
+      request: requestInfo,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  logOfflineTarget(server, error, requestInfo = {}) {
+    this.warn(`Servidor OFFLINE - ID: ${server.id}, URL: ${server.url}, Error: ${error.message}`, {
+      eventType: 'target_offline',
+      serverId: server.id,
+      serverUrl: server.url,
+      error: error.message,
+      request: requestInfo,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  logTargetSelection(server, algorithm = 'round_robin') {
+    this.debug(`Seleccionado servidor destino - ID: ${server.id}, URL: ${server.url}`, {
+      eventType: 'target_selected',
+      serverId: server.id,
+      serverUrl: server.url,
+      algorithm,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  logLoadBalancingStats(stats) {
+    this.info('Estadísticas de balanceo de carga', {
+      eventType: 'balancing_stats',
+      totalRequests: stats.totalRequests,
+      successfulRequests: stats.successfulRequests,
+      failedRequests: stats.failedRequests,
+      onlineTargets: stats.onlineTargets,
+      offlineTargets: stats.offlineTargets,
+      timestamp: new Date().toISOString()
+    });
+  }
+}
+
+module.exports = { BalancerLogger };

package/src/utils/HealthChecker.js

@@ -0,0 +1,51 @@
+const http = require('http');
+const https = require('https');
+const url = require('url');
+
+class HealthChecker {
+  constructor() {
+    this.timeout = 5000; // 5 segundos de timeout
+  }
+
+  async checkServerHealth(server) {
+    try {
+      const parsedUrl = url.parse(server.url);
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: '/health', // Ruta estándar para verificación de salud
+        method: 'GET',
+        timeout: this.timeout
+      };
+
+      return new Promise((resolve) => {
+        const request = server.protocol === 'https:' 
+          ? https.request(options)
+          : http.request(options);
+
+        request.on('response', (res) => {
+          // 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}`);
+          resolve(false);
+        });
+
+        request.on('timeout', () => {
+          console.error(`Timeout verificando salud de ${server.url}`);
+          resolve(false);
+        });
+
+        request.end();
+      });
+    } catch (error) {
+      console.error(`Error en la verificación de salud: ${error.message}`);
+      return false;
+    }
+  }
+}
+
+module.exports = { HealthChecker };

package/src/utils/Logger.js

@@ -0,0 +1,39 @@
+const { ConfigManager } = require('../config/ConfigManager');
+
+class Logger {
+  constructor() {
+    this.config = ConfigManager.getInstance();
+    this.level = this.config.logLevel;
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3
+    };
+  }
+
+  log(level, message) {
+    if (this.levels[level] <= this.levels[this.level]) {
+      const timestamp = new Date().toISOString();
+      console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}`);
+    }
+  }
+
+  error(message) {
+    this.log('error', message);
+  }
+
+  warn(message) {
+    this.log('warn', message);
+  }
+
+  info(message) {
+    this.log('info', message);
+  }
+
+  debug(message) {
+    this.log('debug', message);
+  }
+}
+
+module.exports = { Logger };

package/src/utils/MetricsCollector.js

@@ -0,0 +1,82 @@
+class MetricsCollector {
+  constructor() {
+    this.metrics = {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      totalResponseTime: 0,
+      minResponseTime: Infinity,
+      maxResponseTime: 0,
+      startTime: Date.now(),
+      requestsByPath: {},
+      requestsByServer: {}
+    };
+  }
+
+  recordRequest(path, serverId, responseTime, success = true) {
+    this.metrics.totalRequests++;
+    
+    if (success) {
+      this.metrics.successfulRequests++;
+    } else {
+      this.metrics.failedRequests++;
+    }
+    
+    this.metrics.totalResponseTime += responseTime;
+    
+    if (responseTime < this.metrics.minResponseTime) {
+      this.metrics.minResponseTime = responseTime;
+    }
+    
+    if (responseTime > this.metrics.maxResponseTime) {
+      this.metrics.maxResponseTime = responseTime;
+    }
+    
+    // Contar solicitudes por ruta
+    if (!this.metrics.requestsByPath[path]) {
+      this.metrics.requestsByPath[path] = 0;
+    }
+    this.metrics.requestsByPath[path]++;
+    
+    // Contar solicitudes por servidor
+    if (!this.metrics.requestsByServer[serverId]) {
+      this.metrics.requestsByServer[serverId] = 0;
+    }
+    this.metrics.requestsByServer[serverId]++;
+  }
+
+  getMetrics() {
+    const uptime = Date.now() - this.metrics.startTime;
+    const avgResponseTime = this.metrics.totalRequests > 0 
+      ? this.metrics.totalResponseTime / this.metrics.totalRequests 
+      : 0;
+    
+    const rps = uptime > 0 
+      ? (this.metrics.totalRequests / uptime) * 1000 
+      : 0;
+    
+    return {
+      ...this.metrics,
+      uptime,
+      avgResponseTime,
+      rps,
+      minResponseTime: this.metrics.minResponseTime === Infinity ? 0 : this.metrics.minResponseTime
+    };
+  }
+
+  reset() {
+    this.metrics = {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      totalResponseTime: 0,
+      minResponseTime: Infinity,
+      maxResponseTime: 0,
+      startTime: Date.now(),
+      requestsByPath: {},
+      requestsByServer: {}
+    };
+  }
+}
+
+module.exports = { MetricsCollector };