aetherframework-cluster 1.0.0

package/src/examples/advanced-cluster.js

@@ -0,0 +1,150 @@
+// packages/cluster/src/examples/advanced-cluster.js
+import path from 'path';
+import { fileURLToPath } from 'url';
+import http from 'http';
+import cluster from 'cluster';
+import ClusterManager from '../core/ClusterManager.js';
+import CPUDetector from '../utils/cpu-detector.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function createApp() {
+  let requestCount = 0;
+  
+  const server = http.createServer((req, res) => {
+    requestCount++;
+    
+    console.log(`[Worker ${process.pid}] Received request #${requestCount}: ${req.method} ${req.url}`);
+    
+    const responseData = {
+      status: 'ok',
+      pid: process.pid,
+      workerId: process.env.WORKER_ID || 'unknown',
+      requestCount: requestCount,
+      message: 'Hello from Cluster Worker',
+      timestamp: new Date().toISOString(),
+      url: req.url,
+      method: req.method
+    };
+    
+    res.writeHead(200, { 
+      'Content-Type': 'application/json',
+      'X-Worker-PID': process.pid,
+      'X-Worker-ID': process.env.WORKER_ID || 'unknown'
+    });
+    
+    res.end(JSON.stringify(responseData, null, 2));
+    
+    if (process.send) {
+      process.send({ type: 'REQUEST_PROCESSED' });
+    }
+  });
+  
+  // 【Key fix】Use flag to avoid duplicate shutdown
+  let isShuttingDown = false;
+  
+  const gracefulShutdown = () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    
+    console.log(`Worker ${process.pid} starting graceful shutdown...`);
+    
+    server.close(() => {
+      console.log(`Worker ${process.pid} HTTP server closed`);
+      process.exit(0);
+    });
+    
+    // Set shutdown timeout
+    setTimeout(() => {
+      console.log(`Worker ${process.pid} shutdown timeout, forcing exit`);
+      process.exit(1);
+    }, 5000);
+  };
+  
+  // Listen for shutdown messages from master process
+  process.on('message', (message) => {
+    if (message.type === 'SHUTDOWN') {
+      console.log(`Worker ${process.pid} received shutdown signal from master`);
+      gracefulShutdown();
+    }
+  });
+  
+  // Listen for system signals (as backup)
+  process.once('SIGTERM', () => {
+    console.log(`Worker ${process.pid} received SIGTERM`);
+    gracefulShutdown();
+  });
+  
+  process.once('SIGINT', () => {
+    console.log(`Worker ${process.pid} received SIGINT`);
+    gracefulShutdown();
+  });
+  
+  return {
+    handleRequest: async (requestData, responseCallback) => {
+      const result = {
+        pid: process.pid,
+        workerId: process.env.WORKER_ID,
+        data: requestData,
+        processedAt: new Date().toISOString()
+      };
+      
+      if (responseCallback) {
+        responseCallback(result);
+      }
+      
+      return result;
+    },
+    
+    getStats: () => ({
+      pid: process.pid,
+      requestCount: requestCount,
+      uptime: process.uptime(),
+      memoryUsage: process.memoryUsage()
+    }),
+    
+    close: (callback) => {
+      server.close(callback);
+    }
+  };
+}
+
+async function main() {
+  console.log('🔧 Initializing Advanced Cluster Configuration...');
+  
+  const cpuInfo = CPUDetector.getInfo();
+  const optimalWorkers = CPUDetector.getOptimalWorkerCount({ reserve: 1 });
+  
+  console.log(`🖥️  Detected ${cpuInfo.count} cores. Using ${optimalWorkers} workers`);
+  
+  const clusterManager = new ClusterManager({
+    workers: optimalWorkers,
+    port: 3000,
+    gracefulShutdown: true,
+    restartOnExit: true,
+    restartDelay: 1000,
+    shutdownTimeout: 10000
+  });
+  
+  // Note: No longer listening for events here, as ClusterManager handles logging internally
+  // If custom event handling is needed, add it here but ensure no duplication
+  
+  // Start the cluster
+  await clusterManager.start(createApp);
+  
+  console.log('✅ Cluster is running. Press Ctrl+C to stop.');
+  
+  // Note: No longer setting SignalHandler here, as ClusterManager handles signals internally
+  // Avoid signal handling conflicts
+}
+
+// Execute only in master process
+if (cluster.isPrimary) {
+  main().catch((err) => {
+    console.error('Failed to start cluster:', err);
+    process.exit(1);
+  });
+} else {
+  // Worker processes don't execute any code, handled by ClusterManager.startWorker()
+}

