npm - kukuy - Versions diffs - 1.4.0 - Mend

kukuy 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

package/.ctagsd/ctagsd.json +954 -0
package/.ctagsd/file_list.txt +100 -0
package/.ctagsd/tags.db +0 -0
package/CHANGELOG.md +101 -0
package/LICENSE +680 -0
package/README.md +251 -0
package/captura.png +0 -0
package/kukuy.js +23 -0
package/kukuy.workspace +11 -0
package/package.json +26 -0
package/restart-balancer.sh +10 -0
package/routes.json +14 -0
package/scripts/load_test.py +151 -0
package/servers.json +19 -0
package/servers_real.json +19 -0
package/src/algorithms/AlgorithmManager.js +85 -0
package/src/algorithms/IPHashAlgorithm.js +131 -0
package/src/algorithms/LoadBalancingAlgorithm.js +23 -0
package/src/algorithms/RoundRobinAlgorithm.js +67 -0
package/src/config/ConfigManager.js +37 -0
package/src/config/RouteLoader.js +36 -0
package/src/core/Balancer.js +353 -0
package/src/core/RoundRobinAlgorithm.js +60 -0
package/src/core/ServerPool.js +77 -0
package/src/dashboard/WebDashboard.js +150 -0
package/src/dashboard/WebSocketServer.js +114 -0
package/src/extensibility/CachingFilter.js +134 -0
package/src/extensibility/FilterChain.js +93 -0
package/src/extensibility/HookManager.js +48 -0
package/src/protocol/HttpBalancer.js +37 -0
package/src/protocol/HttpsBalancer.js +47 -0
package/src/utils/BalancerLogger.js +102 -0
package/src/utils/HealthChecker.js +51 -0
package/src/utils/Logger.js +39 -0
package/src/utils/MetricsCollector.js +82 -0
package/src/utils/ProfessionalMetrics.js +501 -0
package/start-iphash.sh +5 -0
package/start-roundrobin.sh +5 -0
package/stress-test.js +190 -0
package/webpage/README.md +17 -0
package/webpage/index.html +549 -0

package/webpage/README.md ADDED Viewed

@@ -0,0 +1,17 @@
+# Página Web de KUKUY
+Interfaz web para monitorear y gestionar KUKUY.
+## Características
+- Panel de control en tiempo real con métricas del sistema
+- Visualización del estado de los servidores backend
+- Indicadores de rendimiento (RPS, tiempo de respuesta promedio)
+- Controles para gestionar el estado del balanceador
+- Representación gráfica del uso de los servidores
+## Uso
+La página web es una aplicación HTML estática que se puede abrir directamente en cualquier navegador web moderno. Simplemente abre el archivo `index.html` en tu navegador.
+Para integrar con el balanceador real, se necesitaría implementar una API que proporcione datos en tiempo real al frontend.

package/webpage/index.html ADDED Viewed

