cluster: overriding inspector port

Added an option to override inspector port for workers using `settings.inspectPort` will override default port incrementing behavior. Also, using this option allows to set 0 port for the whole cluster. PR-URL: #14140Fixes: #8495Fixes: #12941 Refs: #9659 Refs: #13761 Reviewed-By: Refael Ackermann <[email protected]> Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Colin Ihrig <[email protected]>

Author: mutantcornholio

doc/api/cluster.md

@@ -746,6 +746,9 @@ changes:
 `'ipc'` entry. When this option is provided, it overrides `silent`.
 *`uid`{number} Sets the user identity of the process. (See setuid(2).)
 *`gid`{number} Sets the group identity of the process. (See setgid(2).)
+*`inspectPort`{number|function} Sets inspector port of worker.
+ Accepts number, or function that evaluates to number. By default
+ each worker gets port, incremented from master's `process.debugPort`.
 
 After calling `.setupMaster()` (or `.fork()`) this settings object will contain
 the settings, including the default values.

lib/internal/cluster/master.js

@@ -12,6 +12,7 @@ const cluster = new EventEmitter();
 constintercom=newEventEmitter();
 constSCHED_NONE=1;
 constSCHED_RR=2;
+const{isLegalPort}=require('internal/net');
 
 module.exports=cluster;
 
