#!/usr/bin/env node
/**
* Integrated Real-time Server - gRPC + WebSocket Bridge + Data Service
*
* Este servidor integra:
* - gRPC server optimizado para datos en tiempo real
* - WebSocket bridge para compatibilidad con navegadores
* - Data service conectado a MongoDB/Redis para datos reales
* - Dashboard con datos reales en tiempo real (no más mock data)
*/
import { getOptimizedGrpcServer } from './grpc-server.js';
import { getWebSocketGrpcBridge } from './websocket-bridge.js';
import { getDataService } from './data-service.js';
class IntegratedRealTimeServer {
constructor() {
this.grpcServer = null;
this.websocketBridge = null;
this.dataService = null;
this.isRunning = false;
// Configuration
this.config = {
grpcPort: process.env.GRPC_PORT || 50051,
wsPort: process.env.WS_PORT || 8080,
environment: process.env.NODE_ENV || 'development'
};
}
/**
* Initialize and start all services
*/
async start() {
try {
console.log('🚀 Starting Integrated Real-time Server...');
console.log(`📊 Environment: ${this.config.environment}`);
console.log(`🔧 gRPC Port: ${this.config.grpcPort}`);
console.log(`🌉 WebSocket Port: ${this.config.wsPort}`);
console.log('═'.repeat(60));
// 1. Initialize Data Service (MongoDB/Redis)
console.log('📀 Step 1: Initializing Data Service...');
this.dataService = getDataService();
const dataServiceReady = await this.dataService.initialize();
if (dataServiceReady) {
console.log('✅ Data Service connected to MongoDB/Redis');
// Test data access
const testStats = await this.dataService.getLiveStats();
console.log(`📊 Test data loaded: ${testStats.active_sessions} active sessions, ${testStats.total_messages} messages`);
} else {
console.warn('⚠️ Data Service initialization failed, will use fallback data');
}
// 2. Start gRPC Server
console.log('📡 Step 2: Starting gRPC Server...');
this.grpcServer = getOptimizedGrpcServer();
const grpcStarted = await this.grpcServer.start(this.config.grpcPort);
if (grpcStarted) {
console.log(`✅ gRPC Server running on port ${this.config.grpcPort}`);
} else {
throw new Error('Failed to start gRPC server');
}
// 3. Start WebSocket Bridge
console.log('🌉 Step 3: Starting WebSocket Bridge...');
this.websocketBridge = getWebSocketGrpcBridge();
const bridgeStarted = await this.websocketBridge.initialize();
if (bridgeStarted) {
console.log(`✅ WebSocket Bridge running on port ${this.config.wsPort}`);
} else {
throw new Error('Failed to start WebSocket bridge');
}
this.isRunning = true;
// Setup graceful shutdown
this.setupGracefulShutdown();
console.log('═'.repeat(60));
console.log('🎉 Integrated Real-time Server STARTED successfully!');
console.log('');
console.log('📋 Service Status:');
console.log(` 📀 Data Service: ${dataServiceReady ? '🟢 CONNECTED' : '🟡 FALLBACK'}`);
console.log(` 📡 gRPC Server: 🟢 RUNNING (port ${this.config.grpcPort})`);
console.log(` 🌉 WebSocket Bridge: 🟢 RUNNING (port ${this.config.wsPort})`);
console.log('');
console.log('🔗 Connection URLs:');
console.log(` gRPC: localhost:${this.config.grpcPort}`);
console.log(` WebSocket: ws://localhost:${this.config.wsPort}/grpc-ws`);
console.log(` Dashboard: http://localhost:3005`);
console.log('');
console.log('💡 Dashboard ahora usa DATOS REALES en tiempo real!');
console.log(' - Sesiones activas: REAL count (no más hardcoded "1")');
console.log(' - Estadísticas: Desde MongoDB en tiempo real');
console.log(' - Conversaciones: Datos reales sin mock');
console.log('═'.repeat(60));
return true;
} catch (error) {
console.error('❌ Failed to start Integrated Real-time Server:', error);
await this.stop();
return false;
}
}
/**
* Stop all services gracefully
*/
async stop() {
if (!this.isRunning) {
console.log('⚠️ Server is not running');
return;
}
console.log('🛑 Shutting down Integrated Real-time Server...');
try {
// Stop WebSocket Bridge
if (this.websocketBridge) {
console.log('🌉 Stopping WebSocket Bridge...');
await this.websocketBridge.shutdown();
console.log('✅ WebSocket Bridge stopped');
}
// Stop gRPC Server
if (this.grpcServer) {
console.log('📡 Stopping gRPC Server...');
await this.grpcServer.stop();
console.log('✅ gRPC Server stopped');
}
// Close Data Service
if (this.dataService) {
console.log('📀 Closing Data Service...');
await this.dataService.close();
console.log('✅ Data Service closed');
}
this.isRunning = false;
console.log('✅ Integrated Real-time Server shut down successfully');
} catch (error) {
console.error('❌ Error during shutdown:', error);
}
}
/**
* Setup graceful shutdown handlers
*/
setupGracefulShutdown() {
const shutdown = async (signal) => {
console.log(`\n📡 Received ${signal}, initiating graceful shutdown...`);
await this.stop();
process.exit(0);
};
process.on('SIGINT', () => shutdown('SIGINT'));
process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('uncaughtException', (error) => {
console.error('❌ Uncaught Exception:', error);
this.stop().then(() => process.exit(1));
});
process.on('unhandledRejection', (reason, promise) => {
console.error('❌ Unhandled Rejection at:', promise, 'reason:', reason);
this.stop().then(() => process.exit(1));
});
}
/**
* Get server status and statistics
*/
async getStatus() {
const status = {
isRunning: this.isRunning,
services: {
dataService: this.dataService ? await this.dataService.healthCheck() : null,
grpcServer: this.grpcServer ? await this.grpcServer.healthCheck() : null,
websocketBridge: this.websocketBridge ? this.websocketBridge.getStats() : null
},
config: this.config,
timestamp: Date.now()
};
return status;
}
/**
* Print detailed status
*/
async printStatus() {
const status = await this.getStatus();
console.log('📊 Server Status Report');
console.log('═'.repeat(50));
console.log(`Running: ${status.isRunning ? '🟢 YES' : '🔴 NO'}`);
console.log(`Environment: ${status.config.environment}`);
console.log(`Timestamp: ${new Date(status.timestamp).toISOString()}`);
console.log('');
if (status.services.dataService) {
console.log('📀 Data Service:');
console.log(` Status: ${status.services.dataService.status === 'healthy' ? '🟢' : '🟡'} ${status.services.dataService.status}`);
console.log(` MongoDB: ${status.services.dataService.mongodb ? '🟢' : '🔴'}`);
console.log(` Redis: ${status.services.dataService.redis ? '🟢' : '🔴'}`);
}
if (status.services.grpcServer) {
console.log('📡 gRPC Server:');
console.log(` Status: ${status.services.grpcServer.status === 'healthy' ? '🟢' : '🔴'} ${status.services.grpcServer.status}`);
console.log(` Connections: ${status.services.grpcServer.connections}`);
console.log(` Streams: ${status.services.grpcServer.streams}`);
}
if (status.services.websocketBridge) {
console.log('🌉 WebSocket Bridge:');
console.log(` Connected Clients: ${status.services.websocketBridge.connectedClients}`);
console.log(` Port: ${status.services.websocketBridge.port}`);
}
console.log('═'.repeat(50));
}
}
// CLI handling
if (process.argv[1].endsWith('integrated-server.js')) {
const server = new IntegratedRealTimeServer();
const command = process.argv[2];
switch (command) {
case 'start':
case undefined:
server.start().then((success) => {
if (!success) {
process.exit(1);
}
});
break;
case 'status':
server.printStatus().then(() => {
process.exit(0);
});
break;
case 'stop':
server.stop().then(() => {
process.exit(0);
});
break;
default:
console.log('Usage: node integrated-server.js [start|stop|status]');
console.log('');
console.log('Commands:');
console.log(' start - Start the integrated server (default)');
console.log(' status - Show server status');
console.log(' stop - Stop the server gracefully');
process.exit(1);
}
}
export default IntegratedRealTimeServer;
