@eggjs/cluster 3.0.0-beta.0

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

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppProcessUtils = exports.AppProcessWorker = void 0;
+const node_cluster_1 = __importDefault(require("node:cluster"));
+const cfork_1 = require("cfork");
+const sendmessage_1 = require("sendmessage");
+const graceful_process_1 = require("graceful-process");
+const app_js_1 = require("../../base/app.js");
+const terminate_js_1 = require("../../../terminate.js");
+class AppProcessWorker extends app_js_1.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) {
+        (0, sendmessage_1.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) {
+        (0, graceful_process_1.graceful)(options);
+    }
+}
+exports.AppProcessWorker = AppProcessWorker;
+class AppProcessUtils extends app_js_1.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);
+        (0, cfork_1.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;
+        node_cluster_1.default.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(node_cluster_1.default.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,
+                    },
+                });
+            }
+        });
+        node_cluster_1.default.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(node_cluster_1.default.workers));
+        });
+        node_cluster_1.default.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',
+            });
+        });
+        node_cluster_1.default.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(node_cluster_1.default.workers).map(id => {
+            const worker = node_cluster_1.default.workers[id];
+            Reflect.set(worker, 'disableRefork', true);
+            return (0, terminate_js_1.terminate)(worker.process, timeout);
+        }));
+    }
+}
+exports.AppProcessUtils = AppProcessUtils;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/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/commonjs/utils/mode/impl/worker_threads/agent.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentThreadUtils = exports.AgentThreadWorker = void 0;
+const node_worker_threads_1 = __importDefault(require("node:worker_threads"));
+const agent_js_1 = require("../../base/agent.js");
+const ClusterAgentWorkerError_js_1 = require("../../../../error/ClusterAgentWorkerError.js");
+class AgentThreadWorker extends agent_js_1.BaseAgentWorker {
+    get workerId() {
+        return this.instance.threadId;
+    }
+    send(message) {
+        this.instance.postMessage(message);
+    }
+    static send(message) {
+        node_worker_threads_1.default.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);
+        });
+    }
+}
+exports.AgentThreadWorker = AgentThreadWorker;
+class AgentThreadUtils extends agent_js_1.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 node_worker_threads_1.default.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_js_1.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();
+        }
+    }
+}
+exports.AgentThreadUtils = AgentThreadUtils;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/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/commonjs/utils/mode/impl/worker_threads/app.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppThreadUtils = exports.AppThreadWorker = void 0;
+const promises_1 = require("node:timers/promises");
+const node_worker_threads_1 = require("node:worker_threads");
+const app_js_1 = require("../../base/app.js");
+class AppThreadWorker extends app_js_1.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) {
+        node_worker_threads_1.parentPort.on(event, listener);
+    }
+    static send(message) {
+        node_worker_threads_1.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);
+        });
+    }
+}
+exports.AppThreadWorker = AppThreadWorker;
+class AppThreadUtils extends app_js_1.BaseAppUtils {
+    #workers = [];
+    #forkSingle(appPath, options, id) {
+        // start app worker
+        const worker = new node_worker_threads_1.Worker(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 (0, promises_1.setTimeout)(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();
+        }
+    }
+}
+exports.AppThreadUtils = AppThreadUtils;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/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/commonjs/utils/options.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptions = parseOptions;
+const node_os_1 = __importDefault(require("node:os"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const utils_1 = require("@eggjs/utils");
+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 = node_path_1.default.join(options.baseDir, 'package.json');
+    (0, node_assert_1.default)(node_fs_1.default.existsSync(pkgPath), `${pkgPath} should exist`);
+    options.framework = (0, utils_1.getFrameworkPath)({
+        baseDir: options.baseDir,
+        // compatible customEgg only when call startCluster directly without framework
+        framework: options.framework ?? options.customEgg,
+    });
+    const egg = await (0, utils_1.importModule)(options.framework);
+    (0, node_assert_1.default)(egg.Application, `should define Application in ${options.framework}`);
+    (0, node_assert_1.default)(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) {
+        (0, node_assert_1.default)(options.https.key, 'options.https.key should exists');
+        if (typeof options.https.key === 'string') {
+            (0, node_assert_1.default)(node_fs_1.default.existsSync(options.https.key), 'options.https.key file should exists');
+        }
+        (0, node_assert_1.default)(options.https.cert, 'options.https.cert should exists');
+        if (typeof options.https.cert === 'string') {
+            (0, node_assert_1.default)(node_fs_1.default.existsSync(options.https.cert), 'options.https.cert file should exists');
+        }
+        if (typeof options.https.ca === 'string') {
+            (0, node_assert_1.default)(node_fs_1.default.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 = node_os_1.default.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/commonjs/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 {};