kukuy 1.4.0 → 1.6.0

package/kukuy.workspace

@@ -1,11 +0,0 @@
-{
- "NodeJS": {
-  "metadata": {
-   "version": "1.0",
-   "ide": "CodeLite",
-   "type": "NodeJS"
-  },
-  "folders": ["."],
-  "m_showHiddenFiles": false
- }
-}

package/restart-balancer.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-# Script para matar e iniciar KUKUY con estadísticas por servidor y WebSocket
-
-echo "Matando procesos existentes de KUKUY..."
-pkill -f "node kukuy.js" 2>/dev/null || true
-
-sleep 2
-
-echo "Iniciando KUKUY con estadísticas por servidor y WebSocket..."
-LOAD_BALANCING_ALGORITHM=roundrobin CONFIG_FILE_PATH=./servers_real.json BALANCER_HTTP_PORT=8088 DASHBOARD_PORT=8082 WEBSOCKET_PORT=8084 node kukuy.js

package/scripts/load_test.py

@@ -1,151 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de prueba de carga concurrente para el balanceador
-"""
-
-import threading
-import time
-import requests
-import sys
-from datetime import datetime
-
-# Configuración
-BASE_URL = "http://localhost:8081"
-ENDPOINT = "/api/endpoints"
-NUM_THREADS = 100  # Número de hilos concurrentes para alta carga
-REQUESTS_PER_THREAD = 6000  # Solicitudes por hilo (100 hilos * 60 solicitudes = 6000 solicitudes totales por segundo)
-DURATION_SECONDS = 120  # Duración de la prueba en segundos (2 minutos)
-TARGET_RPS = 5000  # Objetivo de solicitudes por segundo
-
-# Variables globales para métricas
-total_requests = 0
-successful_requests = 0
-failed_requests = 0
-lock = threading.Lock()
-
-def make_requests_continuous(thread_id, end_time_target):
-    """Función que realiza solicitudes HTTP continuas hasta alcanzar la duración objetivo"""
-    global total_requests, successful_requests, failed_requests
-
-    thread_start_time = time.time()
-    thread_successful = 0
-    thread_failed = 0
-
-    # Calcular el intervalo entre solicitudes para alcanzar el objetivo RPS
-    interval = 1.0 / (TARGET_RPS / NUM_THREADS) if NUM_THREADS > 0 else 0.001  # Evitar división por cero
-
-    while time.time() < end_time_target:
-        try:
-            response = requests.get(f"{BASE_URL}{ENDPOINT}", timeout=10)
-            with lock:
-                total_requests += 1
-                if response.status_code == 200:
-                    successful_requests += 1
-                    thread_successful += 1
-                else:
-                    failed_requests += 1
-                    thread_failed += 1
-        except requests.exceptions.RequestException as e:
-            with lock:
-                total_requests += 1
-                failed_requests += 1
-                thread_failed += 1
-            if thread_id == 0:  # Solo imprimir errores para el primer hilo
-                print(f"[Thread-{thread_id}] Error en solicitud: {e}")
-
-        # Esperar el intervalo calculado para alcanzar el objetivo RPS
-        time.sleep(interval)
-
-    thread_end_time = time.time()
-    thread_duration = thread_end_time - thread_start_time
-
-    print(f"[Thread-{thread_id}] Completado: {thread_successful} exitosas, {thread_failed} fallidas en {thread_duration:.2f}s")
-
-
-def make_requests(thread_id):
-    """Función original que realiza solicitudes HTTP en un hilo (mantenida por compatibilidad)"""
-    global total_requests, successful_requests, failed_requests
-
-    thread_start_time = time.time()
-    thread_successful = 0
-    thread_failed = 0
-
-    for i in range(REQUESTS_PER_THREAD):
-        try:
-            response = requests.get(f"{BASE_URL}{ENDPOINT}", timeout=10)
-            with lock:
-                total_requests += 1
-                if response.status_code == 200:
-                    successful_requests += 1
-                    thread_successful += 1
-                else:
-                    failed_requests += 1
-                    thread_failed += 1
-        except requests.exceptions.RequestException as e:
-            with lock:
-                total_requests += 1
-                failed_requests += 1
-                thread_failed += 1
-            if thread_id == 0:  # Solo imprimir errores para el primer hilo
-                print(f"[Thread-{thread_id}] Error en solicitud {i+1}: {e}")
-
-    thread_end_time = time.time()
-    thread_duration = thread_end_time - thread_start_time
-
-    print(f"[Thread-{thread_id}] Completado: {thread_successful} exitosas, {thread_failed} fallidas en {thread_duration:.2f}s")
-
-def run_load_test():
-    """Función principal que ejecuta la prueba de carga"""
-    global total_requests, successful_requests, failed_requests
-
-    print(f"Iniciando prueba de carga...")
-    print(f"- URL base: {BASE_URL}")
-    print(f"- Endpoint: {ENDPOINT}")
-    print(f"- Hilos concurrentes: {NUM_THREADS}")
-    print(f"- Solicitudes por hilo: {REQUESTS_PER_THREAD}")
-    print(f"- Duración: {DURATION_SECONDS} segundos")
-    print(f"- Objetivo RPS: {TARGET_RPS}")
-    print("-" * 50)
-
-    start_time = time.time()
-    end_time_target = start_time + DURATION_SECONDS
-
-    # Crear y arrancar hilos
-    threads = []
-    for i in range(NUM_THREADS):
-        thread = threading.Thread(target=make_requests_continuous, args=(i, end_time_target))
-        threads.append(thread)
-        thread.start()
-
-        # Pequeño retraso entre la creación de hilos para evitar congestión
-        time.sleep(0.001)
-
-    # Esperar a que todos los hilos terminen
-    for thread in threads:
-        thread.join()
-
-    actual_duration = time.time() - start_time
-
-    # Mostrar resultados
-    print("-" * 50)
-    print("RESULTADOS DE LA PRUEBA DE CARGA:")
-    print(f"Tiempo total: {actual_duration:.2f} segundos")
-    print(f"Solicitudes totales: {total_requests}")
-    print(f"Solicitudes exitosas: {successful_requests}")
-    print(f"Solicitudes fallidas: {failed_requests}")
-    print(f"Tasa de éxito: {(successful_requests/total_requests*100) if total_requests > 0 else 0:.2f}%")
-    print(f"RPS Real (Solicitudes por segundo): {total_requests/actual_duration if actual_duration > 0 else 0:.2f}")
-    print(f"RPS Objetivo: {TARGET_RPS}")
-
-    if successful_requests > 0:
-        print(f"RPS Exitoso (Solicitudes exitosas por segundo): {successful_requests/actual_duration if actual_duration > 0 else 0:.2f}")
-
-if __name__ == "__main__":
-    try:
-        run_load_test()
-    except KeyboardInterrupt:
-        print("\nPrueba interrumpida por el usuario.")
-        print(f"Resultados parciales:")
-        print(f"- Solicitudes totales: {total_requests}")
-        print(f"- Solicitudes exitosas: {successful_requests}")
-        print(f"- Solicitudes fallidas: {failed_requests}")

package/stress-test.js

@@ -1,190 +0,0 @@
-const http = require('http');
-const https = require('https');
-const url = require('url');
-
-class StressTester {
-  constructor(balancerUrl, durationSeconds = 60, concurrentRequests = 10) {
-    this.balancerUrl = balancerUrl;
-    this.durationSeconds = durationSeconds;
-    this.concurrentRequests = concurrentRequests;
-    this.startTime = null;
-    this.stats = {
-      totalRequests: 0,
-      successfulRequests: 0,
-      failedRequests: 0,
-      statusCodes: {},
-      totalTime: 0,
-      minTime: Infinity,
-      maxTime: 0
-    };
-    this.running = false;
-  }
-
-  async makeRequest(path, method = 'GET', body = null) {
-    const startTime = Date.now();
-    let statusCode = 0;
-    let success = false;
-    
-    return new Promise((resolve, reject) => {
-      const parsedUrl = url.parse(`${this.balancerUrl}${path}`);
-      const options = {
-        hostname: parsedUrl.hostname,
-        port: parsedUrl.port,
-        path: parsedUrl.path,
-        method: method,
-        headers: {
-          'Content-Type': 'application/json'
-        }
-      };
-
-      const request = http.request(options, (res) => {
-        statusCode = res.statusCode;
-        let data = '';
-        
-        res.on('data', (chunk) => {
-          data += chunk;
-        });
-        
-        res.on('end', () => {
-          const endTime = Date.now();
-          const responseTime = endTime - startTime;
-          
-          success = statusCode >= 200 && statusCode < 300;
-          
-          // Actualizar estadísticas
-          this.stats.totalRequests++;
-          if (success) {
-            this.stats.successfulRequests++;
-          } else {
-            this.stats.failedRequests++;
-          }
-          
-          if (!this.stats.statusCodes[statusCode]) {
-            this.stats.statusCodes[statusCode] = 0;
-          }
-          this.stats.statusCodes[statusCode]++;
-          
-          this.stats.totalTime += responseTime;
-          this.stats.minTime = Math.min(this.stats.minTime, responseTime);
-          this.stats.maxTime = Math.max(this.stats.maxTime, responseTime);
-          
-          resolve({
-            statusCode,
-            responseTime,
-            success
-          });
-        });
-      });
-
-      request.on('error', (err) => {
-        const endTime = Date.now();
-        const responseTime = endTime - startTime;
-        
-        this.stats.totalRequests++;
-        this.stats.failedRequests++;
-        
-        if (!this.stats.statusCodes['ERROR']) {
-          this.stats.statusCodes['ERROR'] = 0;
-        }
-        this.stats.statusCodes['ERROR']++;
-        
-        this.stats.totalTime += responseTime;
-        this.stats.maxTime = Math.max(this.stats.maxTime, responseTime);
-        
-        resolve({
-          statusCode: 'ERROR',
-          responseTime,
-          success: false,
-          error: err.message
-        });
-      });
-
-      if (body) {
-        request.write(JSON.stringify(body));
-      }
-      
-      request.end();
-    });
-  }
-
-  async runTest() {
-    console.log(`Iniciando prueba de estrés...`);
-    console.log(`URL del balanceador: ${this.balancerUrl}`);
-    console.log(`Duración: ${this.durationSeconds} segundos`);
-    console.log(`Concurrencia: ${this.concurrentRequests} solicitudes simultáneas`);
-    console.log('----------------------------------------');
-    
-    this.startTime = Date.now();
-    this.running = true;
-    
-    // Lista de endpoints para probar
-    const endpoints = [
-      { path: '/api/endpoints', method: 'GET' },
-      { path: '/sessions', method: 'GET' },
-      { path: '/events', method: 'GET' },
-      { path: '/reports/user-flow', method: 'GET' },
-      { path: '/reports/product-views-by-country', method: 'GET' },
-      { path: '/track/registerSession', method: 'POST', body: { test: 'stress_test_data' } },
-      { path: '/track/registerEventA', method: 'POST', body: { event: 'test_event', data: 'test_data' } }
-    ];
-    
-    // Función para hacer solicitudes continuamente durante la duración del test
-    const makeRequests = async () => {
-      while (this.running) {
-        const randomEndpoint = endpoints[Math.floor(Math.random() * endpoints.length)];
-        await this.makeRequest(randomEndpoint.path, randomEndpoint.method, randomEndpoint.body || null);
-      }
-    };
-    
-    // Iniciar múltiples promesas concurrentes
-    const promises = [];
-    for (let i = 0; i < this.concurrentRequests; i++) {
-      promises.push(makeRequests());
-    }
-    
-    // Esperar hasta que se cumpla la duración del test
-    setTimeout(() => {
-      this.running = false;
-    }, this.durationSeconds * 1000);
-    
-    // Esperar a que todas las promesas terminen
-    await Promise.all(promises);
-    
-    this.printResults();
-  }
-  
-  printResults() {
-    const totalTimeMs = Date.now() - this.startTime;
-    const avgTime = this.stats.totalRequests > 0 ? this.stats.totalTime / this.stats.totalRequests : 0;
-    const requestsPerSecond = this.stats.totalRequests / (totalTimeMs / 1000);
-    
-    console.log('\n========================================');
-    console.log('RESULTADOS DE LA PRUEBA DE ESTRÉS');
-    console.log('========================================');
-    console.log(`Tiempo total de prueba: ${(totalTimeMs / 1000).toFixed(2)} segundos`);
-    console.log(`Solicitudes totales: ${this.stats.totalRequests}`);
-    console.log(`Solicitudes exitosas: ${this.stats.successfulRequests}`);
-    console.log(`Solicitudes fallidas: ${this.stats.failedRequests}`);
-    console.log(`RPS (Solicitudes por segundo): ${requestsPerSecond.toFixed(2)}`);
-    console.log(`Tiempo promedio por solicitud: ${avgTime.toFixed(2)} ms`);
-    console.log(`Tiempo mínimo: ${this.stats.minTime !== Infinity ? this.stats.minTime : 0} ms`);
-    console.log(`Tiempo máximo: ${this.stats.maxTime} ms`);
-    console.log('\nDistribución de códigos de estado:');
-    Object.entries(this.stats.statusCodes).forEach(([code, count]) => {
-      console.log(`  ${code}: ${count} (${((count / this.stats.totalRequests) * 100).toFixed(2)}%)`);
-    });
-    console.log('========================================');
-  }
-}
-
-// Ejecutar la prueba de estrés si se llama directamente
-if (require.main === module) {
-  const balancerUrl = process.env.BALANCER_URL || 'http://localhost:8081';
-  const duration = parseInt(process.env.DURATION_SECONDS) || 30;
-  const concurrency = parseInt(process.env.CONCURRENT_REQUESTS) || 10;
-  
-  const tester = new StressTester(balancerUrl, duration, concurrency);
-  tester.runTest().catch(console.error);
-}
-
-module.exports = { StressTester };