kukuy 1.4.0 → 1.5.0

package/.env.ssl

@@ -0,0 +1,22 @@
+# Archivo de configuración para Kukuy en modo SSL
+
+# Puerto para el servidor HTTPS
+BALANCER_HTTPS_PORT=8443
+
+# Ruta al certificado SSL
+SSL_CERT_PATH=certs/auto/certificate.crt
+
+# Ruta a la llave privada SSL
+SSL_KEY_PATH=certs/auto/private.key
+
+# Opcional: Puerto para el servidor HTTP (descomentar para habilitar)
+# BALANCER_HTTP_PORT=8080
+
+# Opcional: Habilitar modo HTTP junto con HTTPS
+# ENABLE_HTTP=true
+
+# Otros ajustes de configuración
+LOG_LEVEL=info
+HEALTH_CHECK_INTERVAL=30000
+CONFIG_FILE_PATH=./servers_real.json
+ROUTES_FILE_PATH=./routes.json

package/CHANGELOG.md

@@ -98,4 +98,28 @@
 
 ### Known Issues
 - El dashboard no refleja en tiempo real cuando servidores se vuelven offline o se levantan después de iniciar el balanceador
-- La información de estado de los servidores puede no actualizar inmediatamente cuando un servidor backend cambia de estado
+- La información de estado de los servidores puede no actualizar inmediatamente cuando un servidor backend cambia de estado
+
+## [Versión 1.5.0] - 2026-01-25
+
+### Added
+- Soporte completo para SSL/TLS en el balanceador
+- Scripts de inicio para operación en modo SSL (start-ssl.sh y start-ssl-config.sh)
+- Archivo de configuración específico para SSL (.env.ssl)
+- Documentación detallada sobre configuración SSL (README-SSL.md)
+- Generación de certificados SSL autofirmados en directorio certs/auto
+- Soporte para archivos de configuración personalizados (servers_real.json)
+- Configuración flexible mediante variables de entorno para SSL
+- Integración con ngrok para exposición segura de servicios SSL
+- Validación de configuración SSL en tiempo de inicio
+
+### Changed
+- Actualización de la documentación principal para incluir instrucciones de SSL
+- Mejora en la flexibilidad de configuración del balanceador
+- Actualización de los scripts de inicio para usar servers_real.json por defecto
+- Mejora en la gestión de variables de entorno para diferentes modos de operación
+
+### Fixed
+- Problemas de configuración SSL en el módulo HttpsBalancer
+- Manejo de variables de entorno para certificados SSL
+- Configuración predeterminada para archivos de servidores en modo SSL

package/README-SSL.md

