{ "source": "doc/api/cluster.markdown", "modules": [ { "textRaw": "Cluster", "name": "cluster", "stability": 1, "stabilityText": "Experimental", "desc": "

A single instance of Node runs in a single thread. To take advantage of\nmulti-core systems the user will sometimes want to launch a cluster of Node\nprocesses to handle the load.\n\n

\n

The cluster module allows you to easily create a network of processes that\nall share server ports.\n\n

\n
var cluster = require('cluster');\nvar http = require('http');\nvar numCPUs = require('os').cpus().length;\n\nif (cluster.isMaster) {\n  // Fork workers.\n  for (var i = 0; i < numCPUs; i++) {\n    cluster.fork();\n  }\n\n  cluster.on('death', function(worker) {\n    console.log('worker ' + worker.pid + ' died');\n  });\n} else {\n  // Workers can share any TCP connection\n  // In this case its a HTTP server\n  http.createServer(function(req, res) {\n    res.writeHead(200);\n    res.end("hello world\\n");\n  }).listen(8000);\n}
\n

Running node will now share port 8000 between the workers:\n\n

\n
% node server.js\nWorker 2438 online\nWorker 2437 online
\n

This feature was introduced recently, and may change in future versions.\nPlease try it out and provide feedback.\n\n

\n", "properties": [ { "textRaw": "`settings` {Object} ", "name": "settings", "options": [ { "textRaw": "`exec` {String} file path to worker file. (Default=`__filename`) ", "name": "exec", "default": "__filename", "type": "String", "desc": "file path to worker file." }, { "textRaw": "`args` {Array} string arguments passed to worker. (Default=`process.argv.slice(2)`) ", "name": "args", "default": "process.argv.slice(2)", "type": "Array", "desc": "string arguments passed to worker." }, { "textRaw": "`silent` {Boolean} whether or not to send output to parent's stdio. (Default=`false`) ", "name": "silent", "default": "false", "type": "Boolean", "desc": "whether or not to send output to parent's stdio." } ], "desc": "

All settings set by the .setupMaster is stored in this settings object.\nThis object is not supposed to be change or set manually, by you.\n\n

\n" }, { "textRaw": "`isMaster` {Boolean} ", "name": "isMaster", "desc": "

True if the process is a master. This is determined\nby the process.env.NODE_UNIQUE_ID. If process.env.NODE_UNIQUE_ID is\nundefined, then isMaster is true.\n\n

\n" }, { "textRaw": "`isWorker` {Boolean} ", "name": "isWorker", "desc": "

This boolean flag is true if the process is a worker forked from a master.\nIf the process.env.NODE_UNIQUE_ID is set to a value, then\nisWorker is true.\n\n

\n" }, { "textRaw": "`settings` {Object} ", "name": "settings", "options": [ { "textRaw": "`exec` {String} file path to worker file. Default: `__filename` ", "name": "exec", "type": "String", "desc": "file path to worker file. Default: `__filename`" }, { "textRaw": "`args` {Array} string arguments passed to worker. (Default=`process.argv.slice(2)`) ", "name": "args", "default": "process.argv.slice(2)", "type": "Array", "desc": "string arguments passed to worker." }, { "textRaw": "`silent` {Boolean} whether or not to send output to parent's stdio. (Default=`false`) ", "name": "silent", "default": "false", "type": "Boolean", "desc": "whether or not to send output to parent's stdio." } ], "desc": "

All settings set by the .setupMaster is stored in this settings object.\nThis object is not supposed to be change or set manually.\n\n

\n" }, { "textRaw": "`workers` {Object} ", "name": "workers", "desc": "

In the cluster all living worker objects are stored in this object by there\nuniqueID as the key. This makes it easy to loop through all living workers.\n\n

\n
// Go through all workers\nfunction eachWorker(callback) {\n  for (var uniqueID in cluster.workers) {\n    callback(cluster.workers[uniqueID]);\n  }\n}\neachWorker(function (worker) {\n  worker.send('big announcement to all workers');\n});
\n

Should you wish to reference a worker over a communication channel, using\nthe worker's uniqueID is the easiest way to find the worker.\n\n

\n
socket.on('data', function (uniqueID) {\n  var worker = cluster.workers[uniqueID];\n});
\n" } ], "events": [ { "textRaw": "Event: 'fork'", "type": "event", "name": "fork", "params": [], "desc": "

When a new worker is forked the cluster module will emit a 'fork' event.\nThis can be used to log worker activity, and create you own timeout.\n\n

\n
var timeouts = [];\nvar errorMsg = function () {\n  console.error("Something must be wrong with the connection ...");\n});\n\ncluster.on('fork', function (worker) {\n  timeouts[worker.uniqueID] = setTimeout(errorMsg, 2000);\n});\ncluster.on('listening', function (worker) {\n  clearTimeout(timeouts[worker.uniqueID]);\n});\ncluster.on('death', function (worker) {\n  clearTimeout(timeouts[worker.uniqueID]);\n  errorMsg();\n});
\n" }, { "textRaw": "Event: 'online'", "type": "event", "name": "online", "params": [], "desc": "

After forking a new worker, the worker should respond with a online message.\nWhen the master receives a online message it will emit such event.\nThe difference between 'fork' and 'online' is that fork is emitted when the\nmaster tries to fork a worker, and 'online' is emitted when the worker is\nbeing executed.\n\n

\n
cluster.on('online', function (worker) {\n  console.log("Yay, the worker responded after it was forked");\n});
\n" }, { "textRaw": "Event: 'listening'", "type": "event", "name": "listening", "params": [], "desc": "

When calling listen() from a worker, a 'listening' event is automatically assigned\nto the server instance. When the server is listening a message is send to the master\nwhere the 'listening' event is emitted.\n\n

\n
cluster.on('listening', function (worker) {\n  console.log("We are now connected");\n});
\n" }, { "textRaw": "Event: 'death'", "type": "event", "name": "death", "params": [], "desc": "

When any of the workers die the cluster module will emit the 'death' event.\nThis can be used to restart the worker by calling fork() again.\n\n

\n
cluster.on('death', function(worker) {\n  console.log('worker ' + worker.pid + ' died. restart...');\n  cluster.fork();\n});
\n" }, { "textRaw": "Event: 'setup'", "type": "event", "name": "setup", "params": [], "desc": "

When the .setupMaster() function has been executed this event emits.\nIf .setupMaster() was not executed before fork() this function will\ncall .setupMaster() with no arguments.\n\n

\n" }, { "textRaw": "Event: 'death'", "type": "event", "name": "death", "params": [], "desc": "

Same as the cluster.on('death') event, but emits only when the state change\non the specified worker.\n\n

\n
cluster.fork().on('death', function (worker) {\n  // Worker has died\n};
\n" } ], "methods": [ { "textRaw": "cluster.setupMaster([settings])", "type": "method", "name": "setupMaster", "signatures": [ { "params": [ { "textRaw": "`settings` {Object} ", "options": [ { "textRaw": "`exec` {String} file path to worker file. (Default=`__filename`) ", "name": "exec", "default": "__filename", "type": "String", "desc": "file path to worker file." }, { "textRaw": "`args` {Array} string arguments passed to worker. (Default=`process.argv.slice(2)`) ", "name": "args", "default": "process.argv.slice(2)", "type": "Array", "desc": "string arguments passed to worker." }, { "textRaw": "`silent` {Boolean} whether or not to send output to parent's stdio. (Default=`false`) ", "name": "silent", "default": "false", "type": "Boolean", "desc": "whether or not to send output to parent's stdio." } ], "name": "settings", "type": "Object", "optional": true } ] }, { "params": [ { "name": "settings", "optional": true } ] } ], "desc": "

The setupMaster is used to change the default 'fork' behavior. It takes\none option object argument.\n\n

\n

Example:\n\n

\n
var cluster = require("cluster");\ncluster.setupMaster({\n  exec : "worker.js",\n  args : ["--use", "https"],\n  silent : true\n});\ncluster.autoFork();
\n" }, { "textRaw": "cluster.fork([env])", "type": "method", "name": "fork", "signatures": [ { "return": { "textRaw": "return {Worker object} ", "name": "return", "type": "Worker object" }, "params": [ { "textRaw": "`env` {Object} Key/value pairs to add to child process environment. ", "name": "env", "type": "Object", "desc": "Key/value pairs to add to child process environment.", "optional": true } ] }, { "params": [ { "name": "env", "optional": true } ] } ], "desc": "

Spawn a new worker process. This can only be called from the master process.\n\n

\n" } ], "classes": [ { "textRaw": "Class: Worker", "type": "class", "name": "Worker", "desc": "

A Worker object contains all public information and method about a worker.\nIn the master it can be obtained using cluster.workers. In a worker\nit can be obtained using cluster.worker.\n\n

\n", "properties": [ { "textRaw": "`uniqueID` {String} ", "name": "uniqueID", "desc": "

Each new worker is given its own unique id, this id is stored in the\nuniqueID.\n\n

\n

While a worker is alive, this is the key that indexes it in\ncluster.workers\n\n

\n" }, { "textRaw": "`process` {ChildProcess object} ", "name": "process", "desc": "

All workers are created using child_process.fork(), the returned object\nfrom this function is stored in process.\n\n

\n

See: Child Process module\n\n

\n" }, { "textRaw": "`suicide` {Boolean} ", "name": "suicide", "desc": "

This property is a boolean. It is set when a worker dies, until then it is\nundefined. It is true if the worker was killed using the .destroy()\nmethod, and false otherwise.\n\n

\n" } ], "methods": [ { "textRaw": "worker.send(message, [sendHandle])", "type": "method", "name": "send", "signatures": [ { "params": [ { "textRaw": "`message` {Object} ", "name": "message", "type": "Object" }, { "textRaw": "`sendHandle` {Handle object} ", "name": "sendHandle", "type": "Handle object", "optional": true } ] }, { "params": [ { "name": "message" }, { "name": "sendHandle", "optional": true } ] } ], "desc": "

This function is equal to the send methods provided by\nchild_process.fork(). In the master you should use this function to\nsend a message to a specific worker. However in a worker you can also use\nprocess.send(message), since this is the same function.\n\n

\n

This example will echo back all messages from the master:\n\n

\n
if (cluster.isMaster) {\n  var worker = cluster.fork();\n  worker.send('hi there');\n\n} else if (cluster.isWorker) {\n  process.on('message', function (msg) {\n    process.send(msg);\n  });\n}
\n" }, { "textRaw": "worker.destroy()", "type": "method", "name": "destroy", "desc": "

This function will kill the worker, and inform the master to not spawn a\nnew worker. To know the difference between suicide and accidentally death\na suicide boolean is set to true.\n\n

\n
cluster.on('death', function (worker) {\n  if (worker.suicide === true) {\n    console.log('Oh, it was just suicide\\' – no need to worry').\n  }\n});\n\n// destroy worker\nworker.destroy();
\n", "signatures": [ { "params": [] } ] } ], "events": [ { "textRaw": "Event: 'message'", "type": "event", "name": "message", "params": [], "desc": "

This event is the same as the one provided by child_process.fork().\nIn the master you should use this event, however in a worker you can also use\nprocess.on('message')\n\n

\n

As an example, here is a cluster that keeps count of the number of requests\nin the master process using the message system:\n\n

\n
var cluster = require('cluster');\nvar http = require('http');\n\nif (cluster.isMaster) {\n\n  // Keep track of http requests\n  var numReqs = 0;\n  setInterval(function() {\n    console.log("numReqs =", numReqs);\n  }, 1000);\n\n  // Count requestes\n  var messageHandler = function (msg) {\n    if (msg.cmd && msg.cmd == 'notifyRequest') {\n      numReqs += 1;\n    }\n  };\n\n  // Start workers and listen for messages containing notifyRequest\n  cluster.autoFork();\n  Object.keys(cluster.workers).forEach(function (uniqueID) {\n    cluster.workers[uniqueID].on('message', messageHandler);\n  });\n\n} else {\n\n  // Worker processes have a http server.\n  http.Server(function(req, res) {\n    res.writeHead(200);\n    res.end("hello world\\n");\n\n    // notify master about the request\n    process.send({ cmd: 'notifyRequest' });\n  }).listen(8000);\n}
\n" }, { "textRaw": "Event: 'online'", "type": "event", "name": "online", "params": [], "desc": "

Same as the cluster.on('online') event, but emits only when the state change\non the specified worker.\n\n

\n
cluster.fork().on('online', function (worker) {\n  // Worker is online\n};
\n" }, { "textRaw": "Event: 'listening'", "type": "event", "name": "listening", "params": [], "desc": "

Same as the cluster.on('listening') event, but emits only when the state change\non the specified worker.\n\n

\n
cluster.fork().on('listening', function (worker) {\n  // Worker is listening\n};
\n" } ] } ], "type": "module", "displayName": "Cluster" } ] }