@@ -104,8 +105,23 @@ function createWorkerProcess(id, env){
 workerEnv.NODE_UNIQUE_ID=''+id;
 
 if(execArgv.some((arg)=>arg.match(debugArgRegex))){
-execArgv.push(`--inspect-port=${process.debugPort+debugPortOffset}`);
-debugPortOffset++;
+letinspectPort;
+if('inspectPort'incluster.settings){
+if(typeofcluster.settings.inspectPort==='function')
+inspectPort=cluster.settings.inspectPort();
+else
+inspectPort=cluster.settings.inspectPort;
+
+if(!isLegalPort(inspectPort)){
+thrownewTypeError('cluster.settings.inspectPort'+
+' is invalid');
+}
+}else{
+inspectPort=process.debugPort+debugPortOffset;
+debugPortOffset++;
+}
+
+execArgv.push(`--inspect-port=${inspectPort}`);
 }
 
 returnfork(cluster.settings.exec,cluster.settings.args,{

test/inspector/test-inspector-port-cluster.js

@@ -18,7 +18,7 @@ let offset = 0;
  */
 
 functiontestRunnerMain(){
-spawnMaster({
+letdefaultPortCase=spawnMaster({
 execArgv: ['--inspect'],
 workers: [{expectedPort: 9230}]
 });
@@ -77,42 +77,251 @@ function testRunnerMain(){
 workers: [{expectedPort: port+1,expectedHost: '::1'}]
 });
 }
-}
 
+// These tests check that setting inspectPort in cluster.settings
+// would take effect and override port incrementing behavior
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: port+2},
+workers: [{expectedPort: port+2}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'addTwo'},
+workers: [
+{expectedPort: port+2},
+{expectedPort: port+4}
+]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'string'},
+workers: [{}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'null'},
+workers: [{}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'bignumber'},
+workers: [{}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'negativenumber'},
+workers: [{}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'bignumberfunc'},
+workers: [{}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 'strfunc'},
+workers: [{}]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [],
+clusterSettings: {inspectPort: port,execArgv: ['--inspect']},
+workers: [
+{expectedPort: port}
+]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [`--inspect=${port}`],
+clusterSettings: {inspectPort: 0},
+workers: [
+{expectedInitialPort: 0},
+{expectedInitialPort: 0},
+{expectedInitialPort: 0}
+]
+});
+
+port=debuggerPort+offset++*5;
+
+spawnMaster({
+execArgv: [],
+clusterSettings: {inspectPort: 0},
+workers: [
+{expectedInitialPort: 0},
+{expectedInitialPort: 0},
+{expectedInitialPort: 0}
+]
+});
+
+defaultPortCase.then(()=>{
+port=debuggerPort+offset++*5;
+defaultPortCase=spawnMaster({
+execArgv: ['--inspect'],
+clusterSettings: {inspectPort: port+2},
+workers: [
+{expectedInitialPort: port+2}
+]
+});
+});
+}
 functionmasterProcessMain(){
 constworkers=JSON.parse(process.env.workers);
+constclusterSettings=JSON.parse(process.env.clusterSettings);
+letdebugPort=process.debugPort;
 
 for(constworkerofworkers){
-cluster.fork({
-expectedPort: worker.expectedPort,
-expectedHost: worker.expectedHost
-}).on('exit',common.mustCall(checkExitCode));
+constparams={};
+
+if(worker.expectedPort){
+params.expectedPort=worker.expectedPort;
+}
+
+if(worker.expectedInitialPort){
+params.expectedInitialPort=worker.expectedInitialPort;
+}
+
+if(worker.expectedHost){
+params.expectedHost=worker.expectedHost;
+}
+
+if(clusterSettings){
+if(clusterSettings.inspectPort==='addTwo'){
+clusterSettings.inspectPort=common.mustCall(
+()=>{returndebugPort+=2;},
+workers.length
+);
+}elseif(clusterSettings.inspectPort==='string'){
+clusterSettings.inspectPort='string';
+cluster.setupMaster(clusterSettings);
+
+assert.throws(()=>{
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
+},TypeError);
+
+return;
+}elseif(clusterSettings.inspectPort==='null'){
+clusterSettings.inspectPort=null;
+cluster.setupMaster(clusterSettings);
+
+assert.throws(()=>{
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
+},TypeError);
+
+return;
+}elseif(clusterSettings.inspectPort==='bignumber'){
+clusterSettings.inspectPort=1293812;
+cluster.setupMaster(clusterSettings);
+
+assert.throws(()=>{
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
+},TypeError);
+
+return;
+}elseif(clusterSettings.inspectPort==='negativenumber'){
+clusterSettings.inspectPort=-9776;
+cluster.setupMaster(clusterSettings);
+
+assert.throws(()=>{
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
+},TypeError);
+
+return;
+}elseif(clusterSettings.inspectPort==='bignumberfunc'){
+clusterSettings.inspectPort=common.mustCall(
+()=>123121,
+workers.length
+);
+
+cluster.setupMaster(clusterSettings);
+
+assert.throws(()=>{
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
+},TypeError);
+
+return;
+}elseif(clusterSettings.inspectPort==='strfunc'){
+clusterSettings.inspectPort=common.mustCall(
+()=>'invalidPort',
+workers.length
+);
+
+cluster.setupMaster(clusterSettings);
+
+assert.throws(()=>{
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
+},TypeError);
+
+return;
+}
+cluster.setupMaster(clusterSettings);
+}
+
+cluster.fork(params).on('exit',common.mustCall(checkExitCode));
 }
 }
 
 functionworkerProcessMain(){
-const{expectedPort, expectedHost}=process.env;
+const{expectedPort, expectedInitialPort, expectedHost}=process.env;
+constdebugOptions=process.binding('config').debugOptions;
+
+if('expectedPort'inprocess.env){
+assert.strictEqual(process.debugPort,+expectedPort);
+}
 
-assert.strictEqual(process.debugPort,+expectedPort);
+if('expectedInitialPort'inprocess.env){
+assert.strictEqual(debugOptions.port,+expectedInitialPort);
+}
 
-if(expectedHost!=='undefined'){
-assert.strictEqual(
-process.binding('config').debugOptions.host,
-expectedHost
-);
+if('expectedHost'inprocess.env){
+assert.strictEqual(debugOptions.host,expectedHost);
 }
 
 process.exit();
 }
 
-functionspawnMaster({execArgv, workers}){
-childProcess.fork(__filename,{
-env: {
-workers: JSON.stringify(workers),
-testProcess: true
-},
- execArgv
-}).on('exit',common.mustCall(checkExitCode));
+functionspawnMaster({execArgv, workers, clusterSettings ={}}){
+returnnewPromise((resolve)=>{
+childProcess.fork(__filename,{
+env: {
+workers: JSON.stringify(workers),
+clusterSettings: JSON.stringify(clusterSettings),
+testProcess: true
+},
+ execArgv
+}).on('exit',common.mustCall((code,signal)=>{
+checkExitCode(code,signal);
+resolve();
+}));
+});
 }
 
 functioncheckExitCode(code,signal){