package/src/examples/basic-cluster.js

@@ -0,0 +1,107 @@
+// packages/cluster/examples/basic-cluster-simple.js
+import http from 'http';
+import cluster from 'cluster'; 
+import ClusterManager from '../core/ClusterManager.js';
+
+/**
+ * Simple application factory function
+ */
+function createSimpleApp() {
+  const server = http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      pid: process.pid,
+      message: 'Hello from Simple Cluster',
+      timestamp: new Date().toISOString()
+    }));
+  });
+  
+  // 【Key fix】Use flag to avoid duplicate shutdown, consistent with advanced-cluster.js
+  let isShuttingDown = false;
+  
+  const gracefulShutdown = () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    
+    console.log(`Worker ${process.pid} starting graceful shutdown...`);
+    
+    server.close(() => {
+      console.log(`Worker ${process.pid} server closed`);
+      process.exit(0);
+    });
+    
+    // Set shutdown timeout
+    setTimeout(() => {
+      console.log(`Worker ${process.pid} shutdown timeout, forcing exit`);
+      process.exit(1);
+    }, 5000);
+  };
+  
+  // Listen for shutdown messages from master process
+  process.on('message', (message) => {
+    if (message.type === 'SHUTDOWN') {
+      console.log(`Worker ${process.pid} received shutdown signal from master`);
+      gracefulShutdown();
+    }
+  });
+  
+  // Listen for system signals (as backup)
+  process.once('SIGTERM', () => {
+    console.log(`Worker ${process.pid} received SIGTERM`);
+    gracefulShutdown();
+  });
+  
+  process.once('SIGINT', () => {
+    console.log(`Worker ${process.pid} received SIGINT`);
+    gracefulShutdown();
+  });
+  
+  return {
+    handleRequest: async (data, callback) => {
+      if (callback) {
+        callback({ pid: process.pid, data });
+      }
+      return { pid: process.pid, data };
+    },
+    
+    close: (callback) => {
+      server.close(callback);
+    }
+  };
+}
+
+
+async function main() {
+  console.log('🚀 Starting Simple Cluster Example...');
+  
+  const cluster = new ClusterManager({
+    workers: 2, // Fixed 2 worker processes
+    port: 3000,
+    gracefulShutdown: true,
+    shutdownTimeout: 10000
+  });
+  
+  // Basic event listeners
+  cluster.on('worker:ready', (data) => {
+    console.log(`Worker ${data.pid} ready`);
+  });
+  
+  cluster.on('cluster:ready', (data) => {
+    console.log(`Cluster ready on port ${data.port}`);
+  });
+  
+  // Listen for cluster shutdown events
+  cluster.on('cluster:shutdown', () => {
+    console.log('Cluster shutdown complete');
+  });
+  
+  await cluster.start(createSimpleApp);
+  
+  console.log('✅ Cluster running. Press Ctrl+C to stop.');
+  
+
+}
+
+if (cluster.isPrimary) {
+  main().catch(console.error);
+}

package/src/examples/benchmark-cluster.js

