@aetherframework/websocket 1.0.1 → 1.0.3

package/examples//342/200/214stress-test-server.js

@@ -0,0 +1,495 @@
+/**
+ * @file WebSocket Stress Test Server
+ * @description A WebSocket server designed for load testing and performance benchmarking
+ */
+
+import { WebSocketFactory } from '../index.js';
+import FrameEncoder from '../src/utils/frame-encoder.js'; // 添加这行导入
+
+// Configuration for stress testing
+const STRESS_TEST_CONFIG = {
+  driver: 'http',
+  port: process.env.STRESS_TEST_PORT || 8081,
+  host: process.env.STRESS_TEST_HOST || '0.0.0.0',
+  maxPayload: 10 * 1024 * 1024, // 10MB for large message testing
+  pingInterval: 60000, // 60 seconds (reduced for stress testing)
+  pingTimeout: 30000, // 30 seconds timeout
+  maxConnections: 100000, // High connection limit for stress testing
+  socketTimeout: 0 // No timeout for long-running connections
+};
+
+// Statistics tracking
+const stats = {
+  connections: {
+    total: 0,
+    active: 0,
+    peak: 0
+  },
+  messages: {
+    received: 0,
+    sent: 0,
+    bytesReceived: 0,
+    bytesSent: 0
+  },
+  errors: {
+    connection: 0,
+    message: 0,
+    other: 0
+  },
+  startTime: Date.now()
+};
+
+// Store active connections for message handling
+const activeConnections = new Map();
+
+async function main() {
+  try {
+    console.log('⚡ Starting WebSocket Stress Test Server...');
+    console.log(`📊 Port: ${STRESS_TEST_CONFIG.port}`);
+    console.log(`🏠 Host: ${STRESS_TEST_CONFIG.host}`);
+    console.log(`🔧 Max Connections: ${STRESS_TEST_CONFIG.maxConnections}`);
+    console.log(`📦 Max Payload: ${STRESS_TEST_CONFIG.maxPayload / 1024 / 1024}MB`);
+    
+    // Create WebSocket factory instance with stress test configuration
+    const factory = new WebSocketFactory(STRESS_TEST_CONFIG);
+
+    // Create server
+    const server = await factory.createServer();
+    
+    // Listen for server listening event
+    factory.on('server:listening', (address) => {
+      console.log(`\n🎯 ============================================`);
+      console.log(`⚡ Stress Test Server listening on ws://${address.host}:${address.port}`);
+      console.log(`📈 Ready for load testing and performance benchmarking`);
+      console.log(`🛑 Press Ctrl+C to stop the server`);
+      console.log(`============================================\n`);
+      
+      // Start statistics logging
+      startStatisticsLogging();
+    });
+    
+    // Listen for connection events
+    factory.on('connection', (connection) => {
+      // Update connection statistics
+      stats.connections.total++;
+      stats.connections.active++;
+      stats.connections.peak = Math.max(stats.connections.peak, stats.connections.active);
+      
+      const connectionId = connection.id || `conn_${stats.connections.total}`;
+      const remoteAddress = connection.remoteAddress || 'unknown';
+      
+      // Store connection for later use
+      activeConnections.set(connectionId, connection);
+      
+      console.log(`🔗 Client connected: ${connectionId} from ${remoteAddress}`);
+      console.log(`📊 Active connections: ${stats.connections.active}/${stats.connections.total}`);
+      
+      // Log connection object structure for debugging
+      console.log(`🔍 Connection object type: ${typeof connection}`);
+      console.log(`🔍 Connection object keys:`, Object.keys(connection));
+      
+      // Send connection acknowledgment with server info
+      const ackMessage = JSON.stringify({
+        type: 'connection_ack',
+        connectionId: connectionId,
+        serverTime: Date.now(),
+        stats: {
+          activeConnections: stats.connections.active,
+          uptime: Date.now() - stats.startTime
+        }
+      });
+      
+      // Send message through driver's socket
+      if (connection.socket && typeof connection.socket.write === 'function') {
+        try {
+          // Create WebSocket frame for the message
+          const frame = createWebSocketFrame(ackMessage);
+          connection.socket.write(frame);
+          stats.messages.sent++;
+          stats.messages.bytesSent += Buffer.byteLength(ackMessage);
+        } catch (error) {
+          console.error(`❌ Error sending acknowledgment to ${connectionId}:`, error.message);
+        }
+      } else {
+        console.error(`❌ No socket available for connection ${connectionId}`);
+      }
+    });
+    
+    // Listen for message events from factory (not from connection object)
+    factory.on('message', (connection, data, isBinary) => {
+      const connectionId = connection.id || 'unknown';
+      const messageSize = Buffer.byteLength(data);
+      stats.messages.received++;
+      stats.messages.bytesReceived += messageSize;
+      
+      // Log message statistics periodically
+      if (stats.messages.received % 1000 === 0) {
+        console.log(`📨 Received ${stats.messages.received} messages (${formatBytes(stats.messages.bytesReceived)})`);
+      }
+      
+      // Process different types of stress test messages
+      try {
+        if (isBinary) {
+          // Handle binary data (for binary stress testing)
+          handleBinaryMessage(connection, data, messageSize);
+        } else {
+          // Handle text data
+          const message = data.toString();
+          handleTextMessage(connection, message, messageSize);
+        }
+      } catch (error) {
+        stats.errors.message++;
+        console.error(`❌ Message processing error for ${connectionId}:`, error.message);
+      }
+    });
+    
+    // Listen for close events from factory
+    factory.on('close', (connection, code, reason) => {
+      const connectionId = connection.id || 'unknown';
+      stats.connections.active--;
+      console.log(`👋 Client disconnected: ${connectionId}, code: ${code}, reason: ${reason}`);
+      console.log(`📊 Active connections: ${stats.connections.active}/${stats.connections.total}`);
+      
+      // Remove from active connections
+      activeConnections.delete(connectionId);
+    });
+    
+    // Listen for error events from factory
+    factory.on('error', (error) => {
+      stats.errors.other++;
+      console.error('💥 Server error:', error);
+    });
+    
+    // Handle different types of stress test messages
+    function handleTextMessage(connection, message, messageSize) {
+      const connectionId = connection.id || 'unknown';
+      
+      try {
+        const parsed = JSON.parse(message);
+        
+        switch (parsed.type) {
+          case 'echo':
+            // Echo back the message (basic echo test)
+            const echoResponse = {
+              type: 'echo_response',
+              original: parsed.data,
+              timestamp: Date.now(),
+              messageSize: messageSize
+            };
+            sendToConnection(connection, JSON.stringify(echoResponse));
+            stats.messages.sent++;
+            stats.messages.bytesSent += Buffer.byteLength(JSON.stringify(echoResponse));
+            break;
+            
+          case 'broadcast':
+            // Broadcast message to all connections (broadcast stress test)
+            const broadcastMessage = JSON.stringify({
+              type: 'broadcast',
+              from: connectionId,
+              data: parsed.data,
+              timestamp: Date.now()
+            });
+            
+            // Broadcast to all active connections
+            broadcastToAll(broadcastMessage, connectionId);
+            break;
+            
+          case 'stats_request':
+            // Return server statistics
+            const statsResponse = {
+              type: 'stats_response',
+              stats: getCurrentStats(),
+              timestamp: Date.now()
+            };
+            sendToConnection(connection, JSON.stringify(statsResponse));
+            stats.messages.sent++;
+            break;
+            
+          case 'large_payload':
+            // Test large payload handling
+            const largeResponse = {
+              type: 'large_payload_response',
+              size: parsed.size || 1024,
+              data: 'x'.repeat(parsed.size || 1024),
+              timestamp: Date.now()
+            };
+            sendToConnection(connection, JSON.stringify(largeResponse));
+            stats.messages.sent++;
+            stats.messages.bytesSent += Buffer.byteLength(JSON.stringify(largeResponse));
+            break;
+            
+          case 'stress_test':
+            // Run a stress test sequence
+            runStressTestSequence(connection, parsed);
+            break;
+            
+          default:
+            // Default echo response
+            const defaultResponse = {
+              type: 'default_response',
+              received: parsed,
+              timestamp: Date.now()
+            };
+            sendToConnection(connection, JSON.stringify(defaultResponse));
+            stats.messages.sent++;
+        }
+      } catch (error) {
+        // If JSON parsing fails, echo back as text
+        const echoText = `Echo: ${message}`;
+        sendToConnection(connection, echoText);
+        stats.messages.sent++;
+        stats.messages.bytesSent += Buffer.byteLength(echoText);
+      }
+    }
+    
+    function handleBinaryMessage(connection, data, messageSize) {
+      // For binary stress testing, echo back the binary data
+      sendToConnection(connection, data, true);
+      stats.messages.sent++;
+      stats.messages.bytesSent += messageSize;
+      
+      // Log binary message statistics
+      if (stats.messages.received % 100 === 0) {
+        console.log(`🔢 Binary message: ${formatBytes(messageSize)} from ${connection.id || 'unknown'}`);
+      }
+    }
+    
+    function sendToConnection(connection, data, isBinary = false) {
+      try {
+        if (connection.socket && typeof connection.socket.write === 'function') {
+          // Create WebSocket frame
+          const frame = createWebSocketFrame(data, isBinary);
+          return connection.socket.write(frame);
+        } else {
+          console.error(`❌ No socket available for connection ${connection.id || 'unknown'}`);
+          return false;
+        }
+      } catch (error) {
+        console.error(`❌ Error sending to connection ${connection.id || 'unknown'}:`, error.message);
+        return false;
+      }
+    }
+    
+  function createWebSocketFrame(data, isBinary = false) {
+  try {
+    // 使用 FrameEncoder 创建正确的 WebSocket 帧
+    const opcode = isBinary ? 0x2 : 0x1; // 0x1 = TEXT, 0x2 = BINARY
+    return FrameEncoder.encode(opcode, data, true, false); // fin=true, mask=false (服务器到客户端不需要掩码)
+  } catch (error) {
+    console.error('❌ Error creating WebSocket frame:', error.message);
+    
+    // 回退到简单实现
+    const payload = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+    const payloadLength = payload.length;
+    
+    let frame;
+    if (payloadLength <= 125) {
+      frame = Buffer.alloc(2 + payloadLength);
+      frame = isBinary ? 0x82 : 0x81; // FIN + opcode
+      frame = payloadLength; // No mask
+      payload.copy(frame, 2);
+    } else if (payloadLength <= 65535) {
+      frame = Buffer.alloc(4 + payloadLength);
+      frame = isBinary ? 0x82 : 0x81;
+      frame = 126; // Extended payload length
+      frame.writeUInt16BE(payloadLength, 2);
+      payload.copy(frame, 4);
+    } else {
+      frame = Buffer.alloc(10 + payloadLength);
+      frame = isBinary ? 0x82 : 0x81;
+      frame = 127; // 64-bit payload length
+      frame.writeBigUInt64BE(BigInt(payloadLength), 2);
+      payload.copy(frame, 10);
+    }
+    
+    return frame;
+  }
+}
+    
+    function broadcastToAll(message, excludeConnectionId = null) {
+      let sentCount = 0;
+      
+      activeConnections.forEach((connection, id) => {
+        if (excludeConnectionId && id === excludeConnectionId) {
+          return; // Skip excluded connection
+        }
+        
+        if (sendToConnection(connection, message)) {
+          sentCount++;
+        }
+      });
+      
+      stats.messages.sent += sentCount;
+      return sentCount;
+    }
+    
+    function runStressTestSequence(connection, testConfig) {
+      const { iterations = 100, delay = 10, payloadSize = 1024 } = testConfig;
+      const connectionId = connection.id || 'unknown';
+      
+      console.log(`🧪 Starting stress test for ${connectionId}: ${iterations} iterations`);
+      
+      let completed = 0;
+      const testStartTime = Date.now();
+      
+      function sendTestMessage(index) {
+        if (index >= iterations) {
+          // Test complete
+          const testDuration = Date.now() - testStartTime;
+          const messagesPerSecond = iterations / (testDuration / 1000);
+          
+          const completionMessage = JSON.stringify({
+            type: 'stress_test_complete',
+            iterations: iterations,
+            duration: testDuration,
+            messagesPerSecond: messagesPerSecond.toFixed(2),
+            timestamp: Date.now()
+          });
+          
+          sendToConnection(connection, completionMessage);
+          
+          console.log(`✅ Stress test completed for ${connectionId}: ${messagesPerSecond.toFixed(2)} msg/sec`);
+          return;
+        }
+        
+        const testMessage = {
+          type: 'stress_test_message',
+          index: index,
+          payload: 'x'.repeat(payloadSize),
+          timestamp: Date.now()
+        };
+        
+        if (sendToConnection(connection, JSON.stringify(testMessage))) {
+          stats.messages.sent++;
+          stats.messages.bytesSent += Buffer.byteLength(JSON.stringify(testMessage));
+        }
+        
+        setTimeout(() => sendTestMessage(index + 1), delay);
+      }
+      
+      sendTestMessage(0);
+    }
+    
+    function getCurrentStats() {
+      const uptime = Date.now() - stats.startTime;
+      const hours = Math.floor(uptime / 3600000);
+      const minutes = Math.floor((uptime % 3600000) / 60000);
+      const seconds = Math.floor((uptime % 60000) / 1000);
+      
+      return {
+        connections: {
+          total: stats.connections.total,
+          active: stats.connections.active,
+          peak: stats.connections.peak
+        },
+        messages: {
+          received: stats.messages.received,
+          sent: stats.messages.sent,
+          bytesReceived: formatBytes(stats.messages.bytesReceived),
+          bytesSent: formatBytes(stats.messages.bytesSent),
+          receiveRate: (stats.messages.received / (uptime / 1000)).toFixed(2),
+          sendRate: (stats.messages.sent / (uptime / 1000)).toFixed(2)
+        },
+        errors: stats.errors,
+        uptime: `${hours}h ${minutes}m ${seconds}s`,
+        memory: process.memoryUsage()
+      };
+    }
+    
+    function formatBytes(bytes) {
+      if (bytes === 0) return '0 Bytes';
+      const k = 1024;
+      const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+      const i = Math.floor(Math.log(bytes) / Math.log(k));
+      return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    
+    function startStatisticsLogging() {
+      // Log statistics every 30 seconds
+      setInterval(() => {
+        const currentStats = getCurrentStats();
+        console.log('\n📈 ========== SERVER STATISTICS ==========');
+        console.log(`⏱️  Uptime: ${currentStats.uptime}`);
+        console.log(`👥 Connections: ${currentStats.connections.active} active / ${currentStats.connections.total} total (Peak: ${currentStats.connections.peak})`);
+        console.log(`📨 Messages: ${currentStats.messages.received} received, ${currentStats.messages.sent} sent`);
+        console.log(`📊 Data: ${currentStats.messages.bytesReceived} received, ${currentStats.messages.bytesSent} sent`);
+        console.log(`⚡ Rates: ${currentStats.messages.receiveRate} msg/sec received, ${currentStats.messages.sendRate} msg/sec sent`);
+        console.log(`❌ Errors: ${currentStats.errors.connection} connection, ${currentStats.errors.message} message, ${currentStats.errors.other} other`);
+        console.log(`💾 Memory: ${formatBytes(currentStats.memory.rss)} RSS, ${formatBytes(currentStats.memory.heapUsed)} heap used`);
+        console.log(`========================================\n`);
+      }, 30000);
+    }
+    
+    // Graceful shutdown handling
+    process.on('SIGINT', async () => {
+      console.log('\n🔄 Shutting down stress test server...');
+      console.log('📊 Final statistics:');
+      console.log(JSON.stringify(getCurrentStats(), null, 2));
+      
+      try {
+        await factory.close();
+        console.log('✅ Stress test server closed successfully');
+        process.exit(0);
+      } catch (error) {
+        console.error('❌ Error closing server:', error);
+        process.exit(1);
+      }
+    });
+    
+    process.on('SIGTERM', async () => {
+      console.log('\n🔄 Received SIGTERM, shutting down...');
+      await factory.close();
+      process.exit(0);
+    });
+    
+    // Display test client instructions
+    console.log('\n🧪 ========== STRESS TEST CLIENT EXAMPLES ==========');
+    console.log('1. Basic Echo Test:');
+    console.log(`
+const ws = new WebSocket('ws://localhost:${STRESS_TEST_CONFIG.port}');
+ws.onopen = () => {
+  for(let i = 0; i < 1000; i++) {
+    ws.send(JSON.stringify({type: 'echo', data: 'Test message ' + i}));
+  }
+};
+    `);
+    
+    console.log('\n2. Large Payload Test:');
+    console.log(`
+const ws = new WebSocket('ws://localhost:${STRESS_TEST_CONFIG.port}');
+ws.onopen = () => {
+  ws.send(JSON.stringify({type: 'large_payload', size: 1000000}));
+};
+    `);
+    
+    console.log('\n3. Stress Test Sequence:');
+    console.log(`
+const ws = new WebSocket('ws://localhost:${STRESS_TEST_CONFIG.port}');
+ws.onopen = () => {
+  ws.send(JSON.stringify({
+    type: 'stress_test',
+    iterations: 1000,
+    delay: 0,
+    payloadSize: 1024
+  }));
+};
+    `);
+    
+    console.log('\n4. Request Statistics:');
+    console.log(`
+const ws = new WebSocket('ws://localhost:${STRESS_TEST_CONFIG.port}');
+ws.onopen = () => {
+  ws.send(JSON.stringify({type: 'stats_request'}));
+  ws.onmessage = (e) => console.log('Stats:', JSON.parse(e.data));
+};
+    `);
+    console.log('==================================================\n');
+    
+  } catch (error) {
+    console.error('❌ Failed to start stress test server:', error);
+    process.exit(1);
+  }
+}
+
+// Start the stress test server
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aetherframework/websocket",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Zero-dependency WebSocket server implementation for AetherJS",
   "main": "index.js",
   "types": "index.d.ts",
@@ -43,6 +43,8 @@
   "files": [
     "index.js",
     "server.js",
+    "src",
+    "examples",
     "connection.js",
     "README.md",
     "LICENSE"