@@ -0,0 +1,549 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Panel de Control - KUKUY</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        body {
+            background: linear-gradient(135deg, #000, #000, #1a3997a3);
+            color: #f4f4f4;
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        header {
+            text-align: center;
+            padding: 30px 0;
+            margin-bottom: 30px;
+        }
+        h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            text-shadow: 0 2px 4px rgba(0,0,0,0.3);
+        }
+        .subtitle {
+            font-size: 1.2rem;
+            opacity: 0.9;
+            max-width: 600px;
+            margin: 0 auto;
+        }
+        .dashboard {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+        .card {
+            background: rgba(255, 255, 255, 0.1);
+            backdrop-filter: blur(10px);
+            border-radius: 15px;
+            padding: 20px;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        .card h2 {
+            font-size: 1.3rem;
+            margin-bottom: 15px;
+            color: #4fc3f7;
+        }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 15px;
+        }
+        .stat-item {
+            background: rgba(0, 0, 0, 0.2);
+            padding: 15px;
+            border-radius: 10px;
+            text-align: center;
+        }
+        .stat-value {
+            font-size: 1.8rem;
+            font-weight: bold;
+            color: #4fc3f7;
+            margin: 10px 0;
+        }
+        .stat-label {
+            font-size: 0.9rem;
+            opacity: 0.8;
+        }
+        .servers-status {
+            margin-top: 20px;
+        }
+        .server-item {
+            display: flex;
+            justify-content: space-between;
+            padding: 10px 0;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        .server-name {
+            font-weight: bold;
+        }
+        .server-status {
+            display: inline-block;
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            margin-left: 10px;
+        }
+        .status-online {
+            background-color: #4caf50;
+        }
+        .status-offline {
+            background-color: #f44336;
+        }
+        .controls {
+            display: flex;
+            gap: 15px;
+            margin-top: 20px;
+            flex-wrap: wrap;
+        }
+        button {
+            flex: 1;
+            min-width: 120px;
+            padding: 12px 20px;
+            border: none;
+            border-radius: 8px;
+            background: #2196f3;
+            color: white;
+            font-weight: bold;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+        button:hover {
+            background: #0d8bf2;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+        }
+        button:active {
+            transform: translateY(0);
+        }
+        .metrics {
+            margin-top: 30px;
+        }
+        .chart-container {
+            height: 200px;
+            background: rgba(0, 0, 0, 0.2);
+            border-radius: 10px;
+            margin-top: 15px;
+            display: flex;
+            align-items: flex-end;
+            padding: 10px;
+            gap: 5px;
+        }
+        .bar {
+            flex: 1;
+            background: #4fc3f7;
+            border-radius: 5px 5px 0 0;
+            min-width: 20px;
+        }
+        footer {
+            text-align: center;
+            margin-top: 40px;
+            padding: 20px;
+            opacity: 0.7;
+            font-size: 0.9rem;
+        }
+        .loading {
+            text-align: center;
+            padding: 20px;
+            color: #ccc;
+        }
+        @media (max-width: 768px) {
+            .dashboard {
+                grid-template-columns: 1fr;
+            }
+            h1 {
+                font-size: 2rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>KUKUY</h1>
+            <p class="subtitle">Sistema de distribución de carga entre servidores backend con soporte para hooks y filtros</p>
+        </header>
+        <div class="dashboard">
+            <div class="card">
+                <h2>Estado del Sistema</h2>
+                <div class="stats-grid">
+                    <div class="stat-item">
+                        <div class="stat-value" id="requests-count">0</div>
+                        <div class="stat-label">Solicitudes</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="active-servers">0</div>
+                        <div class="stat-label">Servidores Activos</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="rps-value">0</div>
+                        <div class="stat-label">RPS Acumulado</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="instantaneous-rps">0</div>
+                        <div class="stat-label">RPS Instantáneo</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="avg-response">0ms</div>
+                        <div class="stat-label">Respuesta Promedio</div>
+                    </div>
+                </div>
+                <div class="controls">
+                    <button id="refresh-btn">Actualizar</button>
+                    <button id="start-btn">Iniciar</button>
+                    <button id="stop-btn">Detener</button>
+                </div>
+            </div>
+            <div class="card">
+                <h2>Configuración</h2>
+                <div class="stat-item" style="text-align: left;">
+                    <div><strong>Algoritmo Balanceo:</strong> <span id="algorithm">-</span></div>
+                    <div><strong>Puerto HTTP:</strong> <span id="http-port">-</span></div>
+                    <div><strong>Puerto HTTPS:</strong> <span id="https-port">-</span></div>
+                    <div><strong>Filtros Activos:</strong> <span id="filters-count">-</span></div>
+                </div>
+                <h2 style="margin-top: 20px;">Métricas del Sistema</h2>
+                <div class="stat-item" style="text-align: left;" id="system-metrics">
+                    <div><strong>Uso de CPU:</strong> <span id="cpu-usage">-</span>%</div>
+                    <div><strong>Uso de Memoria:</strong> <span id="memory-usage">-</span>%</div>
+                    <div><strong>Carga Promedio:</strong> <span id="load-average">-</span></div>
+                </div>
+                <h2 style="margin-top: 20px;">Hooks Registrados</h2>
+                <div class="stat-item" style="text-align: left;" id="hooks-list">
+                    <!-- Los hooks se cargarán dinámicamente -->
+                </div>
+            </div>
+            <div class="card servers-status">
+                <h2>Servidores Backend</h2>
+                <div id="servers-list">
+                    <div class="loading">Cargando servidores...</div>
+                </div>
+                <div class="metrics">
+                    <h2>Uso Reciente</h2>
+                    <div class="chart-container" id="usage-chart">
+                        <!-- Barras de uso se generarán dinámicamente -->
+                    </div>
+                </div>
+            </div>
+        </div>
+        <footer>
+            <p>KUKUY v1.2.1 | Sistema de Distribución de Carga con Hooks y Filtros</p>
+        </footer>
+    </div>
+    <script>
+        // URLs de la API
+        const API_BASE = window.location.origin;
+        const STATUS_API = `${API_BASE}/api/status`;
+        const METRICS_API = `${API_BASE}/api/metrics`;
+        const SERVERS_API = `${API_BASE}/api/servers`;
+        const SERVER_STATS_API = `${API_BASE}/api/server-stats`;
+        // Elementos del DOM
+        const elements = {
+            requestsCount: document.getElementById('requests-count'),
+            activeServers: document.getElementById('active-servers'),
+            rpsValue: document.getElementById('rps-value'),
+            instantaneousRps: document.getElementById('instantaneous-rps'),
+            avgResponse: document.getElementById('avg-response'),
+            algorithm: document.getElementById('algorithm'),
+            httpPort: document.getElementById('http-port'),
+            httpsPort: document.getElementById('https-port'),
+            filtersCount: document.getElementById('filters-count'),
+            serversList: document.getElementById('servers-list'),
+            refreshBtn: document.getElementById('refresh-btn'),
+            startBtn: document.getElementById('start-btn'),
+            stopBtn: document.getElementById('stop-btn'),
+            hooksList: document.getElementById('hooks-list'),
+            usageChart: document.getElementById('usage-chart'),
+            cpuUsage: document.getElementById('cpu-usage'),
+            memoryUsage: document.getElementById('memory-usage'),
+            loadAverage: document.getElementById('load-average')
+        };
+        // Variables para la configuración
+        let ws = null;
+        let reconnectInterval = null;
+        let websocketPort = 8083; // Puerto por defecto
+        // Cargar la configuración del servidor
+        async function loadServerConfig() {
+            try {
+                const response = await fetch('/api/config');
+                if (response.ok) {
+                    const config = await response.json();
+                    websocketPort = config.websocketPort || 8083;
+                }
+            } catch (error) {
+                console.error('Error cargando configuración del servidor:', error);
+                // Usar puerto por defecto si falla
+                websocketPort = 8083;
+            }
+        }
+        async function connectWebSocket() {
+            // Cargar la configuración antes de conectar
+            await loadServerConfig();
+            // Determinar la URL del WebSocket según el protocolo de la página y la configuración
+            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const wsUrl = `${protocol}//${window.location.hostname}:${websocketPort}`;
+            try {
+                ws = new WebSocket(wsUrl);
+                ws.onopen = function(event) {
+                    console.log(`Conectado al servidor WebSocket en puerto: ${websocketPort}`);
+                    clearInterval(reconnectInterval);
+                    reconnectInterval = null;
+                };
+                ws.onmessage = function(event) {
+                    try {
+                        const data = JSON.parse(event.data);
+                        if (data.type === 'metrics_update') {
+                            updateUIWithMetrics(data);
+                        }
+                    } catch (error) {
+                        console.error('Error procesando mensaje WebSocket:', error);
+                    }
+                };
+                ws.onclose = function(event) {
+                    console.log('Conexión WebSocket cerrada. Reconectando...');
+                    scheduleReconnect();
+                };
+                ws.onerror = function(error) {
+                    console.error('Error en WebSocket:', error);
+                };
+            } catch (error) {
+                console.error('Error creando WebSocket:', error);
+                scheduleReconnect();
+            }
+        }
+        function scheduleReconnect() {
+            if (reconnectInterval) return;
+            reconnectInterval = setInterval(() => {
+                console.log('Intentando reconectar al WebSocket...');
+                connectWebSocket();
+            }, 5000); // Reintentar cada 5 segundos
+        }
+        function updateUIWithMetrics(data) {
+            const { metrics, status } = data;
+            // Actualizar métricas principales
+            elements.requestsCount.textContent = metrics.requests?.total || 0;
+            elements.rpsValue.textContent = metrics.calculated?.cumulativeRps ? metrics.calculated.cumulativeRps.toFixed(2) : '0.00';
+            elements.instantaneousRps.textContent = metrics.calculated?.instantaneousRps ? metrics.calculated.instantaneousRps.toFixed(2) : '0.00';
+            elements.avgResponse.textContent = metrics.performance?.avgResponseTime ? Math.round(metrics.performance.avgResponseTime) + 'ms' : '0ms';
+            // Actualizar el conteo de servidores activos basado en métricas
+            elements.activeServers.textContent = metrics.servers?.healthy || 0;
+            // Actualizar algoritmo
+            elements.algorithm.textContent = status.algorithm || '-';
+            // Actualizar información adicional si está disponible
+            if (metrics.calculated?.successRate !== undefined) {
+                const successRateElement = document.createElement('div');
+                successRateElement.className = 'stat-item';
+                successRateElement.innerHTML = `
+                    <div class="stat-value">${metrics.calculated.successRate}%</div>
+                    <div class="stat-label">Tasa de Éxito</div>
+                `;
+                // Insertar después del elemento de servidores activos si no existe ya
+                const statsGrid = document.querySelector('.stats-grid');
+                const existingSuccessRate = statsGrid.querySelector('.success-rate');
+                if (!existingSuccessRate) {
+                    successRateElement.classList.add('success-rate');
+                    statsGrid.appendChild(successRateElement);
+                } else {
+                    existingSuccessRate.querySelector('.stat-value').textContent = metrics.calculated.successRate + '%';
+                }
+            }
+            // Actualizar métricas del sistema
+            if (metrics.system) {
+                elements.cpuUsage.textContent = metrics.system.cpuUsage ? metrics.system.cpuUsage.toFixed(2) : '-';
+                elements.memoryUsage.textContent = metrics.system.memoryUsage ? metrics.system.memoryUsage.toFixed(2) : '-';
+                // Mostrar la carga promedio (puede ser un array o un valor único)
+                if (Array.isArray(metrics.system.loadAverage)) {
+                    elements.loadAverage.textContent = metrics.system.loadAverage.join(', ');
+                } else {
+                    elements.loadAverage.textContent = metrics.system.loadAverage || '-';
+                }
+            }
+            // Actualizar gráfico de uso reciente
+            updateUsageChart(metrics);
+            // Actualizar lista de servidores
+            updateServersListFromMetrics(metrics);
+        }
+        // Función para actualizar el gráfico de uso reciente
+        function updateUsageChart(data) {
+            elements.usageChart.innerHTML = '';
+            // Obtener los últimos tiempos de respuesta para mostrar en el gráfico
+            const responseTimes = data.responseTimes || [];
+            const maxToShow = 10; // Mostrar solo los últimos 10 tiempos
+            // Tomar los últimos tiempos de respuesta
+            const timesToShow = responseTimes.slice(-maxToShow);
+            if (timesToShow.length === 0) {
+                elements.usageChart.innerHTML = '<div style="display:flex;align-items:center;justify-content:center;height:100%;width:100%;">Sin datos</div>';
+                return;
+            }
+            // Calcular el valor máximo para escalar las barras
+            const maxValue = Math.max(...timesToShow, 100); // Valor mínimo para visualización
+            // Crear barras para cada tiempo de respuesta
+            timesToShow.forEach(time => {
+                const barHeight = (time / maxValue) * 100; // Porcentaje basado en el valor máximo
+                const bar = document.createElement('div');
+                bar.className = 'bar';
+                bar.style.height = `${Math.max(barHeight, 5)}%`; // Altura mínima para visibilidad
+                bar.title = `${time}ms`;
+                elements.usageChart.appendChild(bar);
+            });
+        }
+        // Función para actualizar la lista de servidores desde las métricas
+        function updateServersListFromMetrics(metrics) {
+            // Si tenemos serverStats en las métricas, usarlos para actualizar la lista
+            if (metrics.serverStats) {
+                const servers = Object.values(metrics.serverStats).map(stat => ({
+                    id: stat.id,
+                    host: stat.id, // En este caso usamos el ID como host para simplificar
+                    url: `Servidor ${stat.id}`,
+                    status: stat.totalRequests > 0 ? 'online' : 'offline'
+                }));
+                elements.serversList.innerHTML = '';
+                if (!servers || servers.length === 0) {
+                    elements.serversList.innerHTML = '<div class="loading">No hay servidores disponibles</div>';
+                    return;
+                }
+                servers.forEach(server => {
+                    const serverItem = document.createElement('div');
+                    serverItem.className = 'server-item';
+                    serverItem.innerHTML = `
+                        <div>
+                            <span class="server-name">${server.id}. ${server.host}</span>
+                            <small>${server.url}</small>
+                        </div>
+                        <div>
+                            <span class="server-status status-${server.status}"></span>
+                            <span>${server.status}</span>
+                        </div>
+                    `;
+                    elements.serversList.appendChild(serverItem);
+                });
+            }
+        }
+        // Función para cargar hooks registrados
+        async function loadHooks() {
+            try {
+                // Para esta implementación, mostraremos hooks genéricos
+                // En una implementación real, esto vendría de una API específica
+                const hooks = ['onRequestReceived', 'onServerSelected', 'onResponseSent', 'onServerError'];
+                elements.hooksList.innerHTML = '';
+                hooks.forEach(hook => {
+                    const hookElement = document.createElement('div');
+                    hookElement.textContent = `• ${hook}`;
+                    elements.hooksList.appendChild(hookElement);
+                });
+            } catch (error) {
+                console.error('Error al cargar hooks:', error);
+            }
+        }
+        // Función para actualizar todos los datos (método de respaldo si WebSocket falla)
+        async function updateAllData() {
+            // Intentar cargar hooks
+            await loadHooks();
+        }
+        // Conectar al WebSocket
+        connectWebSocket();
+        // Cargar datos iniciales
+        updateAllData();
+        // Event listeners para botones
+        elements.refreshBtn.addEventListener('click', updateAllData);
+        elements.startBtn.addEventListener('click', () => {
+            alert('Funcionalidad de inicio no implementada en el panel web. Usa el script de inicio correspondiente.');
+        });
+        elements.stopBtn.addEventListener('click', () => {
+            alert('Funcionalidad de detención no implementada en el panel web. Usa pkill -f "node index.js" o el script de reinicio.');
+        });
+    </script>
+</body>
+</html>