@eggjs/cluster 4.0.0-beta.20 → 4.0.0-beta.21

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

@@ -0,0 +1,119 @@
+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 methods use on src/app_worker.ts
+    static get workerId() {
+        return process.pid;
+    }
+    static on(event, listener) {
+        process.on(event, listener);
+    }
+    static send(message) {
+        message.senderWorkerId = String(process.pid);
+        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.log('[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',
+            });
+        });
+        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/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.ts';
+import type { MessageBody } from '../../../messenger.ts';
+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/utils/mode/impl/worker_threads/agent.js

@@ -0,0 +1,84 @@
+import workerThreads, {} from 'node:worker_threads';
+import {} from 'graceful-process';
+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) {
+        message.senderWorkerId = String(workerThreads.threadId);
+        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/utils/mode/impl/worker_threads/app.d.ts

@@ -0,0 +1,26 @@
+import { Worker as ThreadWorker } from 'node:worker_threads';
+import type { Options as gracefulExitOptions } from 'graceful-process';
+import { BaseAppWorker, BaseAppUtils } from '../../base/app.ts';
+import type { MessageBody } from '../../../messenger.ts';
+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 get workerId(): number;
+    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/utils/mode/impl/worker_threads/app.js

@@ -0,0 +1,137 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { Worker as ThreadWorker, threadId, 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 methods use on src/app_worker.ts
+    static get workerId() {
+        return threadId;
+    }
+    static on(event, listener) {
+        parentPort.on(event, listener);
+    }
+    static send(message) {
+        message.senderWorkerId = String(threadId);
+        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 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/utils/options.d.ts

@@ -0,0 +1,80 @@
+import { type 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/utils/options.js

@@ -0,0 +1,81 @@
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import assert from 'node:assert';
+import { debuglog } from 'node:util';
+import {} from 'node:tls';
+import { getFrameworkPath, importModule } from '@eggjs/utils';
+const debug = debuglog('egg/cluster/utils/options');
+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,
+    });
+    debug('[parseOptions] %o', options);
+    const egg = await importModule(options.framework, {
+        paths: [options.baseDir],
+    });
+    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/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 {};