Pinsave/counterstrike

1/**2 * Clusters of Node.js processes can be used to run multiple instances of Node.js3 * that can distribute workloads among their application threads. When process isolation4 * is not needed, use the [`worker_threads`](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html)5 * module instead, which allows running multiple application threads within a single Node.js instance.6 *7 * The cluster module allows easy creation of child processes that all share8 * server ports.9 *10 * ```js11 * import cluster from 'node:cluster';12 * import http from 'node:http';13 * import { availableParallelism } from 'node:os';14 * import process from 'node:process';15 *16 * const numCPUs = availableParallelism();17 *18 * if (cluster.isPrimary) {19 *   console.log(`Primary ${process.pid} is running`);20 *21 *   // Fork workers.22 *   for (let i = 0; i < numCPUs; i++) {23 *     cluster.fork();24 *   }25 *26 *   cluster.on('exit', (worker, code, signal) => {27 *     console.log(`worker ${worker.process.pid} died`);28 *   });29 * } else {30 *   // Workers can share any TCP connection31 *   // In this case it is an HTTP server32 *   http.createServer((req, res) => {33 *     res.writeHead(200);34 *     res.end('hello world\n');35 *   }).listen(8000);36 *37 *   console.log(`Worker ${process.pid} started`);38 * }39 * ```40 *41 * Running Node.js will now share port 8000 between the workers:42 *43 * ```console44 * $ node server.js45 * Primary 3596 is running46 * Worker 4324 started47 * Worker 4520 started48 * Worker 6056 started49 * Worker 5644 started50 * ```51 *52 * On Windows, it is not yet possible to set up a named pipe server in a worker.53 * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/cluster.js)54 */55declare module "cluster" {56    import * as child from "node:child_process";57    import EventEmitter = require("node:events");58    import * as net from "node:net";59    type SerializationType = "json" | "advanced";60    export interface ClusterSettings {61        /**62         * List of string arguments passed to the Node.js executable.63         * @default process.execArgv64         */65        execArgv?: string[] | undefined;66        /**67         * File path to worker file.68         * @default process.argv[1]69         */70        exec?: string | undefined;71        /**72         * String arguments passed to worker.73         * @default process.argv.slice(2)74         */75        args?: string[] | undefined;76        /**77         * Whether or not to send output to parent's stdio.78         * @default false79         */80        silent?: boolean | undefined;81        /**82         * Configures the stdio of forked processes. Because the cluster module relies on IPC to function, this configuration must83         * contain an `'ipc'` entry. When this option is provided, it overrides `silent`. See [`child_prcess.spawn()`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#child_processspawncommand-args-options)'s84         * [`stdio`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#optionsstdio).85         */86        stdio?: any[] | undefined;87        /**88         * Sets the user identity of the process. (See [`setuid(2)`](https://man7.org/linux/man-pages/man2/setuid.2.html).)89         */90        uid?: number | undefined;91        /**92         * Sets the group identity of the process. (See [`setgid(2)`](https://man7.org/linux/man-pages/man2/setgid.2.html).)93         */94        gid?: number | undefined;95        /**96         * Sets inspector port of worker. This can be a number, or a function that takes no arguments and returns a number.97         * By default each worker gets its own port, incremented from the primary's `process.debugPort`.98         */99        inspectPort?: number | (() => number) | undefined;100        /**101         * Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`.102         * See [Advanced serialization for `child_process`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#advanced-serialization) for more details.103         * @default false104         */105        serialization?: SerializationType | undefined;106        /**107         * Current working directory of the worker process.108         * @default undefined (inherits from parent process)109         */110        cwd?: string | undefined;111        /**112         * Hide the forked processes console window that would normally be created on Windows systems.113         * @default false114         */115        windowsHide?: boolean | undefined;116    }117    export interface Address {118        address: string;119        port: number;120        /**121         * The `addressType` is one of:122         *123         * * `4` (TCPv4)124         * * `6` (TCPv6)125         * * `-1` (Unix domain socket)126         * * `'udp4'` or `'udp6'` (UDPv4 or UDPv6)127         */128        addressType: 4 | 6 | -1 | "udp4" | "udp6";129    }130    /**131     * A `Worker` object contains all public information and method about a worker.132     * In the primary it can be obtained using `cluster.workers`. In a worker133     * it can be obtained using `cluster.worker`.134     * @since v0.7.0135     */136    export class Worker extends EventEmitter {137        /**138         * Each new worker is given its own unique id, this id is stored in the `id`.139         *140         * While a worker is alive, this is the key that indexes it in `cluster.workers`.141         * @since v0.8.0142         */143        id: number;144        /**145         * All workers are created using [`child_process.fork()`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#child_processforkmodulepath-args-options), the returned object146         * from this function is stored as `.process`. In a worker, the global `process` is stored.147         *148         * See: [Child Process module](https://nodejs.org/docs/latest-v24.x/api/child_process.html#child_processforkmodulepath-args-options).149         *150         * Workers will call `process.exit(0)` if the `'disconnect'` event occurs151         * on `process` and `.exitedAfterDisconnect` is not `true`. This protects against152         * accidental disconnection.153         * @since v0.7.0154         */155        process: child.ChildProcess;156        /**157         * Send a message to a worker or primary, optionally with a handle.158         *159         * In the primary, this sends a message to a specific worker. It is identical to [`ChildProcess.send()`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#subprocesssendmessage-sendhandle-options-callback).160         *161         * In a worker, this sends a message to the primary. It is identical to `process.send()`.162         *163         * This example will echo back all messages from the primary:164         *165         * ```js166         * if (cluster.isPrimary) {167         *   const worker = cluster.fork();168         *   worker.send('hi there');169         *170         * } else if (cluster.isWorker) {171         *   process.on('message', (msg) => {172         *     process.send(msg);173         *   });174         * }175         * ```176         * @since v0.7.0177         * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles.178         */179        send(message: child.Serializable, callback?: (error: Error | null) => void): boolean;180        send(181            message: child.Serializable,182            sendHandle: child.SendHandle,183            callback?: (error: Error | null) => void,184        ): boolean;185        send(186            message: child.Serializable,187            sendHandle: child.SendHandle,188            options?: child.MessageOptions,189            callback?: (error: Error | null) => void,190        ): boolean;191        /**192         * This function will kill the worker. In the primary worker, it does this by193         * disconnecting the `worker.process`, and once disconnected, killing with `signal`. In the worker, it does it by killing the process with `signal`.194         *195         * The `kill()` function kills the worker process without waiting for a graceful196         * disconnect, it has the same behavior as `worker.process.kill()`.197         *198         * This method is aliased as `worker.destroy()` for backwards compatibility.199         *200         * In a worker, `process.kill()` exists, but it is not this function;201         * it is [`kill()`](https://nodejs.org/docs/latest-v24.x/api/process.html#processkillpid-signal).202         * @since v0.9.12203         * @param [signal='SIGTERM'] Name of the kill signal to send to the worker process.204         */205        kill(signal?: string): void;206        destroy(signal?: string): void;207        /**208         * In a worker, this function will close all servers, wait for the `'close'` event209         * on those servers, and then disconnect the IPC channel.210         *211         * In the primary, an internal message is sent to the worker causing it to call `.disconnect()` on itself.212         *213         * Causes `.exitedAfterDisconnect` to be set.214         *215         * After a server is closed, it will no longer accept new connections,216         * but connections may be accepted by any other listening worker. Existing217         * connections will be allowed to close as usual. When no more connections exist,218         * see `server.close()`, the IPC channel to the worker will close allowing it219         * to die gracefully.220         *221         * The above applies _only_ to server connections, client connections are not222         * automatically closed by workers, and disconnect does not wait for them to close223         * before exiting.224         *225         * In a worker, `process.disconnect` exists, but it is not this function;226         * it is `disconnect()`.227         *228         * Because long living server connections may block workers from disconnecting, it229         * may be useful to send a message, so application specific actions may be taken to230         * close them. It also may be useful to implement a timeout, killing a worker if231         * the `'disconnect'` event has not been emitted after some time.232         *233         * ```js234         * import net from 'node:net';235         *236         * if (cluster.isPrimary) {237         *   const worker = cluster.fork();238         *   let timeout;239         *240         *   worker.on('listening', (address) => {241         *     worker.send('shutdown');242         *     worker.disconnect();243         *     timeout = setTimeout(() => {244         *       worker.kill();245         *     }, 2000);246         *   });247         *248         *   worker.on('disconnect', () => {249         *     clearTimeout(timeout);250         *   });251         *252         * } else if (cluster.isWorker) {253         *   const server = net.createServer((socket) => {254         *     // Connections never end255         *   });256         *257         *   server.listen(8000);258         *259         *   process.on('message', (msg) => {260         *     if (msg === 'shutdown') {261         *       // Initiate graceful close of any connections to server262         *     }263         *   });264         * }265         * ```266         * @since v0.7.7267         * @return A reference to `worker`.268         */269        disconnect(): this;270        /**271         * This function returns `true` if the worker is connected to its primary via its272         * IPC channel, `false` otherwise. A worker is connected to its primary after it273         * has been created. It is disconnected after the `'disconnect'` event is emitted.274         * @since v0.11.14275         */276        isConnected(): boolean;277        /**278         * This function returns `true` if the worker's process has terminated (either279         * because of exiting or being signaled). Otherwise, it returns `false`.280         *281         * ```js282         * import cluster from 'node:cluster';283         * import http from 'node:http';284         * import { availableParallelism } from 'node:os';285         * import process from 'node:process';286         *287         * const numCPUs = availableParallelism();288         *289         * if (cluster.isPrimary) {290         *   console.log(`Primary ${process.pid} is running`);291         *292         *   // Fork workers.293         *   for (let i = 0; i < numCPUs; i++) {294         *     cluster.fork();295         *   }296         *297         *   cluster.on('fork', (worker) => {298         *     console.log('worker is dead:', worker.isDead());299         *   });300         *301         *   cluster.on('exit', (worker, code, signal) => {302         *     console.log('worker is dead:', worker.isDead());303         *   });304         * } else {305         *   // Workers can share any TCP connection. In this case, it is an HTTP server.306         *   http.createServer((req, res) => {307         *     res.writeHead(200);308         *     res.end(`Current process\n ${process.pid}`);309         *     process.kill(process.pid);310         *   }).listen(8000);311         * }312         * ```313         * @since v0.11.14314         */315        isDead(): boolean;316        /**317         * This property is `true` if the worker exited due to `.disconnect()`.318         * If the worker exited any other way, it is `false`. If the319         * worker has not exited, it is `undefined`.320         *321         * The boolean `worker.exitedAfterDisconnect` allows distinguishing between322         * voluntary and accidental exit, the primary may choose not to respawn a worker323         * based on this value.324         *325         * ```js326         * cluster.on('exit', (worker, code, signal) => {327         *   if (worker.exitedAfterDisconnect === true) {328         *     console.log('Oh, it was just voluntary – no need to worry');329         *   }330         * });331         *332         * // kill worker333         * worker.kill();334         * ```335         * @since v6.0.0336         */337        exitedAfterDisconnect: boolean;338        /**339         * events.EventEmitter340         *   1. disconnect341         *   2. error342         *   3. exit343         *   4. listening344         *   5. message345         *   6. online346         */347        addListener(event: string, listener: (...args: any[]) => void): this;348        addListener(event: "disconnect", listener: () => void): this;349        addListener(event: "error", listener: (error: Error) => void): this;350        addListener(event: "exit", listener: (code: number, signal: string) => void): this;351        addListener(event: "listening", listener: (address: Address) => void): this;352        addListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.353        addListener(event: "online", listener: () => void): this;354        emit(event: string | symbol, ...args: any[]): boolean;355        emit(event: "disconnect"): boolean;356        emit(event: "error", error: Error): boolean;357        emit(event: "exit", code: number, signal: string): boolean;358        emit(event: "listening", address: Address): boolean;359        emit(event: "message", message: any, handle: net.Socket | net.Server): boolean;360        emit(event: "online"): boolean;361        on(event: string, listener: (...args: any[]) => void): this;362        on(event: "disconnect", listener: () => void): this;363        on(event: "error", listener: (error: Error) => void): this;364        on(event: "exit", listener: (code: number, signal: string) => void): this;365        on(event: "listening", listener: (address: Address) => void): this;366        on(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.367        on(event: "online", listener: () => void): this;368        once(event: string, listener: (...args: any[]) => void): this;369        once(event: "disconnect", listener: () => void): this;370        once(event: "error", listener: (error: Error) => void): this;371        once(event: "exit", listener: (code: number, signal: string) => void): this;372        once(event: "listening", listener: (address: Address) => void): this;373        once(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.374        once(event: "online", listener: () => void): this;375        prependListener(event: string, listener: (...args: any[]) => void): this;376        prependListener(event: "disconnect", listener: () => void): this;377        prependListener(event: "error", listener: (error: Error) => void): this;378        prependListener(event: "exit", listener: (code: number, signal: string) => void): this;379        prependListener(event: "listening", listener: (address: Address) => void): this;380        prependListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.381        prependListener(event: "online", listener: () => void): this;382        prependOnceListener(event: string, listener: (...args: any[]) => void): this;383        prependOnceListener(event: "disconnect", listener: () => void): this;384        prependOnceListener(event: "error", listener: (error: Error) => void): this;385        prependOnceListener(event: "exit", listener: (code: number, signal: string) => void): this;386        prependOnceListener(event: "listening", listener: (address: Address) => void): this;387        prependOnceListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.388        prependOnceListener(event: "online", listener: () => void): this;389    }390    export interface Cluster extends EventEmitter {391        disconnect(callback?: () => void): void;392        /**393         * Spawn a new worker process.394         *395         * This can only be called from the primary process.396         * @param env Key/value pairs to add to worker process environment.397         * @since v0.6.0398         */399        fork(env?: any): Worker;400        /** @deprecated since v16.0.0 - use isPrimary. */401        readonly isMaster: boolean;402        /**403         * True if the process is a primary. This is determined by the `process.env.NODE_UNIQUE_ID`. If `process.env.NODE_UNIQUE_ID`404         * is undefined, then `isPrimary` is `true`.405         * @since v16.0.0406         */407        readonly isPrimary: boolean;408        /**409         * True if the process is not a primary (it is the negation of `cluster.isPrimary`).410         * @since v0.6.0411         */412        readonly isWorker: boolean;413        /**414         * The scheduling policy, either `cluster.SCHED_RR` for round-robin or `cluster.SCHED_NONE` to leave it to the operating system. This is a415         * global setting and effectively frozen once either the first worker is spawned, or [`.setupPrimary()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clustersetupprimarysettings)416         * is called, whichever comes first.417         *418         * `SCHED_RR` is the default on all operating systems except Windows. Windows will change to `SCHED_RR` once libuv is able to effectively distribute419         * IOCP handles without incurring a large performance hit.420         *421         * `cluster.schedulingPolicy` can also be set through the `NODE_CLUSTER_SCHED_POLICY` environment variable. Valid values are `'rr'` and `'none'`.422         * @since v0.11.2423         */424        schedulingPolicy: number;425        /**426         * After calling [`.setupPrimary()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clustersetupprimarysettings)427         * (or [`.fork()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clusterforkenv)) this settings object will contain428         * the settings, including the default values.429         *430         * This object is not intended to be changed or set manually.431         * @since v0.7.1432         */433        readonly settings: ClusterSettings;434        /** @deprecated since v16.0.0 - use [`.setupPrimary()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clustersetupprimarysettings) instead. */435        setupMaster(settings?: ClusterSettings): void;436        /**437         * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in `cluster.settings`.438         *439         * Any settings changes only affect future calls to [`.fork()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clusterforkenv)440         * and have no effect on workers that are already running.441         *442         * The only attribute of a worker that cannot be set via `.setupPrimary()` is the `env` passed to443         * [`.fork()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clusterforkenv).444         *445         * The defaults above apply to the first call only; the defaults for later calls are the current values at the time of446         * `cluster.setupPrimary()` is called.447         *448         * ```js449         * import cluster from 'node:cluster';450         *451         * cluster.setupPrimary({452         *   exec: 'worker.js',453         *   args: ['--use', 'https'],454         *   silent: true,455         * });456         * cluster.fork(); // https worker457         * cluster.setupPrimary({458         *   exec: 'worker.js',459         *   args: ['--use', 'http'],460         * });461         * cluster.fork(); // http worker462         * ```463         *464         * This can only be called from the primary process.465         * @since v16.0.0466         */467        setupPrimary(settings?: ClusterSettings): void;468        /**469         * A reference to the current worker object. Not available in the primary process.470         *471         * ```js472         * import cluster from 'node:cluster';473         *474         * if (cluster.isPrimary) {475         *   console.log('I am primary');476         *   cluster.fork();477         *   cluster.fork();478         * } else if (cluster.isWorker) {479         *   console.log(`I am worker #${cluster.worker.id}`);480         * }481         * ```482         * @since v0.7.0483         */484        readonly worker?: Worker | undefined;485        /**486         * A hash that stores the active worker objects, keyed by `id` field. This makes it easy to loop through all the workers. It is only available in the primary process.487         *488         * A worker is removed from `cluster.workers` after the worker has disconnected _and_ exited. The order between these two events cannot be determined in advance. However, it489         * is guaranteed that the removal from the `cluster.workers` list happens before the last `'disconnect'` or `'exit'` event is emitted.490         *491         * ```js492         * import cluster from 'node:cluster';493         *494         * for (const worker of Object.values(cluster.workers)) {495         *   worker.send('big announcement to all workers');496         * }497         * ```498         * @since v0.7.0499         */500        readonly workers?: NodeJS.Dict<Worker> | undefined;501        readonly SCHED_NONE: number;502        readonly SCHED_RR: number;503        /**504         * events.EventEmitter505         *   1. disconnect506         *   2. exit507         *   3. fork508         *   4. listening509         *   5. message510         *   6. online511         *   7. setup512         */513        addListener(event: string, listener: (...args: any[]) => void): this;514        addListener(event: "disconnect", listener: (worker: Worker) => void): this;515        addListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;516        addListener(event: "fork", listener: (worker: Worker) => void): this;517        addListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;518        addListener(519            event: "message",520            listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void,521        ): this; // the handle is a net.Socket or net.Server object, or undefined.522        addListener(event: "online", listener: (worker: Worker) => void): this;523        addListener(event: "setup", listener: (settings: ClusterSettings) => void): this;524        emit(event: string | symbol, ...args: any[]): boolean;525        emit(event: "disconnect", worker: Worker): boolean;526        emit(event: "exit", worker: Worker, code: number, signal: string): boolean;527        emit(event: "fork", worker: Worker): boolean;528        emit(event: "listening", worker: Worker, address: Address): boolean;529        emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean;530        emit(event: "online", worker: Worker): boolean;531        emit(event: "setup", settings: ClusterSettings): boolean;532        on(event: string, listener: (...args: any[]) => void): this;533        on(event: "disconnect", listener: (worker: Worker) => void): this;534        on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;535        on(event: "fork", listener: (worker: Worker) => void): this;536        on(event: "listening", listener: (worker: Worker, address: Address) => void): this;537        on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.538        on(event: "online", listener: (worker: Worker) => void): this;539        on(event: "setup", listener: (settings: ClusterSettings) => void): this;540        once(event: string, listener: (...args: any[]) => void): this;541        once(event: "disconnect", listener: (worker: Worker) => void): this;542        once(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;543        once(event: "fork", listener: (worker: Worker) => void): this;544        once(event: "listening", listener: (worker: Worker, address: Address) => void): this;545        once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.546        once(event: "online", listener: (worker: Worker) => void): this;547        once(event: "setup", listener: (settings: ClusterSettings) => void): this;548        prependListener(event: string, listener: (...args: any[]) => void): this;549        prependListener(event: "disconnect", listener: (worker: Worker) => void): this;550        prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;551        prependListener(event: "fork", listener: (worker: Worker) => void): this;552        prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;553        // the handle is a net.Socket or net.Server object, or undefined.554        prependListener(555            event: "message",556            listener: (worker: Worker, message: any, handle?: net.Socket | net.Server) => void,557        ): this;558        prependListener(event: "online", listener: (worker: Worker) => void): this;559        prependListener(event: "setup", listener: (settings: ClusterSettings) => void): this;560        prependOnceListener(event: string, listener: (...args: any[]) => void): this;561        prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): this;562        prependOnceListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;563        prependOnceListener(event: "fork", listener: (worker: Worker) => void): this;564        prependOnceListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;565        // the handle is a net.Socket or net.Server object, or undefined.566        prependOnceListener(567            event: "message",568            listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void,569        ): this;570        prependOnceListener(event: "online", listener: (worker: Worker) => void): this;571        prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): this;572    }573    const cluster: Cluster;574    export default cluster;575}576declare module "node:cluster" {577    export * from "cluster";578    export { default as default } from "cluster";579}580