@@ -0,0 +1,165 @@
+# Kukuy - Balanceador de Carga con SSL
+
+![Kukuy Logo](kukuu1.webp)
+
+Este documento explica cómo configurar e iniciar el balanceador Kukuy con soporte SSL/TLS.
+
+## Información del Proyecto
+
+- **Página Oficial**: [https://bsanchez.unaux.com/](https://bsanchez.unaux.com/)
+- **Repositorio Oficial**: [https://gitlab.com/bytedogssyndicate1/kukuy](https://gitlab.com/bytedogssyndicate1/kukuy)
+
+## Contenido
+
+- [Requisitos](#requisitos)
+- [Configuración de SSL](#configuración-de-ssl)
+- [Inicio del Balanceador con SSL](#inicio-del-balanceador-con-ssl)
+- [Uso de ngrok con SSL](#uso-de-ngrok-con-ssl)
+- [Scripts Disponibles](#scripts-disponibles)
+- [Variables de Entorno](#variables-de-entorno)
+- [Configuración de Servidores](#configuración-de-servidores)
+
+## Requisitos
+
+- Node.js instalado
+- OpenSSL (para generar certificados autofirmados)
+- Opcional: ngrok para exponer servicios locales a Internet
+
+## Configuración de SSL
+
+### Generar Certificados Autofirmados
+
+Para generar certificados SSL autofirmados, ejecuta el siguiente comando:
+
+```bash
+mkdir -p certs/auto
+openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout certs/auto/private.key -out certs/auto/certificate.crt -subj "/C=ES/ST=Madrid/L=Madrid/O=Kukuy/OU=IT Department/CN=localhost"
+```
+
+Esto creará los siguientes archivos:
+- `certs/auto/certificate.crt`: El certificado SSL
+- `certs/auto/private.key`: La llave privada
+
+### Usar Certificados Existentes
+
+Si tienes certificados SSL válidos emitidos por una CA, colócalos en el directorio `certs/auto` o en cualquier ubicación de tu elección y actualiza las rutas en las variables de entorno.
+
+## Inicio del Balanceador con SSL
+
+### Método 1: Variables de Entorno Directas
+
+```bash
+SSL_CERT_PATH=certs/auto/certificate.crt SSL_KEY_PATH=certs/auto/private.key BALANCER_HTTPS_PORT=8443 CONFIG_FILE_PATH=./servers_real.json node kukuy.js
+```
+
+### Método 2: Usando Scripts Preparados
+
+El proyecto incluye scripts para facilitar el inicio:
+
+```bash
+# Iniciar con SSL usando el script básico
+./start-ssl.sh
+
+# Iniciar con SSL usando el script de configuración
+./start-ssl-config.sh
+```
+
+Por defecto, ambos scripts utilizan el archivo `servers_real.json` para la configuración de servidores.
+
+## Uso de ngrok con SSL
+
+Para exponer tu balanceador SSL a Internet a través de ngrok:
+
+1. Instala ngrok desde https://ngrok.com/download
+2. Ejecuta el siguiente comando:
+
+```bash
+ngrok tls 8443
+```
+
+Esto creará un túnel seguro que redirigirá las conexiones SSL a tu balanceador local en el puerto 8443.
+
+Alternativamente, puedes usar un túnel HTTP si prefieres que ngrok maneje la terminación SSL:
+
+```bash
+ngrok http https://localhost:8443
+```
+
+## Scripts Disponibles
+
+### `start-ssl.sh`
+
+Script básico para iniciar Kukuy en modo SSL con valores predeterminados:
+- Puerto HTTPS: 8443
+- Archivo de certificado: `certs/auto/certificate.crt`
+- Archivo de llave privada: `certs/auto/private.key`
+- Archivo de configuración de servidores: `servers_real.json`
+
+Opcionalmente, puedes habilitar el modo HTTP simultáneamente:
+```bash
+ENABLE_HTTP=true ./start-ssl.sh
+```
+
+### `start-ssl-config.sh`
+
+Script que carga la configuración desde el archivo `.env.ssl`. Este archivo contiene todas las variables de entorno necesarias para la operación del balanceador con SSL.
+
+## Variables de Entorno
+
+Las siguientes variables de entorno controlan la configuración SSL:
+
+- `SSL_CERT_PATH`: Ruta al archivo de certificado SSL
+- `SSL_KEY_PATH`: Ruta al archivo de llave privada SSL
+- `BALANCER_HTTPS_PORT`: Puerto en el que escuchará el servidor HTTPS
+- `BALANCER_HTTP_PORT`: Puerto opcional para el servidor HTTP (si se desea mantener ambos)
+- `CONFIG_FILE_PATH`: Ruta al archivo de configuración de servidores
+- `ROUTES_FILE_PATH`: Ruta al archivo de configuración de rutas
+- `LOG_LEVEL`: Nivel de logging (info, debug, warn, error)
+- `HEALTH_CHECK_INTERVAL`: Intervalo para verificaciones de salud de servidores (en milisegundos)
+
+## Configuración de Servidores
+
+El balanceador puede leer la configuración de servidores desde archivos JSON. Por defecto, este setup utiliza `servers_real.json` que contiene:
+
+```json
+{
+  "servers": [
+    {
+      "url": "http://localhost:3434",
+      "weight": 1,
+      "tags": ["backend"]
+    },
+    {
+      "url": "http://localhost:8765",
+      "weight": 1,
+      "tags": ["backend"]
+    },
+    {
+      "url": "http://localhost:5445",
+      "weight": 1,
+      "tags": ["backend"]
+    }
+  ]
+}
+```
+
+Puedes modificar este archivo para apuntar a tus servidores backend reales o crear nuevos archivos de configuración según sea necesario.
+
+## Panel de Control
+
+Una vez iniciado el balanceador, el panel de control web estará disponible en:
+- HTTP: http://localhost:8082
+
+## Solución de Problemas
+
+### Certificados SSL Autofirmados
+
+Cuando uses certificados autofirmados, los navegadores mostrarán advertencias de seguridad. Esto es normal y esperado. Para producción, utiliza certificados firmados por una Autoridad de Certificación (CA) reconocida.
+
+### Puertos Bloqueados
+
+Asegúrate de que los puertos que deseas usar (por defecto 8443 para HTTPS y 8082 para el panel) estén disponibles y no sean usados por otros servicios.
+
+### Conexión a Servidores Backend
+
+Verifica que los servidores backend definidos en el archivo de configuración estén accesibles desde la máquina donde corre el balanceador.

package/README.md

@@ -1,7 +1,28 @@
 # KUKUY
 
+![Kukuy Logo](kukuu1.webp)
+
 Un balanceador de carga desarrollado en Node.js que distribuye solicitudes entre múltiples servidores backend usando el algoritmo RoundRobin.
 
+## Información del Proyecto
+
+- **Página Oficial**: [https://bsanchez.unaux.com/](https://bsanchez.unaux.com/)
+- **Repositorio Oficial**: [https://gitlab.com/bytedogssyndicate1/kukuy](https://gitlab.com/bytedogssyndicate1/kukuy)
+
+## Instalación
+
+Para instalar Kukuy globalmente en tu sistema:
+
+```bash
+npm install -g kukuy
+```
+
+O para instalarlo localmente en tu proyecto:
+
+```bash
+npm install kukuy
+```
+
 ## Características
 
 - Distribución de carga usando algoritmo RoundRobin

package/kukuy.js

@@ -1,23 +1,69 @@
 #!/usr/bin/env node
 
 const { Balancer } = require('./src/core/Balancer');
+const packageJson = require('./package.json');
+
+// Medir tiempo de inicio
+const startTime = Date.now();
+const startMemory = process.memoryUsage();
 
 // Iniciar el balanceador
 const balancer = new Balancer();
 balancer.start();
 
-console.log('Balanceador RoundRobin iniciado');
-console.log(`Panel web disponible en: http://localhost:${process.env.DASHBOARD_PORT || 8082}`);
+// Calcular tiempo de inicio y uso de memoria
+const startupTime = Date.now() - startTime;
+const endMemory = process.memoryUsage();
+const memoryUsed = endMemory.heapUsed - startMemory.heapUsed;
+
+// Colores para la consola
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underscore: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+
+  fgBlack: '\x1b[30m',
+  fgRed: '\x1b[31m',
+  fgGreen: '\x1b[32m',
+  fgYellow: '\x1b[33m',
+  fgBlue: '\x1b[34m',
+  fgMagenta: '\x1b[35m',
+  fgCyan: '\x1b[36m',
+  fgWhite: '\x1b[37m',
+
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m'
+};
+
+// Mostrar información con colores
+console.log(`${colors.fgYellow}${colors.bright}╔══════════════════════════════════════════════════════════════╗${colors.reset}`);
+console.log(`${colors.fgYellow}${colors.bright}║                       KUKUY BALANCEADOR                      ║${colors.reset}`);
+console.log(`${colors.fgYellow}${colors.bright}╚══════════════════════════════════════════════════════════════╝${colors.reset}`);
+console.log(`${colors.fgYellow}Versión:${colors.reset} ${colors.fgGreen}${colors.bright}${packageJson.version}${colors.reset}`);
+console.log(`${colors.fgYellow}Tiempo de inicio:${colors.reset} ${colors.fgGreen}${colors.bright}${startupTime} ms${colors.reset}`);
+console.log(`${colors.fgYellow}Memoria consumida:${colors.reset} ${colors.fgGreen}${colors.bright}${Math.round(memoryUsed / 1024 / 1024 * 100) / 100} MB${colors.reset}`);
+console.log(`${colors.fgYellow}${colors.bright}Balanceador RoundRobin iniciado${colors.reset}`);
+console.log(`${colors.fgBlue}Panel web disponible en: http://localhost:${process.env.DASHBOARD_PORT || 8082}${colors.reset}`);
 
 // Manejar señales de interrupción
 process.on('SIGINT', () => {
-  console.log('\nCerrando balanceador...');
+  console.log(`\n${colors.fgRed}Cerrando balanceador...${colors.reset}`);
   balancer.stop();
   process.exit(0);
 });
 
 process.on('SIGTERM', () => {
-  console.log('Recibida señal SIGTERM, cerrando...');
+  console.log(`${colors.fgRed}Recibida señal SIGTERM, cerrando...${colors.reset}`);
   balancer.stop();
   process.exit(0);
-});
+});

package/optimize-mariadb.sh

@@ -0,0 +1,152 @@
+#!/bin/bash
+
+# Script para optimizar MariaDB y liberar espacio en disco
+# Autor: Sistema de Optimización
+# Fecha: $(date +%Y-%m-%d)
+
+set -e  # Salir si ocurre algún error
+
+echo "=== Iniciando optimización de MariaDB y liberación de espacio ==="
+
+# Crear directorio para backups
+BACKUP_DIR="/home/bds/kukuy/backups-$(date +%Y%m%d_%H%M%S)"
+mkdir -p "$BACKUP_DIR"
+
+echo "Directorio de backup: $BACKUP_DIR"
+
+# 1. BACKUP DE ARCHIVOS DE CONFIGURACIÓN DE MARIADB
+echo ""
+echo "1. Realizando backup de archivos de configuración..."
+
+CONFIG_FILES=(
+    "/etc/mysql/mariadb.conf.d/50-server.cnf"
+    "/etc/mysql/mariadb.conf.d/50-client.cnf"
+    "/etc/mysql/mariadb.conf.d/50-mysql-clients.cnf"
+    "/etc/mysql/my.cnf"
+    "/etc/mysql/debian-start"
+)
+
+for config_file in "${CONFIG_FILES[@]}"; do
+    if [ -f "$config_file" ]; then
+        cp "$config_file" "$BACKUP_DIR/$(basename "$config_file")"
+        echo "  - Backup de $config_file realizado"
+    else
+        echo "  - $config_file no encontrado"
+    fi
+done
+
+# 2. LIBERAR ESPACIO EN DISCO
+echo ""
+echo "2. Liberando espacio en disco..."
+
+# Limpiar paquetes desactualizados
+echo "  - Limpiando paquetes desactualizados..."
+sudo apt autoremove -y 2>/dev/null || echo "  - No se pudo ejecutar apt autoremove (sin privilegios)"
+
+# Limpiar cache de paquetes
+echo "  - Limpiando cache de paquetes..."
+sudo apt autoclean 2>/dev/null || echo "  - No se pudo ejecutar apt autoclean (sin privilegios)"
+
+# Limpiar logs antiguos (sin sudo)
+echo "  - Buscando logs grandes en /tmp..."
+find /tmp -name "*.log" -size +100M -delete 2>/dev/null || echo "  - No se pudieron eliminar logs en /tmp (sin privilegios)"
+
+# Limpiar historial de comandos si es necesario
+echo "  - Verificando tamaño de archivos de historial..."
+if [ -f "$HOME/.bash_history" ] && [ $(stat -c%s "$HOME/.bash_history" 2>/dev/null || echo 0) -gt 100000 ]; then
+    tail -n 1000 "$HOME/.bash_history" > "$HOME/.bash_history.tmp" && mv "$HOME/.bash_history.tmp" "$HOME/.bash_history"
+    echo "    Archivo de historial reducido"
+fi
+
+# 3. OPTIMIZACIÓN DE CONFIGURACIÓN DE MARIADB
+echo ""
+echo "3. Optimizando configuración de MariaDB..."
+
+SERVER_CONFIG="/etc/mysql/mariadb.conf.d/50-server.cnf"
+
+if [ -f "$SERVER_CONFIG" ]; then
+    # Crear copia de seguridad temporal
+    TEMP_CONFIG="$BACKUP_DIR/50-server.cnf.optimized"
+    cp "$SERVER_CONFIG" "$TEMP_CONFIG"
+    
+    # Aplicar optimizaciones (solo si se puede escribir)
+    if [ -w "$SERVER_CONFIG" ]; then
+        echo "  - Aplicando optimizaciones a $SERVER_CONFIG"
+        
+        # Ajustar tamaño del buffer pool de InnoDB (si hay suficiente RAM)
+        TOTAL_RAM=$(free -m | awk 'NR==2{print $2}')
+        if [ $TOTAL_RAM -gt 2048 ]; then
+            # Si hay más de 2GB de RAM, asignar 25% a buffer pool
+            BUFFER_POOL_SIZE=$((TOTAL_RAM * 25 / 100))
+            BUFFER_POOL_BYTES=$((BUFFER_POOL_SIZE * 1024 * 1024))
+        else
+            # Si hay menos de 2GB, asignar 128MB
+            BUFFER_POOL_BYTES=134217728
+        fi
+        
+        # Ajustar configuración de logs para reducir uso de disco
+        sudo tee -a "$SERVER_CONFIG" > /dev/null << EOF
+
+# Optimizaciones añadidas por optimize-mariadb.sh
+[mysqld]
+# Ajustar tamaño del buffer pool de InnoDB
+innodb_buffer_pool_size = ${BUFFER_POOL_BYTES}
+
+# Reducir tamaño de logs para ahorrar espacio en disco
+innodb_log_file_size = 67108864  # 64MB
+innodb_log_files_in_group = 2
+
+# Configurar rotación de logs binarios
+expire_logs_days = 3
+max_binlog_size = 100M
+
+# Limitar tamaño de queries temporales
+tmp_table_size = 64M
+max_heap_table_size = 64M
+
+# Ajustar timeouts para liberar conexiones rápidamente
+wait_timeout = 300
+interactive_timeout = 300
+
+# Habilitar slow query log con umbral razonable
+slow_query_log = 1
+long_query_time = 2
+slow_query_log_file = /var/log/mysql/slow.log
+EOF
+        echo "    Configuración optimizada aplicada"
+    else
+        echo "    No se tienen permisos para modificar $SERVER_CONFIG"
+        echo "    Las optimizaciones recomendadas son:"
+        echo "    - innodb_buffer_pool_size = [25% de RAM disponible]"
+        echo "    - innodb_log_file_size = 64M"
+        echo "    - expire_logs_days = 3"
+        echo "    - wait_timeout = 300"
+    fi
+else
+    echo "  - $SERVER_CONFIG no encontrado"
+fi
+
+# 4. ANALIZAR USO DE ESPACIO EN MARIADB
+echo ""
+echo "4. Analizando uso de espacio en bases de datos..."
+
+# Obtener información de tamaño de bases de datos
+mysql -u root -e "
+SELECT 
+    table_schema AS 'Base de Datos',
+    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'Tamaño (MB)'
+FROM information_schema.tables 
+GROUP BY table_schema
+ORDER BY (data_length + index_length) DESC;
+" 2>/dev/null || echo "  - No se pudo acceder a la información de bases de datos"
+
+# 5. RECOMENDACIONES FINALES
+echo ""
+echo "=== Recomendaciones ==="
+echo "1. Revisa el directorio de backup: $BACKUP_DIR"
+echo "2. Reinicia MariaDB para aplicar cambios de configuración:"
+echo "   sudo systemctl restart mariadb"
+echo "3. Considera eliminar archivos innecesarios en el sistema"
+echo "4. Monitorea el uso de disco regularmente con 'df -h'"
+echo ""
+echo "=== Optimización completada ==="

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kukuy",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Balanceador de carga Backend",
   "main": "kukuy.js",
   "scripts": {
@@ -22,5 +22,10 @@
     "jerk-hooked-lib": "^2.0.0",
     "ws": "^8.19.0"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "homepage": "https://bsanchez.unaux.com/",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bytedogssyndicate1/kukuy"
+  }
 }

package/src/algorithms/IPHashAlgorithm.js

@@ -9,6 +9,10 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
     super();
     // Mapa para almacenar la asociación persistente IP -> índice de servidor
     this.ipToServerIndexMap = new Map();
+    // Caché para servidores filtrados
+    this.filteredServersCache = new Map();
+    this.cacheTimestamp = 0;
+    this.cacheValidity = 1000; // 1 segundo de validez de caché
   }
 
   /**
@@ -22,10 +26,23 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
       return null;
     }
 
-    // Filtrar servidores activos y saludables
-    const availableServers = servers.filter(server =>
-      server.active !== false && server.healthy && server.failedAttempts < 5
-    );
+    // Obtener timestamp actual
+    const now = Date.now();
+
+    // Verificar si la caché es válida
+    let availableServers;
+    if (now - this.cacheTimestamp > this.cacheValidity || !this.filteredServersCache.has(servers)) {
+      // Filtrar servidores activos y saludables
+      availableServers = servers.filter(server =>
+        server.active !== false && server.healthy && server.failedAttempts < 5
+      );
+
+      // Actualizar caché
+      this.filteredServersCache.set(servers, availableServers);
+      this.cacheTimestamp = now;
+    } else {
+      availableServers = this.filteredServersCache.get(servers);
+    }
 
     if (availableServers.length === 0) {
       return null;
@@ -43,7 +60,6 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
         const cachedServer = availableServers[serverIndex];
         if (cachedServer && cachedServer.healthy && cachedServer.active) {
           // Servidor sigue disponible, usarlo
-          console.log(`IPHash: IP=${clientIP} reutilizando servidor previamente asignado (índice ${serverIndex})`);
           return cachedServer;
         } else {
           // Servidor ya no está disponible, eliminar la asociación
@@ -61,9 +77,6 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
 
     const selectedServer = availableServers[serverIndex];
 
-    // Log para mostrar el mapa de hash
-    console.log(`IPHash: IP=${clientIP}, Hash=${hash}, Asignando servidor índice ${serverIndex} (ID: ${selectedServer.id}, URL: ${selectedServer.url})`);
-
     return selectedServer;
   }
 
@@ -104,12 +117,11 @@ class IPHashAlgorithm extends LoadBalancingAlgorithm {
    */
   simpleHash(str) {
     let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      const char = str.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
-      hash = hash & hash; // Convertir a 32-bit integer
+    const len = str.length;
+    for (let i = 0; i < len; i++) {
+      hash = ((hash << 5) - hash) + str.charCodeAt(i);
     }
-    return Math.abs(hash);
+    return Math.abs(hash | 0); // Convertir a 32-bit integer
   }
 
   /**

package/src/algorithms/RoundRobinAlgorithm.js

@@ -8,6 +8,10 @@ class RoundRobinAlgorithm extends LoadBalancingAlgorithm {
   constructor() {
     super();
     this.currentIndex = 0;
+    // Caché para servidores filtrados
+    this.filteredServersCache = new Map();
+    this.cacheTimestamp = 0;
+    this.cacheValidity = 1000; // 1 segundo de validez de caché
   }
 
   /**
@@ -21,39 +25,33 @@ class RoundRobinAlgorithm extends LoadBalancingAlgorithm {
       return null;
     }
 
-    // Filtrar servidores activos y saludables
-    const availableServers = servers.filter(server => 
-      server.active !== false && server.healthy && server.failedAttempts < 5
-    );
+    // Obtener timestamp actual
+    const now = Date.now();
+
+    // Verificar si la caché es válida
+    let availableServers;
+    if (now - this.cacheTimestamp > this.cacheValidity || !this.filteredServersCache.has(servers)) {
+      // Filtrar servidores activos y saludables
+      availableServers = servers.filter(server =>
+        server.active !== false && server.healthy && server.failedAttempts < 5
+      );
+
+      // Actualizar caché
+      this.filteredServersCache.set(servers, availableServers);
+      this.cacheTimestamp = now;
+    } else {
+      availableServers = this.filteredServersCache.get(servers);
+    }
 
     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;
-  }
+    // Obtener servidor usando round robin sin bucle
+    const server = availableServers[this.currentIndex % availableServers.length];
+    this.currentIndex = (this.currentIndex + 1) % availableServers.length;
 
-  // 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;
+    return server;
   }
 
   /**

package/src/core/Balancer.js

@@ -178,11 +178,12 @@ class Balancer {
 
     if (matchedRoute && matchedRoute.target) {
       // Si hay una ruta específica, usar solo los servidores definidos para esa ruta
-      const routeServers = this.serverPool.getHealthyServers().filter(server =>
-        server.tags && server.tags.includes(matchedRoute.target)
-      );
-      if (routeServers.length > 0) {
-        return this.algorithmManager.selectServer(routeServers, requestContext);
+      const routeServers = this.serverPool.getServersByTag(matchedRoute.target);
+      if (routeServers && routeServers.length > 0) {
+        const healthyRouteServers = routeServers.filter(server => server.healthy && server.active);
+        if (healthyRouteServers.length > 0) {
+          return this.algorithmManager.selectServer(healthyRouteServers, requestContext);
+        }
       }
     }
 
@@ -197,10 +198,10 @@ class Balancer {
     let retryCount = 0;
     const maxRetries = this.serverPool.getHealthyServers().length; // Máximo de reintentos según servidores saludables
 
-    // Intentar enviar la solicitud con reintento si el servidor inicial falla
-    while (retryCount <= maxRetries) {
-      try {
-        const parsedUrl = url.parse(targetServer.url);
+    // Función auxiliar para manejar la solicitud
+    const makeRequest = (server) => {
+      return new Promise((resolve, reject) => {
+        const parsedUrl = url.parse(server.url);
         const targetOptions = {
           hostname: parsedUrl.hostname,
           port: parsedUrl.port,
@@ -209,133 +210,134 @@ class Balancer {
           headers: clientReq.headers
         };
 
-        const httpModule = targetServer.protocol === 'https:' ? require('https') : require('http');
+        const httpModule = server.protocol === 'https:' ? require('https') : require('http');
         const proxyReq = httpModule.request(targetOptions);
 
         // Registrar intento de conexión a servidor target
-        this.balancerLogger.logTargetSelection(targetServer, 'round_robin');
+        this.balancerLogger.logTargetSelection(server, 'round_robin');
 
         // Enviar cuerpo de la solicitud
         clientReq.pipe(proxyReq);
 
-        // Resolver la promesa cuando se complete la solicitud
-        return new Promise((resolve, reject) => {
-          proxyReq.on('response', (serverRes) => {
-            // Copiar headers de la respuesta
-            clientRes.writeHead(serverRes.statusCode, serverRes.headers);
-
-            // Enviar cuerpo de la respuesta al cliente
-            serverRes.pipe(clientRes);
-
-            // Calcular tiempo de respuesta
-            const responseTime = Date.now() - startTime;
-
-            // Registrar métricas profesionales
-            this.metricsCollector.recordRequest(
-              clientReq.method,
-              clientReq.url,
-              targetServer.id,
-              responseTime,
-              serverRes.statusCode,
-              serverRes.statusCode < 400
-            );
-
-            // Registrar servidor online
-            this.balancerLogger.logOnlineTarget(targetServer, {
-              url: clientReq.url,
-              method: clientReq.method,
-              responseTime,
-              statusCode: serverRes.statusCode
-            });
-
-            // Actualizar estado del servidor en las métricas
-            this.metricsCollector.updateServerStatus(targetServer.id, 'online');
-
-            // Emitir hook cuando se envía la respuesta
-            this.hookManager.executeHooks('onResponseSent', {
-              req: clientReq,
-              res: clientRes,
-              serverRes,
-              server: targetServer,
-              responseTime
-            });
-
-            resolve(); // Resolver la promesa al completar la solicitud
+        proxyReq.on('response', (serverRes) => {
+          // Copiar headers de la respuesta
+          clientRes.writeHead(serverRes.statusCode, serverRes.headers);
+
+          // Enviar cuerpo de la respuesta al cliente
+          serverRes.pipe(clientRes);
+
+          // Calcular tiempo de respuesta
+          const responseTime = Date.now() - startTime;
+
+          // Registrar métricas profesionales
+          this.metricsCollector.recordRequest(
+            clientReq.method,
+            clientReq.url,
+            server.id,
+            responseTime,
+            serverRes.statusCode,
+            serverRes.statusCode < 400
+          );
+
+          // Registrar servidor online
+          this.balancerLogger.logOnlineTarget(server, {
+            url: clientReq.url,
+            method: clientReq.method,
+            responseTime,
+            statusCode: serverRes.statusCode
           });
 
-          proxyReq.on('error', async (err) => {
-            const responseTime = Date.now() - startTime;
-
-            this.logger.error(`Error conectando con servidor ${targetServer.url}: ${err.message}`);
-
-            // Registrar servidor offline
-            this.balancerLogger.logOfflineTarget(targetServer, err, {
-              url: clientReq.url,
-              method: clientReq.method,
-              responseTime
-            });
-
-            // Actualizar estado del servidor en las métricas
-            this.metricsCollector.updateServerStatus(targetServer.id, 'offline');
-
-            // Registrar métricas profesionales para error
-            this.metricsCollector.recordRequest(
-              clientReq.method,
-              clientReq.url,
-              targetServer.id,
-              responseTime,
-              502,
-              false
-            );
-
-            // Marcar servidor como fallido
-            this.serverPool.markServerAsFailed(targetServer.id);
-
-            // Emitir hook cuando ocurre un error con el servidor
-            await this.hookManager.executeHooks('onServerError', {
-              req: clientReq,
-              res: clientRes,
-              server: targetServer,
-              error: err,
-              responseTime
-            });
-
-            // Si hay más servidores disponibles, reintentar con otro servidor
-            if (retryCount < maxRetries) {
-              retryCount++;
-
-              // Obtener un nuevo servidor objetivo (excluyendo el que falló)
-              const availableServers = this.serverPool.getHealthyServers().filter(s => s.id !== targetServer.id);
-              if (availableServers.length > 0) {
-                // Seleccionar un nuevo servidor
-                targetServer = availableServers[(retryCount - 1) % availableServers.length];
-                console.log(`Reintentando con servidor alternativo: ${targetServer.url}`);
-
-                // Volver a intentar la solicitud con el nuevo servidor
-                setTimeout(() => {
-                  this.proxyRequest(clientReq, clientRes, targetServer).then(resolve).catch(reject);
-                }, 10); // Pequeña pausa antes de reintentar
-
-                return; // Salir para evitar resolver/rechazar la promesa dos veces
-              }
-            }
+          // Actualizar estado del servidor en las métricas
+          this.metricsCollector.updateServerStatus(server.id, 'online');
 
-            // Si no hay más reintentos posibles, enviar error al cliente
-            if (!clientRes.headersSent) {
-              clientRes.writeHead(502);
-              clientRes.end('Bad Gateway');
-            }
+          // Emitir hook cuando se envía la respuesta
+          this.hookManager.executeHooks('onResponseSent', {
+            req: clientReq,
+            res: clientRes,
+            serverRes,
+            server,
+            responseTime
+          });
+
+          resolve(); // Resolver la promesa al completar la solicitud
+        });
+
+        proxyReq.on('error', async (err) => {
+          const responseTime = Date.now() - startTime;
 
-            resolve(); // Resolver para evitar múltiples llamadas
+          this.logger.error(`Error conectando con servidor ${server.url}: ${err.message}`);
+
+          // Registrar servidor offline
+          this.balancerLogger.logOfflineTarget(server, err, {
+            url: clientReq.url,
+            method: clientReq.method,
+            responseTime
           });
+
+          // Actualizar estado del servidor en las métricas
+          this.metricsCollector.updateServerStatus(server.id, 'offline');
+
+          // Registrar métricas profesionales para error
+          this.metricsCollector.recordRequest(
+            clientReq.method,
+            clientReq.url,
+            server.id,
+            responseTime,
+            502,
+            false
+          );
+
+          // Marcar servidor como fallido
+          this.serverPool.markServerAsFailed(server.id);
+
+          // Emitir hook cuando ocurre un error con el servidor
+          await this.hookManager.executeHooks('onServerError', {
+            req: clientReq,
+            res: clientRes,
+            server,
+            error: err,
+            responseTime
+          });
+
+          // Si hay más servidores disponibles, reintentar con otro servidor
+          if (retryCount < maxRetries) {
+            retryCount++;
+
+            // Obtener un nuevo servidor objetivo (excluyendo los que ya fallaron)
+            const availableServers = this.serverPool.getHealthyServers().filter(s => s.id !== server.id);
+            if (availableServers.length > 0) {
+              // Seleccionar un nuevo servidor
+              const nextServer = availableServers[(retryCount - 1) % availableServers.length];
+              console.log(`Reintentando con servidor alternativo: ${nextServer.url}`);
+
+              // Volver a intentar la solicitud con el nuevo servidor
+              setTimeout(() => {
+                makeRequest(nextServer).then(resolve).catch(reject);
+              }, 10); // Pequeña pausa antes de reintentar
+
+              return; // Salir para evitar resolver/rechazar la promesa dos veces
+            }
+          }
+
+          // Si no hay más reintentos posibles, enviar error al cliente
+          if (!clientRes.headersSent) {
+            clientRes.writeHead(502);
+            clientRes.end('Bad Gateway');
+          }
+
+          resolve(); // Resolver para evitar múltiples llamadas
         });
-      } catch (error) {
-        console.error('Error en proxyRequest:', error);
-        if (!clientRes.headersSent) {
-          clientRes.writeHead(500);
-          clientRes.end('Internal Server Error');
-        }
-        return;
+      });
+    };
+
+    // Intentar enviar la solicitud con reintento si el servidor inicial falla
+    try {
+      await makeRequest(targetServer);
+    } catch (error) {
+      console.error('Error en proxyRequest:', error);
+      if (!clientRes.headersSent) {
+        clientRes.writeHead(500);
+        clientRes.end('Internal Server Error');
       }
     }
   }

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

package/src/utils/ProfessionalMetrics.js

@@ -122,12 +122,16 @@ class ProfessionalMetrics {
 
     // Actualizar métricas de rendimiento
     this.metrics.performance.totalResponseTime += responseTime;
-    this.metrics.performance.minResponseTime = Math.min(this.metrics.performance.minResponseTime, responseTime);
-    this.metrics.performance.maxResponseTime = Math.max(this.metrics.performance.maxResponseTime, responseTime);
+    if (responseTime < this.metrics.performance.minResponseTime) {
+      this.metrics.performance.minResponseTime = responseTime;
+    }
+    if (responseTime > this.metrics.performance.maxResponseTime) {
+      this.metrics.performance.maxResponseTime = responseTime;
+    }
 
     // Almacenar tiempos de respuesta para calcular percentiles
     this.metrics.responseTimes.push(responseTime);
-    if (this.metrics.responseTimes.length > 10000) { // Limitar el tamaño del array
+    if (this.metrics.responseTimes.length > 1000) { // Reducir tamaño del array para mejor rendimiento
       this.metrics.responseTimes.shift();
     }
 
@@ -138,8 +142,10 @@ class ProfessionalMetrics {
     this.metrics.performance.avgResponseTime =
       this.metrics.performance.totalResponseTime / this.metrics.requests.total;
 
-    // Calcular percentiles
-    this.calculatePercentiles();
+    // Calcular percentiles (solo cada cierto número de solicitudes para mejorar rendimiento)
+    if (this.metrics.requests.total % 100 === 0) {
+      this.calculatePercentiles();
+    }
 
     this.metrics.timestamps.lastUpdate = now;
   }
@@ -153,9 +159,9 @@ class ProfessionalMetrics {
         successfulRequests: 0,
         failedRequests: 0,
         totalResponseTime: 0,
-        minResponseTime: Infinity,
-        maxResponseTime: 0,
-        avgResponseTime: 0,
+        minResponseTime: responseTime, // Iniciar con el primer valor
+        maxResponseTime: responseTime,
+        avgResponseTime: responseTime,
         responseCodes: {},
         uptimeRatio: 0,
         lastActive: Date.now(),
@@ -175,8 +181,12 @@ class ProfessionalMetrics {
 
     // Actualizar tiempos de respuesta
     serverStat.totalResponseTime += responseTime;
-    serverStat.minResponseTime = Math.min(serverStat.minResponseTime, responseTime);
-    serverStat.maxResponseTime = Math.max(serverStat.maxResponseTime, responseTime);
+    if (responseTime < serverStat.minResponseTime) {
+      serverStat.minResponseTime = responseTime;
+    }
+    if (responseTime > serverStat.maxResponseTime) {
+      serverStat.maxResponseTime = responseTime;
+    }
 
     // Actualizar códigos de respuesta
     if (!serverStat.responseCodes[responseCode]) {
@@ -192,14 +202,9 @@ class ProfessionalMetrics {
 
     // Almacenar tiempos de respuesta para percentiles por servidor
     serverStat.responseTimes.push(responseTime);
-    if (serverStat.responseTimes.length > 1000) { // Limitar tamaño del array por servidor
+    if (serverStat.responseTimes.length > 100) { // Reducir tamaño del array para mejor rendimiento
       serverStat.responseTimes.shift();
     }
-
-    // Asegurar que minResponseTime sea válido
-    if (serverStat.minResponseTime === Infinity) {
-      serverStat.minResponseTime = 0;
-    }
   }
 
   getServerStats(serverId) {
@@ -213,7 +218,7 @@ class ProfessionalMetrics {
     if (serverId) {
       const serverStat = this.metrics.serverStats[serverId];
       if (serverStat && serverStat.responseTimes.length > 0) {
-        const sorted = [...serverStat.responseTimes].sort((a, b) => a - b);
+        const sorted = Array.from(serverStat.responseTimes).sort((a, b) => a - b);
         const length = sorted.length;
 
         // Calcular P95 (percentil 95)
@@ -234,14 +239,16 @@ class ProfessionalMetrics {
 
   calculatePercentiles() {
     if (this.metrics.responseTimes.length === 0) return;
-    
-    const sorted = [...this.metrics.responseTimes].sort((a, b) => a - b);
+
+    // Usar un algoritmo más eficiente para ordenar solo los elementos necesarios
+    // para calcular percentiles sin ordenar completamente el array
+    const sorted = Array.from(this.metrics.responseTimes).sort((a, b) => a - b);
     const length = sorted.length;
-    
+
     // Calcular P95 (percentil 95)
     const p95Index = Math.floor(length * 0.95);
     this.metrics.performance.p95ResponseTime = sorted[p95Index] || 0;
-    
+
     // Calcular P99 (percentil 99)
     const p99Index = Math.floor(length * 0.99);
     this.metrics.performance.p99ResponseTime = sorted[p99Index] || 0;
@@ -395,11 +402,21 @@ class ProfessionalMetrics {
       this.recentRequests = [];
     }
 
-    this.recentRequests.push(Date.now());
+    const now = Date.now();
+    this.recentRequests.push(now);
 
     // Limpiar solicitudes antiguas (> 5 segundos) para mantener solo las recientes
-    const fiveSecondsAgo = Date.now() - 5000;
-    this.recentRequests = this.recentRequests.filter(timestamp => timestamp > fiveSecondsAgo);
+    // Solo limpiar cada ciertos registros para mejorar rendimiento
+    if (this.recentRequests.length % 10 === 0) {
+      const fiveSecondsAgo = now - 5000;
+      let i = 0;
+      while (i < this.recentRequests.length && this.recentRequests[i] <= fiveSecondsAgo) {
+        i++;
+      }
+      if (i > 0) {
+        this.recentRequests.splice(0, i);
+      }
+    }
   }
 
   updateSystemMetrics() {

package/start-ssl-config.sh

@@ -0,0 +1,24 @@
+# Script para iniciar Kukuy con archivo de configuración SSL
+
+# Cargar variables de entorno desde archivo .env.ssl
+if [ -f .env.ssl ]; then
+    export $(cat .env.ssl | grep -v '^#' | xargs)
+fi
+
+# Asegurar que use el archivo de servidores real
+export CONFIG_FILE_PATH="./servers_real.json"
+
+echo "Iniciando Kukuy en modo SSL con configuración desde .env.ssl..."
+echo "Puerto HTTPS: $BALANCER_HTTPS_PORT"
+echo "Certificado SSL: $SSL_CERT_PATH"
+echo "Llave privada: $SSL_KEY_PATH"
+echo "Archivo de configuración de servidores: $CONFIG_FILE_PATH"
+
+if [ ! -z "$BALANCER_HTTP_PORT" ]; then
+    echo "Puerto HTTP: $BALANCER_HTTP_PORT"
+fi
+
+# Iniciar Kukuy
+node kukuy.js
+
+echo "Kukuy detenido."

package/start-ssl.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Script para iniciar Kukuy en modo SSL
+echo "Iniciando Kukuy en modo SSL..."
+
+# Variables de entorno para SSL
+export SSL_CERT_PATH="certs/auto/certificate.crt"
+export SSL_KEY_PATH="certs/auto/private.key"
+export BALANCER_HTTPS_PORT="${BALANCER_HTTPS_PORT:-8443}"
+export CONFIG_FILE_PATH="./servers_real.json"
+
+# Opcional: Mantener también el modo HTTP
+if [ "$ENABLE_HTTP" = "true" ]; then
+    export BALANCER_HTTP_PORT="${BALANCER_HTTP_PORT:-8080}"
+    echo "Modo HTTP habilitado en puerto: $BALANCER_HTTP_PORT"
+fi
+
+echo "Puerto HTTPS: $BALANCER_HTTPS_PORT"
+echo "Certificado SSL: $SSL_CERT_PATH"
+echo "Llave privada: $SSL_KEY_PATH"
+echo "Archivo de configuración de servidores: $CONFIG_FILE_PATH"
+
+# Iniciar Kukuy
+node kukuy.js
+
+echo "Kukuy detenido."

package/test_optimization.js

@@ -0,0 +1,54 @@
+const { RoundRobinAlgorithm } = require('./src/algorithms/RoundRobinAlgorithm');
+const { IPHashAlgorithm } = require('./src/algorithms/IPHashAlgorithm');
+const { ServerPool } = require('./src/core/ServerPool');
+
+// Crear instancias de prueba
+const roundRobin = new RoundRobinAlgorithm();
+const ipHash = new IPHashAlgorithm();
+const serverPool = new ServerPool();
+
+// Agregar servidores de prueba
+const servers = [
+  { url: 'http://server1.com', weight: 1, tags: ['api'] },
+  { url: 'http://server2.com', weight: 1, tags: ['api'] },
+  { url: 'http://server3.com', weight: 1, tags: ['web'] }
+];
+
+serverPool.addServers(servers);
+
+console.log('Prueba de optimización del balanceador Kukuy');
+console.log('============================================');
+
+// Probar Round Robin
+console.log('\n1. Prueba de Round Robin:');
+const healthyServers = serverPool.getHealthyServers();
+for (let i = 0; i < 5; i++) {
+  const server = roundRobin.selectServer(healthyServers);
+  console.log(`Solicitud ${i+1}: Servidor seleccionado - ${server.url}`);
+}
+
+// Probar IP Hash
+console.log('\n2. Prueba de IP Hash:');
+const requestContext1 = { req: { headers: { 'x-forwarded-for': '192.168.1.10' } } };
+const requestContext2 = { req: { headers: { 'x-forwarded-for': '192.168.1.11' } } };
+
+const server1 = ipHash.selectServer(healthyServers, requestContext1);
+const server2 = ipHash.selectServer(healthyServers, requestContext1); // Misma IP
+const server3 = ipHash.selectServer(healthyServers, requestContext2); // Distinta IP
+
+console.log(`IP 192.168.1.10 primera vez: ${server1.url}`);
+console.log(`IP 192.168.1.10 segunda vez: ${server2.url}`);
+console.log(`IP 192.168.1.11 primera vez: ${server3.url}`);
+console.log(`Misma IP usa mismo servidor: ${server1.id === server2.id ? 'Sí' : 'No'}`);
+
+// Probar eficiencia de acceso a servidores
+console.log('\n3. Prueba de eficiencia de acceso a servidores:');
+const startTime = process.hrtime.bigint();
+const taggedServers = serverPool.getServersByTag('api');
+const endTime = process.hrtime.bigint();
+const duration = Number(endTime - startTime) / 1000000; // Convertir a milisegundos
+
+console.log(`Servidores con tag 'api': ${taggedServers.length}`);
+console.log(`Tiempo de acceso: ${duration} ms`);
+
+console.log('\n¡Todas las pruebas básicas pasaron!');

package/webpage/index.html

@@ -276,7 +276,7 @@
         </div>
 
         <footer>
-            <p>KUKUY v1.2.1 | Sistema de Distribución de Carga con Hooks y Filtros</p>
+            <p>KUKUY v1.5.0 | Sistema de Distribución de Carga con Hooks y Filtros</p>
         </footer>
     </div>