Worker - node__cluster.d.ts - Node

class Worker

extends EventEmitter

Usage in Deno

```typescript import { Worker } from "node:node__cluster.d.ts"; ```

> [!WARNING] Deno compatibility > This symbol is a non-functional stub. A `Worker` object contains all public information and method about a worker. In the primary it can be obtained using `cluster.workers`. In a worker it can be obtained using `cluster.worker`.

Properties



exitedAfterDisconnect: boolean

This property is `true` if the worker exited due to `.disconnect()`. If the worker exited any other way, it is `false`. If the worker has not exited, it is `undefined`. The boolean `worker.exitedAfterDisconnect` allows distinguishing between voluntary and accidental exit, the primary may choose not to respawn a worker based on this value. ```js cluster.on('exit', (worker, code, signal) => { if (worker.exitedAfterDisconnect === true) { console.log('Oh, it was just voluntary – no need to worry'); } }); // kill worker worker.kill(); ```



id: number

Each new worker is given its own unique id, this id is stored in the `id`. While a worker is alive, this is the key that indexes it in `cluster.workers`.



process: child.ChildProcess

All workers are created using [`child_process.fork()`](https://nodejs.org/docs/latest-v22.x/api/child_process.html#child_processforkmodulepath-args-options), the returned object from this function is stored as `.process`. In a worker, the global `process` is stored. See: [Child Process module](https://nodejs.org/docs/latest-v22.x/api/child_process.html#child_processforkmodulepath-args-options). Workers will call `process.exit(0)` if the `'disconnect'` event occurs on `process` and `.exitedAfterDisconnect` is not `true`. This protects against accidental disconnection.

Methods



addListener(event: string,
listener: (...args: any[]) => void,
): this

events.EventEmitter 1. disconnect 2. error 3. exit 4. listening 5. message 6. online



addListener(event: "disconnect",
listener: () => void,
): this



addListener(event: "error",
listener: (error: Error) => void,
): this



addListener(event: "exit",
listener: (code: number,
signal: string,
) => void,
): this



addListener(event: "listening",
listener: (address: Address) => void,
): this



addListener(event: "message",
listener: (message: any,
handle: net.Socket | net.Server,
) => void,
): this



addListener(event: "online",
listener: () => void,
): this



destroy(signal?: string): void



disconnect(): void

In a worker, this function will close all servers, wait for the `'close'` event on those servers, and then disconnect the IPC channel. In the primary, an internal message is sent to the worker causing it to call `.disconnect()` on itself. Causes `.exitedAfterDisconnect` to be set. After a server is closed, it will no longer accept new connections, but connections may be accepted by any other listening worker. Existing connections will be allowed to close as usual. When no more connections exist, see `server.close()`, the IPC channel to the worker will close allowing it to die gracefully. The above applies _only_ to server connections, client connections are not automatically closed by workers, and disconnect does not wait for them to close before exiting. In a worker, `process.disconnect` exists, but it is not this function; it is `disconnect()`. Because long living server connections may block workers from disconnecting, it may be useful to send a message, so application specific actions may be taken to close them. It also may be useful to implement a timeout, killing a worker if the `'disconnect'` event has not been emitted after some time. ```js import net from 'node:net'; if (cluster.isPrimary) { const worker = cluster.fork(); let timeout; worker.on('listening', (address) => { worker.send('shutdown'); worker.disconnect(); timeout = setTimeout(() => { worker.kill(); }, 2000); }); worker.on('disconnect', () => { clearTimeout(timeout); }); } else if (cluster.isWorker) { const server = net.createServer((socket) => { // Connections never end }); server.listen(8000); process.on('message', (msg) => { if (msg === 'shutdown') { // Initiate graceful close of any connections to server } }); } ```



emit(event: string | symbol,
...args: any[],
): boolean



emit(event: "disconnect"): boolean



emit(event: "error",
error: Error,
): boolean



emit(event: "exit",
code: number,
signal: string,
): boolean



emit(event: "listening",
address: Address,
): boolean



emit(event: "message",
message: any,
handle: net.Socket | net.Server,
): boolean



emit(event: "online"): boolean



isConnected(): boolean

This function returns `true` if the worker is connected to its primary via its IPC channel, `false` otherwise. A worker is connected to its primary after it has been created. It is disconnected after the `'disconnect'` event is emitted.



isDead(): boolean

This function returns `true` if the worker's process has terminated (either because of exiting or being signaled). Otherwise, it returns `false`. ```js import cluster from 'node:cluster'; import http from 'node:http'; import { availableParallelism } from 'node:os'; import process from 'node:process'; const numCPUs = availableParallelism(); if (cluster.isPrimary) { console.log(`Primary ${process.pid} is running`); // Fork workers. for (let i = 0; i < numCPUs; i++) { cluster.fork(); } cluster.on('fork', (worker) => { console.log('worker is dead:', worker.isDead()); }); cluster.on('exit', (worker, code, signal) => { console.log('worker is dead:', worker.isDead()); }); } else { // Workers can share any TCP connection. In this case, it is an HTTP server. http.createServer((req, res) => { res.writeHead(200); res.end(`Current process\n ${process.pid}`); process.kill(process.pid); }).listen(8000); } ```



kill(signal?: string): void

This function will kill the worker. In the primary worker, it does this by disconnecting the `worker.process`, and once disconnected, killing with `signal`. In the worker, it does it by killing the process with `signal`. The `kill()` function kills the worker process without waiting for a graceful disconnect, it has the same behavior as `worker.process.kill()`. This method is aliased as `worker.destroy()` for backwards compatibility. In a worker, `process.kill()` exists, but it is not this function; it is [`kill()`](https://nodejs.org/docs/latest-v22.x/api/process.html#processkillpid-signal).



on(event: string,
listener: (...args: any[]) => void,
): this



on(event: "disconnect",
listener: () => void,
): this



on(event: "error",
listener: (error: Error) => void,
): this



on(event: "exit",
listener: (code: number,
signal: string,
) => void,
): this



on(event: "listening",
listener: (address: Address) => void,
): this



on(event: "message",
listener: (message: any,
handle: net.Socket | net.Server,
) => void,
): this



on(event: "online",
listener: () => void,
): this



once(event: string,
listener: (...args: any[]) => void,
): this



once(event: "disconnect",
listener: () => void,
): this



once(event: "error",
listener: (error: Error) => void,
): this



once(event: "exit",
listener: (code: number,
signal: string,
) => void,
): this



once(event: "listening",
listener: (address: Address) => void,
): this



once(event: "message",
listener: (message: any,
handle: net.Socket | net.Server,
) => void,
): this



once(event: "online",
listener: () => void,
): this



prependListener(event: string,
listener: (...args: any[]) => void,
): this



prependListener(event: "disconnect",
listener: () => void,
): this



prependListener(event: "error",
listener: (error: Error) => void,
): this



prependListener(event: "exit",
listener: (code: number,
signal: string,
) => void,
): this



prependListener(event: "listening",
listener: (address: Address) => void,
): this



prependListener(event: "message",
listener: (message: any,
handle: net.Socket | net.Server,
) => void,
): this



prependListener(event: "online",
listener: () => void,
): this



prependOnceListener(event: string,
listener: (...args: any[]) => void,
): this



prependOnceListener(event: "disconnect",
listener: () => void,
): this



prependOnceListener(event: "error",
listener: (error: Error) => void,
): this



prependOnceListener(event: "exit",
listener: (code: number,
signal: string,
) => void,
): this



prependOnceListener(event: "listening",
listener: (address: Address) => void,
): this



prependOnceListener(event: "message",
listener: (message: any,
handle: net.Socket | net.Server,
) => void,
): this



prependOnceListener(event: "online",
listener: () => void,
): this



send(message: child.Serializable,
callback?: (error: Error | null) => void,
): boolean

Send a message to a worker or primary, optionally with a handle. In the primary, this sends a message to a specific worker. It is identical to [`ChildProcess.send()`](https://nodejs.org/docs/latest-v22.x/api/child_process.html#subprocesssendmessage-sendhandle-options-callback). In a worker, this sends a message to the primary. It is identical to `process.send()`. This example will echo back all messages from the primary: ```js if (cluster.isPrimary) { const worker = cluster.fork(); worker.send('hi there'); } else if (cluster.isWorker) { process.on('message', (msg) => { process.send(msg); }); } ```



send(message: child.Serializable,
sendHandle: child.SendHandle,
callback?: (error: Error | null) => void,
): boolean



send(message: child.Serializable,
sendHandle: child.SendHandle,
options?: child.MessageOptions,
callback?: (error: Error | null) => void,
): boolean