@@ -0,0 +1,112 @@
+// package/cluster/src/examples/benchmark-cluster.js
+import http from 'http';
+import net from 'net';
+import cluster from 'cluster';
+import os from 'os';
+import { Worker } from 'worker_threads';
+import ClusterManager from '../core/ClusterManager.js';
+
+if (!cluster.isPrimary) {
+    const CORES = os.availableParallelism?.() || os.cpus().length;
+    const workerPool = [];
+    const callbacks = new Map();
+    let nextId = 0;
+    let workerIndex = 0;
+
+    console.log(`[Worker ${process.pid}] Starting ${CORES} persistent Worker Threads`);
+
+    for (let i = 0; i < CORES; i++) {
+        const worker = new Worker(`
+            const { parentPort } = require('worker_threads');
+            parentPort.on('message', ({ id }) => {
+                let sum = 0;
+                for (let i = 0; i < 60000; i++) {        // Further reduce computation, target 4000+ req/s
+                    sum += Math.random() * 0.1;
+                }
+                parentPort.postMessage({ id, result: sum.toFixed(2) });
+            });
+        `, { eval: true });
+
+        worker.on('message', ({ id, result }) => {
+            const cb = callbacks.get(id);
+            if (cb) {
+                cb(result);
+                callbacks.delete(id);
+            }
+        });
+
+        workerPool.push(worker);
+    }
+
+    function heavyComputation() {
+        return new Promise(resolve => {
+            const id = nextId++;
+            callbacks.set(id, resolve);
+            const worker = workerPool[workerIndex];
+            workerIndex = (workerIndex + 1) % CORES;
+            worker.postMessage({ id });
+        });
+    }
+
+    const server = http.createServer(async (req, res) => {
+        const start = process.hrtime.bigint();
+
+        if (req.url === '/heavy') {
+            await heavyComputation();
+            const latencyMs = Number(process.hrtime.bigint() - start) / 1_000_000;
+
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Server': 'HighPerf-WorkerPool'
+            });
+            res.end(`{"ok":true,"ms":${latencyMs.toFixed(2)}}`);
+            return;
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end('{"status":"light"}');
+    });
+
+    server.listen(3005, '127.0.0.1', () => {
+        console.log(`✅ Worker ${process.pid} listening on http://127.0.0.1:3005`);
+        if (process.send) process.send({ type: 'READY', pid: process.pid });
+    });
+}
+
+// ====================== Master Process ======================
+async function isPortAvailable(port) {
+    return new Promise(r => {
+        const s = net.createServer()
+            .once('error', () => r(false))
+            .once('listening', () => { s.close(); r(true); })
+            .listen(port, '127.0.0.1');
+    });
+}
+
+async function main() {
+    console.log('🚀 Starting final high-performance version (Single Process + Optimized Thread Pool)...');
+
+    if (!(await isPortAvailable(3005))) {
+        console.error('❌ Port 3005 is already in use');
+        process.exit(1);
+    }
+
+    const manager = new ClusterManager({
+        workers: 1,
+        port: 3005
+    });
+
+    manager.on('worker:ready', () => {
+        console.log('\n🎉 Service is ready! Recommended benchmark:');
+        console.log('autocannon -c 1000 -d 30 -p 10 http://127.0.0.1:3005/heavy\n');
+    });
+
+    manager.start();
+}
+
+if (cluster.isPrimary) {
+    main().catch(err => {
+        console.error('Startup failed:', err);
+        process.exit(1);
+    });
+}

package/src/examples/simple-app.js

@@ -0,0 +1,52 @@
+// packages/cluster/src/examples/simple-app.js
+import http from 'http';
+
+/**
+ * Application factory function
+ * This function is called when each Worker process starts to create a service instance
+ */
+export default function createApp() {
+  // 1. Create HTTP server
+  const server = http.createServer((req, res) => {
+    // Log request
+    console.log(`[Worker ${process.pid}] Received request: ${req.method} ${req.url}`);
+
+    // Build response data
+    const responseData = {
+      status: 'ok',
+      pid: process.pid,
+      workerId: process.env.WORKER_ID || 'unknown',
+      message: 'Hello from Cluster Worker',
+      timestamp: new Date().toISOString(),
+      url: req.url
+    };
+
+    // Send response
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(responseData, null, 2));
+  });
+
+  // 2. Return object containing handleRequest method
+  // ClusterManager expects to interact with your application this way
+  return {
+    server, // Keep server reference for later closing
+    
+    // ClusterManager will call this method to handle incoming requests or start listening
+    handleRequest: (req, res) => {
+      server.emit('request', req, res);
+    },
+
+    // Optional: Method to start listening on a port
+    listen: (port, callback) => {
+      server.listen(port, () => {
+        console.log(`[Worker ${process.pid}] Server listening on port ${port}`);
+        if (callback) callback();
+      });
+    },
+
+    // Optional: Method to close the server
+    close: (callback) => {
+      server.close(callback);
+    }
+  };
+}