Every line of 'nodejs fork' code snippets is scanned for vulnerabilities by our powerful machine learning engine that combs millions of open source libraries, ensuring your JavaScript code is secure.
13 function fork(CLUSTER_ROLE) { 14 cluster.fork({ CLUSTER_ROLE }) 15 .on('online', () => { 16 _.dev(() => console.warn(`worker ${CLUSTER_ROLE} is online.`)); 17 }) 18 .on('exit', (code, signal) => { 19 _.dev(() => console.warn(`Worker ${CLUSTER_ROLE} exited with code ${code} and signal ${signal}.`)); 20 fork(CLUSTER_ROLE); 21 }); 22 }
466 function fork(options, workerFunc, thenDo) { 467 // Fork automatically starts a worker and calls `workerFunc`. `workerFunc` 468 // gets as a last paramter a callback, that, when invoked with an error and 469 // result object, ends the worker execution. 470 // 471 // Options are the same as in `create` except for an `args` property that 472 // can be an array of objects. These objects will be passed to `workerFunc` 473 // as arguments. 474 // 475 // Note: `workerFunc` will not be able to capture outside variables (create a 476 // closure). 477 // 478 // Example: 479 // // When running this inside a browser: Note how the UI does not block. 480 // worker.fork({args: [40]}, 481 // function(n, thenDo) { 482 // function fib(n) { return n <= 1 ? n : fib(n-1) + fib(n-2); } 483 // thenDo(null, fib(n)); 484 // }, 485 // function(err, result) { show(err ? err.stack : result); }) 486 487 if (!thenDo) { thenDo = workerFunc; workerFunc = options; options = null; } 488 options = options || {}; 489 var args = options.args || []; 490 var w = create(options); 491 w.run.apply(w, [workerFunc].concat(args).concat(thenDo)); 492 return w; 493 }
97 fork(modulePath, args, options) { 98 let child; 99 let promise = new Promise((resolve, reject) => { 100 let stdout = ''; 101 let stderr = ''; 102 child = this.child_process 103 .fork(modulePath, args, options) 104 .on('close', (code, signal) => { 105 if (code !== 0) { 106 const error = new Error('Exited with code ' + code); 107 error.code = code; 108 error.stderr = stderr; 109 error.stdout = stdout; 110 error.signal = signal; 111 reject(error); 112 } else { 113 resolve({ 114 code: code, 115 signal: signal, 116 stderr: stderr, 117 stdout: stdout 118 }); 119 } 120 }) 121 .on('error', (error) => { 122 error.stdout = stdout; 123 error.stderr = stderr; 124 reject(error); 125 }); 126 127 if (child.stdout) { 128 child.stdout 129 .setEncoding('utf8') 130 .on('data', (data) => { 131 stdout += data; 132 }); 133 } 134 if (child.stderr) { 135 child.stderr 136 .setEncoding('utf8') 137 .on('data', (data) => { 138 stderr += data; 139 }); 140 } 141 }); 142 promise.child = child; 143 return promise; 144 }
34 function forkProcess() { 35 const nodeProcess = this.nodeProcess || process; 36 const cluster = this.cluster || clusterModule; 37 const onlineEventHandlerFunc = onlineEventHandler.bind(this); 38 const exitEventHandlerFunc = exitEventHandler.bind(this, cluster); 39 return new Promise((resolve, reject) => { 40 try { 41 if (this.settings.application.cluster_process) { 42 if (cluster.isMaster) { 43 this.config.process.isMaster = true; 44 const numWorkers = this.settings.application.number_of_clusters || os.cpus().length; 45 this.logger.info(`Master cluster setting up ${numWorkers} workers...`); 46 for (let i = 0; i < numWorkers; i++) { 47 const worker = cluster.fork(); 48 } 49 for (const id in cluster.workers) { 50 // Receive messages from this worker and handle them in the master process. 51 cluster.workers[ id ].on('message', workerProcessMessageHandler.bind(this)); 52 } 53 54 cluster.on('online', onlineEventHandlerFunc); 55 cluster.on('exit', exitEventHandlerFunc); 56 // this.config.process.isClustered = true; 57 reject(new Error('Leave Promise Chain: Forking Process')); 58 } else { 59 this.config.process.pid = nodeProcess.pid; 60 this.config.process.isClustered = true; 61 this.config.process.isMaster = false; 62 this.status.emit('cluster-process-waiting-on-master', true); 63 nodeProcess.send({ 64 cmd: 'requestMasterProcessId', 65 pid: process.pid, 66 }); 67 nodeProcess.on('message', (msg) => { 68 this.status.emit('cluster-process-master-message', msg); 69 this.status.emit('clustered-process-master-process-id', msg.masterProcessId); 70 this.config.process.masterProcessId = msg.masterProcessId; 71 // console.log(`WORKER (${process.pid}): Got message`, msg); 72 }); 73 74 resolve(true); 75 } 76 } else { 77 this.config.process.isClustered = false; 78 resolve(true); 79 } 80 } catch (e) { 81 reject(e); 82 } 83 }); 84 }
23 fork(workerModule: string) { 24 const filteredArgs = process.execArgv.filter( 25 v => !/^--(debug|inspect)/.test(v) 26 ); 27 28 const options: cp.ForkOptions = { 29 execArgv: filteredArgs, 30 env: process.env, 31 cwd: process.cwd() 32 }; 33 34 const args = ['--start-worker']; 35 36 this.childProcess = cp.fork(workerModule, args, options); 37 38 this.childProcess.on('message', this.receiveFromWorker.bind(this)); 39 40 this.childProcess.once('exit', code => { 41 this.exitCode = code; 42 this.emit('exit', code); 43 }); 44 45 this.childProcess.on('error', err => { 46 this.emit('error', err); 47 }); 48 }
14 function fork(offset, execArgv) { 15 if (execArgv) 16 cluster.setupMaster({execArgv}); 17 18 const check = common.mustCall(checkExitCode); 19 cluster.fork({portSet: debuggerPort + offset}).on('exit', check); 20 }
77 export function forkP( 78 moduleName: string, args?: string[], options?: ForkOptions, 79 log?: (text: string) => void): Promise { 80 const stringifiedCommand = 81 `\`${moduleName}${args ? (' ' + args.join(' ')) : ''}\``; 82 if (log) { 83 log(`> Running: ${stringifiedCommand}`); 84 } 85 return promisifyChildProcess( 86 fork(moduleName, args, Object.assign({stdio: 'inherit'}, options))); 87 }
104 function forkWorker() { 105 106 var worker = cluster.fork(); 107 108 worker.on('message', function (msg) { 109 110 if (msg.cmd) { 111 112 if (msg.cmd == 'workerStarted') { 113 114 runningWorkers++; 115 116 if (runningWorkers === parseInt(totalWorkers)) { 117 console.log("Calipso configured for: ".green + (global.process.env.NODE_ENV || 'development') + " environment.".green); 118 console.log("Calipso server running ".green + runningWorkers + " workers, listening on port: ".green + port); 119 } 120 121 } 122 123 } 124 125 }); 126 127 }
18 forkWorker() { 19 const worker = new Worker({ 20 modulePath: this.modulePath, 21 workerOptions: this.workerOptions, 22 }); 23 24 this.stdout.add(worker.child.stdout); 25 this.stderr.add(worker.child.stderr); 26 27 this.workers.push(worker); 28 29 return worker; 30 }
48 function forkWorker(i) { 49 var worker = cluster.fork({ 50 PARSER_URL: parsers[i] 51 }); 52 worker.on("exit", function() { 53 console.log("Worker crashed! Spawning a replacement of worker %s", worker.id); 54 forkWorker(i); 55 }); 56 }