feat: support reusePort on server listen

.github/workflows/nodejs.yml

@@ -12,6 +12,6 @@ jobs:
     uses: node-modules/github-actions/.github/workflows/node-test.yml@master
     with:
       os: 'ubuntu-latest, macos-latest'
-      version: '14, 16, 18, 20, 22'
+      version: '14, 16, 18, 20, 22, 24'
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -9,3 +9,4 @@ run
 .nyc_output
 package-lock.json
 .package-lock.json
+pnpm-lock.yaml

README.md

@@ -8,8 +8,8 @@
 
 [npm-image]: https://img.shields.io/npm/v/egg-cluster.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/egg-cluster
-[codecov-image]: https://codecov.io/github/eggjs/egg-cluster/coverage.svg?branch=master
-[codecov-url]: https://codecov.io/github/eggjs/egg-cluster?branch=master
+[codecov-image]: https://codecov.io/github/eggjs/cluster/coverage.svg?branch=master
+[codecov-url]: https://codecov.io/github/eggjs/cluster?branch=master
 [snyk-image]: https://snyk.io/test/npm/egg-cluster/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/egg-cluster
 [download-image]: https://img.shields.io/npm/dm/egg-cluster.svg?style=flat-square
@@ -53,12 +53,13 @@ startCluster(options, () => {
 | workers      | `Number`  | numbers of app workers                   |
 | sticky       | `Boolean` | sticky mode server                       |
 | port         | `Number`  | port                                     |
+| reusePort   | `Boolean` | (Required Node.js >= 22.12.0) allows multiple sockets on the same host to bind to the same port. Incoming connections are distributed by the operating system to listening sockets. This option is available only on some platforms, such as Linux 3.9+, DragonFlyBSD 3.6+, FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+. **Default:** `false` |
 | debugPort    | `Number`  | the debug port only listen on http protocol |
 | https        | `Object`  | start a https server, note: `key` / `cert` / `ca` should be full path to file |
 | require      | `Array\|String` | will inject into worker/agent process |
 | pidFile      | `String`  | will save master pid to this file |
 | startMode    | `String`  | default is 'process', use 'worker_threads' to start the app & agent worker by worker_threads |
-| ports        | `Array`   | startup port of each app worker, such as: [7001, 7002, 7003], only effects when the startMode is 'worker_threads' |
+| ports        | `Array`   | startup port of each app worker, such as: [7001, 7002, 7003], only effects when the `startMode` is `'worker_threads'` and `reusePort` is `false` |
 | env        | `String`   | custom env, default is process.env.EGG_SERVER_ENV |
 
 ## Env

lib/agent_worker.js

@@ -24,7 +24,7 @@ if (options.startMode === 'worker_threads') {
   AgentWorker = require('./utils/mode/impl/process/agent').AgentWorker;
 }
 
-const debug = require('util').debuglog('egg-cluster');
+const debug = require('util').debuglog('egg-cluster:agent_worker');
 const ConsoleLogger = require('egg-logger').EggConsoleLogger;
 const consoleLogger = new ConsoleLogger({ level: process.env.EGG_AGENT_WORKER_LOGGER_LEVEL });
 

lib/app_worker.js

@@ -16,9 +16,11 @@
   AppWorker = require('./utils/mode/impl/process/app').AppWorker;
 }
 
+const os = require('os');
 const fs = require('fs');
-const debug = require('util').debuglog('egg-cluster');
+const debug = require('util').debuglog('egg-cluster:app_worker');
 const ConsoleLogger = require('egg-logger').EggConsoleLogger;
+
 const consoleLogger = new ConsoleLogger({
   level: process.env.EGG_APP_WORKER_LOGGER_LEVEL,
 });
@@ -38,6 +40,14 @@
 const debugPort = options.debugPort;
 const protocol = (httpsOptions.key && httpsOptions.cert) ? 'https' : 'http';
 
+let reusePort = options.reusePort = options.reusePort || listenConfig.reusePort;
+if (reusePort && os.platform() !== 'linux') {
+  // Currently only linux is supported
+  reusePort = false;
+  options.reusePort = false;
+  debug('platform %s is not support currently, set reusePort to false', os.platform());
+}
+
 AppWorker.send({
   to: 'master',
   action: 'realport',
@@ -121,10 +131,23 @@
         exitProcess();
         return;
       }
-      const args = [ port ];
-      if (listenConfig.hostname) args.push(listenConfig.hostname);
-      debug('listen options %s', args);
-      server.listen(...args);
+      if (reusePort) {
+        // https://nodejs.org/api/net.html#serverlistenoptions-callback
+        // When exclusive is true, the handle is not shared, and attempted port sharing results in an error. 
+        const listenOptions = { port, reusePort, exclusive: true };
+        if (listenConfig.hostname) {
+          listenOptions.host = listenConfig.hostname;
+        }
+        debug('listen options %s', listenOptions);
+        server.listen(listenOptions);
+      } else {
+        const args = [ port ];
+        if (listenConfig.hostname) {
+          args.push(listenConfig.hostname);
+        }
+        debug('listen options %s', args);
+        server.listen(...args);
+      }
     }
     if (debugPortServer) {
       debug('listen on debug port: %s', debugPort);

lib/master.js

@@ -34,6 +34,7 @@ class Master extends EventEmitter {
    *  - {Object} [plugins] - customized plugins, for unittest
    *  - {Number} [workers] numbers of app workers, default to `os.cpus().length`
    *  - {Number} [port] listening port, default to 7001(http) or 8443(https)
+   *  - {Boolean} [reusePort] setting `reusePort` to `true` allows multiple sockets on the same host to bind to the same port. Incoming connections are distributed by the operating system to listening sockets. This option is available only on some platforms, such as Linux 3.9+, DragonFlyBSD 3.6+, FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+. **Default:** `false`.
    *  - {Number} [debugPort] listening a debug port on http protocol
    *  - {Object} [https] https options, { key, cert, ca }, full path
    *  - {Array|String} [require] will inject into worker/agent process

lib/utils/mode/impl/worker_threads/app.js

@@ -155,17 +155,25 @@ class AppUtils extends BaseAppUtils {
     this.startTime = Date.now();
     this.startSuccessCount = 0;
 
-    const ports = this.options.ports;
-    if (!ports.length) {
-      ports.push(this.options.port);
+    if (this.options.reusePort) {
+      for (let i = 0; i < this.options.workers; i++) {
+        const argv = [ JSON.stringify(this.options) ];
+        const appWorkerId = i + 1;
+        this.#forkSingle(this.getAppWorkerFile(), { argv }, appWorkerId);
+      }
+    } else {
+      const ports = this.options.ports;
+      if (!ports.length) {
+        ports.push(this.options.port);
+      }
+      this.options.workers = ports.length;
+      let i = 0;
+      do {
+        const options = Object.assign({}, this.options, { port: ports[i] });
+        const argv = [ JSON.stringify(options) ];
+        this.#forkSingle(this.getAppWorkerFile(), { argv }, ++i);
+      } while (i < ports.length);
     }
-    this.options.workers = ports.length;
-    let i = 0;
-    do {
-      const options = Object.assign({}, this.options, { port: ports[i] });
-      const argv = [ JSON.stringify(options) ];
-      this.#forkSingle(this.getAppWorkerFile(), { argv }, ++i);
-    } while (i < ports.length);
 
     return this;
   }

lib/utils/options.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const cluster = require('cluster');
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
@@ -12,6 +13,7 @@
     framework: '',
     baseDir: process.cwd(),
     port: options.https ? 8443 : null,
+    reusePort: false,
     workers: null,
     plugins: null,
     https: false,
@@ -69,6 +71,17 @@
   const isDebug = process.execArgv.some(argv => argv.includes('--debug') || argv.includes('--inspect'));
   if (isDebug) options.isDebug = isDebug;
 
+  if (options.reusePort) {
+    if (os.platform() !== 'linux') {
+      // Currently only linux is supported
+      options.reusePort = false;
+      console.log('platform %s is not support currently, set reusePort to false', os.platform());
+    } else {
+      // https://nodejs.org/api/cluster.html#clusterschedulingpolicy
+      // set cluster.schedulingPolicy to cluster.SCHED_NONE, leave it to the operating system
+      // cluster.schedulingPolicy = cluster.SCHED_NONE;
+    }
+  }
   return options;
 };
 

package.json

@@ -1,22 +1,22 @@
 {
   "name": "egg-cluster",
-  "version": "2.4.0",
+  "version": "2.5.0-beta.3",
   "description": "cluster manager for egg",
   "main": "index.js",
   "scripts": {
     "lint": "eslint .",
     "test": "npm run lint -- --fix && npm run test-local",
     "test-local": "egg-bin test --ts false",
     "cov": "egg-bin cov --prerequire --timeout 100000 --ts false",
-    "ci": "npm run lint && npm run cov"
+    "ci": "npm run lint && node test/reuseport_cluster.js && npm run cov"
   },
   "files": [
     "index.js",
     "lib"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/eggjs/egg-cluster.git"
+    "url": "git+https://github.com/eggjs/cluster.git"
   },
   "keywords": [
     "egg",
@@ -26,9 +26,9 @@
   "author": "dead-horse <dead_horse@qq.com>",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/eggjs/egg-cluster/issues"
+    "url": "https://github.com/eggjs/cluster/issues"
   },
-  "homepage": "https://github.com/eggjs/egg-cluster#readme",
+  "homepage": "https://github.com/eggjs/cluster#readme",
   "dependencies": {
     "await-event": "^2.1.0",
     "cfork": "^1.7.1",

test/app_worker.test.js

@@ -232,6 +232,35 @@ describe('test/app_worker.test.js', () => {
         .expect(200);
     });
 
+    it('should set reusePort=true in config', async () => {
+      app = utils.cluster('apps/app-listen-reusePort');
+      // app.debug();
+      await app.ready();
+
+      app.expect('code', 0);
+      app.expect('stdout', /egg started on http:\/\/127.0.0.1:17010/);
+
+      await request('http://0.0.0.0:17010')
+        .get('/')
+        .expect('done')
+        .expect(200);
+
+      await request('http://127.0.0.1:17010')
+        .get('/')
+        .expect('done')
+        .expect(200);
+
+      await request('http://localhost:17010')
+        .get('/')
+        .expect('done')
+        .expect(200);
+
+      await request('http://127.0.0.1:17010')
+        .get('/port')
+        .expect('17010')
+        .expect(200);
+    });
+
     it('should use hostname in config', async () => {
       const url = address.ip() + ':17010';
 

test/fixtures/apps/app-listen-reusePort/app.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = app => {
+  // don't use the port that egg-mock defined
+  app._options.port = undefined;
+};

test/fixtures/apps/app-listen-reusePort/app/router.js

@@ -0,0 +1,9 @@
+module.exports = app => {
+  app.get('/', ctx => {
+    ctx.body = 'done';
+  });
+
+  app.get('/port', ctx => {
+    ctx.body = ctx.app._options.port;
+  });
+};

test/fixtures/apps/app-listen-reusePort/config/config.default.js

@@ -0,0 +1,9 @@
+module.exports = {
+  keys: '123',
+  cluster: {
+    listen: {
+      port: 17010,
+      reusePort: true,
+    },
+  },
+};

test/fixtures/apps/app-listen-reusePort/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "app-listen-reusePort"
+}

test/master.test.js

@@ -29,6 +29,17 @@ describe('test/master.test.js', () => {
         .end(done);
     });
 
+    it('start success with reusePort=true', done => {
+      mm.env('local');
+      app = utils.cluster('apps/master-worker-started', { reusePort: true });
+
+      app.expect('stdout', /egg start/)
+        .expect('stdout', /egg started/)
+        .notExpect('stdout', /\[master\] agent_worker#1:\d+ start with clusterPort:\d+/)
+        .expect('code', 0)
+        .end(done);
+    });
+
     it('start success in prod env', done => {
       mm.env('prod');
       app = utils.cluster('apps/mock-production-app').debug(false);

test/reuseport_cluster.js

@@ -0,0 +1,70 @@
+const cluster = require('node:cluster');
+const http = require('node:http');
+const numCPUs = require('node:os').availableParallelism();
+const process = require('node:process');
+
+function request(index) {
+  http.get('http://localhost:17001/', res => {
+    const { statusCode } = res;
+    console.log(index, res.statusCode, res.headers);
+    let error;
+    // Any 2xx status code signals a successful response but
+    // here we're only checking for 200.
+    if (statusCode !== 200) {
+      error = new Error('Request Failed.\n' +
+                        `Status Code: ${statusCode}`);
+    }
+    if (error) {
+      console.error(error.message);
+      // Consume response data to free up memory
+      res.resume();
+      return;
+    }
+    res.setEncoding('utf8');
+    let rawData = '';
+    res.on('data', chunk => { rawData += chunk; });
+    res.on('end', () => {
+      try {
+        console.log(rawData);
+      } catch (e) {
+        console.error(e.message);
+      }
+    });
+  }).on('error', e => {
+    console.error(`Got error: ${e.stack}`);
+  });
+}
+
+if (cluster.isPrimary) {
+  console.log(`Primary ${process.pid} is running`);
+
+  // Fork workers.
+  for (let i = 0; i < numCPUs; i++) {
+    cluster.fork();
+  }
+
+  cluster.on('exit', (worker, code, signal) => {
+    console.log(`worker ${worker.process.pid} died, code: ${code}, signal: ${signal}`);
+  });
+
+  setTimeout(() => {
+    for (let i = 0; i < 20; i++) {
+      request(i);
+    }
+  }, 2000);
+  setTimeout(() => {
+    process.exit(0);
+  }, 5000);
+} else {
+  // Workers can share any TCP connection
+  // In this case it is an HTTP server
+  http.createServer((req, res) => {
+    res.writeHead(200);
+    res.end('hello world\n');
+  }).listen({
+    port: 17001,
+    reusePort: true,
+  });
+
+  console.log(`Worker ${process.pid} started`);
+}