@eggjs/cluster 3.0.0-beta.0

package/dist/esm/utils/mode/impl/process/app.js

@@ -0,0 +1,126 @@
+import cluster from 'node:cluster';
+import { cfork } from 'cfork';
+import { sendmessage } from 'sendmessage';
+import { graceful as gracefulExit } from 'graceful-process';
+import { BaseAppWorker, BaseAppUtils } from '../../base/app.js';
+import { terminate } from '../../../terminate.js';
+export class AppProcessWorker extends BaseAppWorker {
+    get id() {
+        return this.instance.id;
+    }
+    get workerId() {
+        return this.instance.process.pid;
+    }
+    get exitedAfterDisconnect() {
+        return this.instance.exitedAfterDisconnect;
+    }
+    get exitCode() {
+        return this.instance.process.exitCode;
+    }
+    send(message) {
+        sendmessage(this.instance, message);
+    }
+    clean() {
+        this.instance.removeAllListeners();
+    }
+    static on(event, listener) {
+        process.on(event, listener);
+    }
+    static send(message) {
+        process.send(message);
+    }
+    static kill() {
+        process.exitCode = 1;
+        process.kill(process.pid);
+    }
+    static gracefulExit(options) {
+        gracefulExit(options);
+    }
+}
+export class AppProcessUtils extends BaseAppUtils {
+    fork() {
+        this.startTime = Date.now();
+        this.startSuccessCount = 0;
+        const args = [JSON.stringify(this.options)];
+        this.log('[master] start appWorker with args %j (process)', args);
+        cfork({
+            exec: this.getAppWorkerFile(),
+            args,
+            silent: false,
+            count: this.options.workers,
+            // don't refork in local env
+            refork: this.isProduction,
+            windowsHide: process.platform === 'win32',
+        });
+        let debugPort = process.debugPort;
+        cluster.on('fork', worker => {
+            const appWorker = new AppProcessWorker(worker);
+            this.emit('worker_forked', appWorker);
+            appWorker.disableRefork = true;
+            worker.on('message', msg => {
+                if (typeof msg === 'string') {
+                    msg = {
+                        action: msg,
+                        data: msg,
+                    };
+                }
+                msg.from = 'app';
+                this.messenger.send(msg);
+            });
+            this.log('[master] app_worker#%s:%s start, state: %s, current workers: %j', appWorker.id, appWorker.workerId, appWorker.state, Object.keys(cluster.workers));
+            // send debug message, due to `brk` scene, send here instead of app_worker.js
+            if (this.options.isDebug) {
+                debugPort++;
+                this.messenger.send({
+                    to: 'parent',
+                    from: 'app',
+                    action: 'debug',
+                    data: {
+                        debugPort,
+                        // keep compatibility, should use workerId instead
+                        pid: appWorker.workerId,
+                        workerId: appWorker.workerId,
+                    },
+                });
+            }
+        });
+        cluster.on('disconnect', worker => {
+            const appWorker = new AppProcessWorker(worker);
+            this.logger.info('[master] app_worker#%s:%s disconnect, suicide: %s, state: %s, current workers: %j', appWorker.id, appWorker.workerId, appWorker.exitedAfterDisconnect, appWorker.state, Object.keys(cluster.workers));
+        });
+        cluster.on('exit', (worker, code, signal) => {
+            const appWorker = new AppProcessWorker(worker);
+            this.messenger.send({
+                action: 'app-exit',
+                data: {
+                    workerId: appWorker.workerId,
+                    code,
+                    signal,
+                },
+                to: 'master',
+                from: 'app',
+            });
+        });
+        cluster.on('listening', (worker, address) => {
+            const appWorker = new AppProcessWorker(worker);
+            this.messenger.send({
+                action: 'app-start',
+                data: {
+                    workerId: appWorker.workerId,
+                    address,
+                },
+                to: 'master',
+                from: 'app',
+            });
+        });
+        return this;
+    }
+    async kill(timeout) {
+        await Promise.all(Object.keys(cluster.workers).map(id => {
+            const worker = cluster.workers[id];
+            Reflect.set(worker, 'disableRefork', true);
+            return terminate(worker.process, timeout);
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/mode/impl/worker_threads/agent.d.ts

@@ -0,0 +1,18 @@
+import { type Worker } from 'node:worker_threads';
+import { type Options as gracefulExitOptions } from 'graceful-process';
+import { BaseAgentUtils, BaseAgentWorker } from '../../base/agent.js';
+import type { MessageBody } from '../../../messenger.js';
+export declare class AgentThreadWorker extends BaseAgentWorker<Worker> {
+    get workerId(): number;
+    send(message: MessageBody): void;
+    static send(message: MessageBody): void;
+    static kill(): void;
+    static gracefulExit(options: gracefulExitOptions): void;
+}
+export declare class AgentThreadUtils extends BaseAgentUtils {
+    #private;
+    instance: AgentThreadWorker;
+    fork(): void;
+    clean(): void;
+    kill(): Promise<void>;
+}

package/dist/esm/utils/mode/impl/worker_threads/agent.js

@@ -0,0 +1,82 @@
+import workerThreads from 'node:worker_threads';
+import { BaseAgentUtils, BaseAgentWorker } from '../../base/agent.js';
+import { ClusterAgentWorkerError } from '../../../../error/ClusterAgentWorkerError.js';
+export class AgentThreadWorker extends BaseAgentWorker {
+    get workerId() {
+        return this.instance.threadId;
+    }
+    send(message) {
+        this.instance.postMessage(message);
+    }
+    static send(message) {
+        workerThreads.parentPort.postMessage(message);
+    }
+    static kill() {
+        // in worker_threads, process.exit
+        // does not stop the whole program, just the single thread
+        process.exit(1);
+    }
+    static gracefulExit(options) {
+        const { beforeExit } = options;
+        process.on('exit', async (code) => {
+            if (typeof beforeExit === 'function') {
+                await beforeExit();
+            }
+            process.exit(code);
+        });
+    }
+}
+export class AgentThreadUtils extends BaseAgentUtils {
+    #worker;
+    #id = 0;
+    instance;
+    fork() {
+        this.startTime = Date.now();
+        // start agent worker
+        const argv = [JSON.stringify(this.options)];
+        const agentPath = this.getAgentWorkerFile();
+        const worker = this.#worker = new workerThreads.Worker(agentPath, { argv });
+        // wrap agent worker
+        const agentWorker = this.instance = new AgentThreadWorker(worker);
+        this.emit('agent_forked', agentWorker);
+        agentWorker.status = 'starting';
+        agentWorker.id = ++this.#id;
+        this.log('[master] agent_worker#%s:%s start with worker_threads', agentWorker.id, agentWorker.workerId);
+        worker.on('message', msg => {
+            if (typeof msg === 'string') {
+                msg = {
+                    action: msg,
+                    data: msg,
+                };
+            }
+            msg.from = 'agent';
+            this.messenger.send(msg);
+        });
+        worker.on('error', err => {
+            this.logger.error(new ClusterAgentWorkerError(agentWorker.id, agentWorker.workerId, agentWorker.status, err));
+        });
+        // agent exit message
+        worker.once('exit', (code, signal) => {
+            this.messenger.send({
+                action: 'agent-exit',
+                data: {
+                    code,
+                    signal,
+                },
+                to: 'master',
+                from: 'agent',
+            });
+        });
+    }
+    clean() {
+        this.#worker.removeAllListeners();
+    }
+    async kill() {
+        if (this.#worker) {
+            this.log(`[master] kill agent worker#${this.#id} (worker_threads) by worker.terminate()`);
+            this.clean();
+            await this.#worker.terminate();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/mode/impl/worker_threads/app.d.ts

@@ -0,0 +1,25 @@
+import { Worker as ThreadWorker } from 'node:worker_threads';
+import type { Options as gracefulExitOptions } from 'graceful-process';
+import { BaseAppWorker, BaseAppUtils } from '../../base/app.js';
+import type { MessageBody } from '../../../messenger.js';
+export declare class AppThreadWorker extends BaseAppWorker<ThreadWorker> {
+    #private;
+    constructor(instance: ThreadWorker, id: number);
+    get id(): number;
+    get workerId(): number;
+    get state(): string;
+    set state(val: string);
+    get exitedAfterDisconnect(): boolean;
+    get exitCode(): number;
+    send(message: MessageBody): void;
+    clean(): void;
+    static on(event: string, listener: (...args: any[]) => void): void;
+    static send(message: MessageBody): void;
+    static kill(): void;
+    static gracefulExit(options: gracefulExitOptions): void;
+}
+export declare class AppThreadUtils extends BaseAppUtils {
+    #private;
+    fork(): this;
+    kill(): Promise<void>;
+}

package/dist/esm/utils/mode/impl/worker_threads/app.js

@@ -0,0 +1,151 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { Worker as ThreadWorker, parentPort } from 'node:worker_threads';
+import { BaseAppWorker, BaseAppUtils } from '../../base/app.js';
+export class AppThreadWorker extends BaseAppWorker {
+    #state = 'none';
+    #id;
+    constructor(instance, id) {
+        super(instance);
+        this.#id = id;
+    }
+    get id() {
+        return this.#id;
+    }
+    get workerId() {
+        return this.instance.threadId;
+    }
+    get state() {
+        return this.#state;
+    }
+    set state(val) {
+        this.#state = val;
+    }
+    get exitedAfterDisconnect() {
+        return true;
+    }
+    get exitCode() {
+        return 0;
+        // return this.instance.exitCode;
+    }
+    send(message) {
+        this.instance.postMessage(message);
+    }
+    clean() {
+        this.instance.removeAllListeners();
+    }
+    static on(event, listener) {
+        parentPort.on(event, listener);
+    }
+    static send(message) {
+        parentPort.postMessage(message);
+    }
+    static kill() {
+        process.exit(1);
+    }
+    static gracefulExit(options) {
+        process.on('exit', async (code) => {
+            if (typeof options.beforeExit === 'function') {
+                await options.beforeExit();
+            }
+            process.exit(code);
+        });
+    }
+}
+export class AppThreadUtils extends BaseAppUtils {
+    #workers = [];
+    #forkSingle(appPath, options, id) {
+        // start app worker
+        const worker = new ThreadWorker(appPath, options);
+        this.#workers.push(worker);
+        // wrap app worker
+        const appWorker = new AppThreadWorker(worker, id);
+        this.emit('worker_forked', appWorker);
+        appWorker.disableRefork = true;
+        worker.on('message', (msg) => {
+            if (typeof msg === 'string') {
+                msg = {
+                    action: msg,
+                    data: msg,
+                };
+            }
+            msg.from = 'app';
+            this.messenger.send(msg);
+        });
+        this.log('[master] app_worker#%s (tid:%s) start', appWorker.id, appWorker.workerId);
+        // send debug message, due to `brk` scene, send here instead of app_worker.js
+        let debugPort = process.debugPort;
+        if (this.options.isDebug) {
+            debugPort++;
+            this.messenger.send({
+                to: 'parent',
+                from: 'app',
+                action: 'debug',
+                data: {
+                    debugPort,
+                    pid: appWorker.workerId,
+                    workerId: appWorker.workerId,
+                },
+            });
+        }
+        // handle worker listening
+        worker.on('message', ({ action, data: address }) => {
+            if (action !== 'listening') {
+                return;
+            }
+            if (!address) {
+                return;
+            }
+            appWorker.state = 'listening';
+            this.messenger.send({
+                action: 'app-start',
+                data: {
+                    workerId: appWorker.workerId,
+                    address,
+                },
+                to: 'master',
+                from: 'app',
+            });
+        });
+        // handle worker exit
+        worker.on('exit', async (code) => {
+            appWorker.state = 'dead';
+            this.messenger.send({
+                action: 'app-exit',
+                data: {
+                    workerId: appWorker.workerId,
+                    code,
+                },
+                to: 'master',
+                from: 'app',
+            });
+            // refork app worker
+            await sleep(1000);
+            this.#forkSingle(appPath, options, id);
+        });
+    }
+    fork() {
+        this.startTime = Date.now();
+        this.startSuccessCount = 0;
+        const ports = this.options.ports ?? [];
+        if (!ports.length) {
+            ports.push(this.options.port);
+        }
+        this.options.workers = ports.length;
+        let i = 0;
+        do {
+            const options = Object.assign({}, this.options, { port: ports[i] });
+            const argv = [JSON.stringify(options)];
+            this.#forkSingle(this.getAppWorkerFile(), { argv }, ++i);
+        } while (i < ports.length);
+        return this;
+    }
+    async kill() {
+        for (const worker of this.#workers) {
+            const id = Reflect.get(worker, 'id');
+            this.log(`[master] kill app worker#${id} (worker_threads) by worker.terminate()`);
+            worker.removeAllListeners();
+            worker.terminate();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/options.d.ts

@@ -0,0 +1,80 @@
+import { SecureContextOptions } from 'node:tls';
+export interface ClusterHTTPSSecureOptions {
+    key: SecureContextOptions['key'];
+    cert: SecureContextOptions['cert'];
+    ca?: SecureContextOptions['ca'];
+    passphrase?: SecureContextOptions['passphrase'];
+}
+export type ClusterStartMode = 'process' | 'worker_threads';
+/** Cluster start options */
+export interface ClusterOptions {
+    /**
+     * specify framework that can be absolute path or npm package
+     */
+    framework?: string;
+    /**
+     * @deprecated please use framework instead
+     */
+    customEgg?: string;
+    /** directory of application, default to `process.cwd()` */
+    baseDir?: string;
+    /**
+     * numbers of app workers, default to `os.cpus().length`
+     */
+    workers?: number | string;
+    /**
+     * listening port, default to `7001`(http) or `8443`(https)
+     */
+    port?: number | string | null;
+    /**
+     * listening a debug port on http protocol
+     */
+    debugPort?: number;
+    /**
+     * https options, { key, cert, ca }, full path
+     */
+    https?: ClusterHTTPSSecureOptions | boolean;
+    /**
+     * @deprecated please use `options.https.key` instead
+     */
+    key?: ClusterHTTPSSecureOptions['key'];
+    /**
+     * @deprecated please use `options.https.cert` instead
+     */
+    cert?: ClusterHTTPSSecureOptions['cert'];
+    /**
+     * will inject into worker/agent process
+     */
+    require?: string | string[];
+    /**
+     * will save master pid to this file
+     */
+    pidFile?: string;
+    /**
+     * custom env, default is `process.env.EGG_SERVER_ENV`
+     */
+    env?: string;
+    /**
+     * default is `'process'`, use `'worker_threads'` to start the app & agent worker by worker_threads
+     */
+    startMode?: ClusterStartMode;
+    /**
+     * startup port of each app worker, such as: `[7001, 7002, 7003]`, only effects when the startMode is `'worker_threads'`
+     */
+    ports?: number[];
+    /**
+     * sticky mode server
+     */
+    sticky?: boolean;
+    /** customized plugins, for unittest */
+    plugins?: object;
+    isDebug?: boolean;
+}
+export interface ParsedClusterOptions extends ClusterOptions {
+    port?: number;
+    baseDir: string;
+    workers: number;
+    framework: string;
+    startMode: ClusterStartMode;
+}
+export declare function parseOptions(options?: ClusterOptions): Promise<ParsedClusterOptions>;

package/dist/esm/utils/options.js

@@ -0,0 +1,75 @@
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import assert from 'node:assert';
+import { getFrameworkPath, importModule } from '@eggjs/utils';
+export async function parseOptions(options) {
+    options = {
+        baseDir: process.cwd(),
+        port: options?.https ? 8443 : undefined,
+        startMode: 'process',
+        // ports: [],
+        env: process.env.EGG_SERVER_ENV,
+        ...options,
+    };
+    const pkgPath = path.join(options.baseDir, 'package.json');
+    assert(fs.existsSync(pkgPath), `${pkgPath} should exist`);
+    options.framework = getFrameworkPath({
+        baseDir: options.baseDir,
+        // compatible customEgg only when call startCluster directly without framework
+        framework: options.framework ?? options.customEgg,
+    });
+    const egg = await importModule(options.framework);
+    assert(egg.Application, `should define Application in ${options.framework}`);
+    assert(egg.Agent, `should define Agent in ${options.framework}`);
+    if (options.https === true) {
+        // Keep compatible options.key, options.cert
+        console.warn('[@eggjs/cluster:deprecated] [master] Please use `https: { key, cert, ca }` instead of `https: true`');
+        options.https = {
+            key: options.key,
+            cert: options.cert,
+        };
+    }
+    // https
+    if (options.https) {
+        assert(options.https.key, 'options.https.key should exists');
+        if (typeof options.https.key === 'string') {
+            assert(fs.existsSync(options.https.key), 'options.https.key file should exists');
+        }
+        assert(options.https.cert, 'options.https.cert should exists');
+        if (typeof options.https.cert === 'string') {
+            assert(fs.existsSync(options.https.cert), 'options.https.cert file should exists');
+        }
+        if (typeof options.https.ca === 'string') {
+            assert(fs.existsSync(options.https.ca), 'options.https.ca file should exists');
+        }
+    }
+    if (options.port && typeof options.port === 'string') {
+        options.port = parseInt(options.port);
+    }
+    if (options.port === null) {
+        options.port = undefined;
+    }
+    if (options.workers && typeof options.workers === 'string') {
+        options.workers = parseInt(options.workers);
+    }
+    if (!options.workers) {
+        options.workers = os.cpus().length;
+    }
+    if (options.require) {
+        if (typeof options.require === 'string') {
+            options.require = [options.require];
+        }
+    }
+    // don't print deprecated message in production env.
+    // it will print to stderr.
+    if (process.env.NODE_ENV === 'production') {
+        process.env.NO_DEPRECATION = '*';
+    }
+    const isDebug = process.execArgv.some(argv => argv.includes('--debug') || argv.includes('--inspect'));
+    if (isDebug) {
+        options.isDebug = isDebug;
+    }
+    return options;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/terminate.d.ts

@@ -0,0 +1,6 @@
+import { ChildProcess } from 'node:child_process';
+interface SubProcess extends ChildProcess {
+    process?: ChildProcess;
+}
+export declare function terminate(subProcess: SubProcess, timeout: number): Promise<void>;
+export {};