@eggjs/cluster 3.0.0-beta.0

package/dist/esm/utils/messenger.js

@@ -0,0 +1,176 @@
+import { debuglog } from 'node:util';
+import workerThreads from 'node:worker_threads';
+const debug = debuglog('@eggjs/cluster/messenger');
+/**
+ * master messenger, provide communication between parent, master, agent and app.
+ *
+ *             ┌────────┐
+ *             │ parent │
+ *            /└────────┘\
+ *           /     |      \
+ *          /  ┌────────┐  \
+ *         /   │ master │   \
+ *        /    └────────┘    \
+ *       /     /         \    \
+ *     ┌───────┐         ┌───────┐
+ *     │ agent │ ------- │  app  │
+ *     └───────┘         └───────┘
+ *
+ *
+ * in app worker
+ *
+ * ```js
+ * process.send({
+ *   action: 'xxx',
+ *   data: '',
+ *   to: 'agent/master/parent', // default to agent
+ * });
+ * ```
+ *
+ * in agent worker
+ *
+ * ```js
+ * process.send({
+ *   action: 'xxx',
+ *   data: '',
+ *   to: 'app/master/parent', // default to app
+ * });
+ * ```
+ *
+ * in parent
+ *
+ * ```js
+ * process.send({
+ *   action: 'xxx',
+ *   data: '',
+ *   to: 'app/agent/master', // default to master
+ * });
+ * ```
+ */
+export class Messenger {
+    #master;
+    #workerManager;
+    #hasParent;
+    constructor(master, workerManager) {
+        this.#master = master;
+        this.#workerManager = workerManager;
+        this.#hasParent = !!workerThreads.parentPort || !!process.send;
+        process.on('message', (msg) => {
+            msg.from = 'parent';
+            this.send(msg);
+        });
+        process.once('disconnect', () => {
+            this.#hasParent = false;
+        });
+    }
+    /**
+     * send message
+     * @param {Object} data message body
+     *  - {String} from from who
+     *  - {String} to to who
+     */
+    send(data) {
+        if (!data.from) {
+            data.from = 'master';
+        }
+        // https://github.com/eggjs/egg/blob/b6861f1c7548f05a281386050dfeaeb30f236558/lib/core/messenger/ipc.js#L56
+        // recognize receiverPid is to who
+        if (data.receiverPid) {
+            if (data.receiverPid === String(process.pid)) {
+                data.to = 'master';
+            }
+            else if (data.receiverPid === String(this.#workerManager.getAgent().workerId)) {
+                data.to = 'agent';
+            }
+            else {
+                data.to = 'app';
+            }
+        }
+        // default from -> to rules
+        if (!data.to) {
+            if (data.from === 'agent') {
+                data.to = 'app';
+            }
+            if (data.from === 'app') {
+                data.to = 'agent';
+            }
+            if (data.from === 'parent') {
+                data.to = 'master';
+            }
+        }
+        // app -> master
+        // agent -> master
+        if (data.to === 'master') {
+            debug('%s -> master, data: %j', data.from, data);
+            // app/agent to master
+            this.sendToMaster(data);
+            return;
+        }
+        // master -> parent
+        // app -> parent
+        // agent -> parent
+        if (data.to === 'parent') {
+            debug('%s -> parent, data: %j', data.from, data);
+            this.sendToParent(data);
+            return;
+        }
+        // parent -> master -> app
+        // agent -> master -> app
+        if (data.to === 'app') {
+            debug('%s -> %s, data: %j', data.from, data.to, data);
+            this.sendToAppWorker(data);
+            return;
+        }
+        // parent -> master -> agent
+        // app -> master -> agent，可能不指定 to
+        if (data.to === 'agent') {
+            debug('%s -> %s, data: %j', data.from, data.to, data);
+            this.sendToAgentWorker(data);
+            return;
+        }
+    }
+    /**
+     * send message to master self
+     * @param {Object} data message body
+     */
+    sendToMaster(data) {
+        this.#master.emit(data.action, data.data);
+    }
+    /**
+     * send message to parent process
+     * @param {Object} data message body
+     */
+    sendToParent(data) {
+        if (!this.#hasParent) {
+            return;
+        }
+        process.send(data);
+    }
+    /**
+     * send message to app worker
+     * @param {Object} data message body
+     */
+    sendToAppWorker(data) {
+        for (const worker of this.#workerManager.listWorkers()) {
+            if (worker.state === 'disconnected') {
+                continue;
+            }
+            // check receiverPid
+            if (data.receiverPid && data.receiverPid !== String(worker.workerId)) {
+                continue;
+            }
+            worker.send(data);
+        }
+    }
+    /**
+     * send message to agent worker
+     * @param {Object} data message body
+     */
+    sendToAgentWorker(data) {
+        const agent = this.#workerManager.getAgent();
+        if (agent) {
+            agent.send(data);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/mode/base/agent.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'node:events';
+import type { ChildProcess } from 'node:child_process';
+import type { Worker } from 'node:worker_threads';
+import type { Logger } from 'egg-logger';
+import type { MasterOptions } from '../../../master.js';
+import type { MessageBody, Messenger } from '../../messenger.js';
+export declare abstract class BaseAgentWorker<T = ChildProcess | Worker> {
+    #private;
+    instance: T;
+    constructor(instance: T);
+    abstract get workerId(): number;
+    get id(): number;
+    set id(id: number);
+    get status(): string;
+    set status(status: string);
+    abstract send(message: MessageBody): void;
+    static send(_message: MessageBody): void;
+    static kill(): void;
+    static gracefulExit(_options: any): void;
+}
+type LogFun = (msg: any, ...args: any[]) => void;
+export declare abstract class BaseAgentUtils extends EventEmitter {
+    protected options: MasterOptions;
+    protected messenger: Messenger;
+    protected log: LogFun;
+    protected logger: Logger;
+    startTime: number;
+    constructor(options: MasterOptions, { log, logger, messenger }: {
+        log: LogFun;
+        logger: Logger;
+        messenger: Messenger;
+    });
+    getAgentWorkerFile(): string;
+    fork(): void;
+    clean(): void;
+    abstract kill(timeout: number): Promise<void>;
+}
+export {};

package/dist/esm/utils/mode/base/agent.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { getSrcDirname } from '../../../dirname.js';
+export class BaseAgentWorker {
+    instance;
+    #instanceId;
+    #instanceStatus;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    get id() {
+        return this.#instanceId;
+    }
+    set id(id) {
+        this.#instanceId = id;
+    }
+    get status() {
+        return this.#instanceStatus;
+    }
+    set status(status) {
+        this.#instanceStatus = status;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static send(_message) {
+        throw new Error('BaseAgentWorker should implement send.');
+    }
+    static kill() {
+        throw new Error('BaseAgentWorker should implement kill.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static gracefulExit(_options) {
+        throw new Error('BaseAgentWorker should implement gracefulExit.');
+    }
+}
+export class BaseAgentUtils extends EventEmitter {
+    options;
+    messenger;
+    log;
+    logger;
+    // public attrs
+    startTime = 0;
+    constructor(options, { log, logger, messenger }) {
+        super();
+        this.options = options;
+        this.log = log;
+        this.logger = logger;
+        this.messenger = messenger;
+        // this.instance = null;
+    }
+    getAgentWorkerFile() {
+        return path.join(getSrcDirname(), 'agent_worker.js');
+    }
+    fork() {
+        throw new Error('BaseAgent should implement fork.');
+    }
+    clean() {
+        throw new Error('BaseAgent should implement clean.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvdXRpbHMvbW9kZS9iYXNlL2FnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUM3QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBTTNDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVwRCxNQUFNLE9BQWdCLGVBQWU7SUFDbkMsUUFBUSxDQUFJO0lBQ1osV0FBVyxDQUFTO0lBQ3BCLGVBQWUsQ0FBUztJQUV4QixZQUFZLFFBQVc7UUFDckIsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQztJQUlELElBQUksRUFBRTtRQUNKLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDO0lBRUQsSUFBSSxFQUFFLENBQUMsRUFBRTtRQUNQLElBQUksQ0FBQyxXQUFXLEdBQUcsRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFFRCxJQUFJLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUM7SUFDOUIsQ0FBQztJQUVELElBQUksTUFBTSxDQUFDLE1BQU07UUFDZixJQUFJLENBQUMsZUFBZSxHQUFHLE1BQU0sQ0FBQztJQUNoQyxDQUFDO0lBSUQsNkRBQTZEO0lBQzdELE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBcUI7UUFDL0IsTUFBTSxJQUFJLEtBQUssQ0FBQyx3Q0FBd0MsQ0FBQyxDQUFDO0lBQzVELENBQUM7SUFFRCxNQUFNLENBQUMsSUFBSTtRQUNULE1BQU0sSUFBSSxLQUFLLENBQUMsd0NBQXdDLENBQUMsQ0FBQztJQUM1RCxDQUFDO0lBRUQsNkRBQTZEO0lBQzdELE1BQU0sQ0FBQyxZQUFZLENBQUMsUUFBYTtRQUMvQixNQUFNLElBQUksS0FBSyxDQUFDLGdEQUFnRCxDQUFDLENBQUM7SUFDcEUsQ0FBQztDQUNGO0FBSUQsTUFBTSxPQUFnQixjQUFlLFNBQVEsWUFBWTtJQUM3QyxPQUFPLENBQWdCO0lBQ3ZCLFNBQVMsQ0FBWTtJQUNyQixHQUFHLENBQVM7SUFDWixNQUFNLENBQVM7SUFDekIsZUFBZTtJQUNmLFNBQVMsR0FBRyxDQUFDLENBQUM7SUFFZCxZQUFZLE9BQXNCLEVBQUUsRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFJM0Q7UUFDQyxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxHQUFHLEdBQUcsR0FBRyxDQUFDO1FBQ2YsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0Isd0JBQXdCO0lBQzFCLENBQUM7SUFFRCxrQkFBa0I7UUFDaEIsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxFQUFFLGlCQUFpQixDQUFDLENBQUM7SUFDdkQsQ0FBQztJQUVELElBQUk7UUFDRixNQUFNLElBQUksS0FBSyxDQUFDLGtDQUFrQyxDQUFDLENBQUM7SUFDdEQsQ0FBQztJQUVELEtBQUs7UUFDSCxNQUFNLElBQUksS0FBSyxDQUFDLG1DQUFtQyxDQUFDLENBQUM7SUFDdkQsQ0FBQztDQUdGIn0=

package/dist/esm/utils/mode/base/app.d.ts

@@ -0,0 +1,48 @@
+import { EventEmitter } from 'node:events';
+import type { Worker as ClusterProcessWorker } from 'node:cluster';
+import type { Worker as ThreadWorker } from 'node:worker_threads';
+import type { Logger } from 'egg-logger';
+import type { MessageBody, Messenger } from '../../messenger.js';
+import type { MasterOptions } from '../../../master.js';
+export declare abstract class BaseAppWorker<T = ThreadWorker | ClusterProcessWorker> {
+    #private;
+    instance: T;
+    constructor(instance: T);
+    abstract get workerId(): number;
+    abstract get id(): number;
+    get state(): string;
+    set state(state: string);
+    abstract get exitedAfterDisconnect(): boolean;
+    abstract get exitCode(): number;
+    get disableRefork(): boolean;
+    set disableRefork(disableRefork: boolean);
+    get isDevReload(): boolean;
+    set isDevReload(status: boolean);
+    abstract send(data: MessageBody): void;
+    clean(): void;
+    static on(..._args: any[]): void;
+    static send(_message: MessageBody): void;
+    static kill(): void;
+    static gracefulExit(_options: any): void;
+}
+type LogFun = (msg: any, ...args: any[]) => void;
+export declare abstract class BaseAppUtils extends EventEmitter {
+    options: MasterOptions;
+    protected messenger: Messenger;
+    protected log: LogFun;
+    protected logger: Logger;
+    protected isProduction: boolean;
+    startTime: number;
+    startSuccessCount: number;
+    isAllWorkerStarted: boolean;
+    constructor(options: MasterOptions, { log, logger, messenger, isProduction, }: {
+        log: LogFun;
+        logger: Logger;
+        messenger: Messenger;
+        isProduction: boolean;
+    });
+    getAppWorkerFile(): string;
+    fork(): void;
+    abstract kill(timeout: number): Promise<void>;
+}
+export {};

package/dist/esm/utils/mode/base/app.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { getSrcDirname } from '../../../dirname.js';
+export class BaseAppWorker {
+    instance;
+    #isDevReload;
+    #state;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    get state() {
+        return this.#state;
+    }
+    set state(state) {
+        this.#state = state;
+    }
+    get disableRefork() {
+        return Reflect.get(this.instance, 'disableRefork');
+    }
+    set disableRefork(disableRefork) {
+        Reflect.set(this.instance, 'disableRefork', disableRefork);
+    }
+    get isDevReload() {
+        return this.#isDevReload;
+    }
+    set isDevReload(status) {
+        this.#isDevReload = status;
+    }
+    clean() {
+        throw new Error('BaseAppWorker should implement clean.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static on(..._args) {
+        throw new Error('BaseAppWorker should implement on.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static send(_message) {
+        throw new Error('BaseAgentWorker should implement send.');
+    }
+    static kill() {
+        throw new Error('BaseAppWorker should implement kill.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static gracefulExit(_options) {
+        throw new Error('BaseAgentWorker should implement gracefulExit.');
+    }
+}
+export class BaseAppUtils extends EventEmitter {
+    options;
+    messenger;
+    log;
+    logger;
+    isProduction;
+    // public attrs
+    startTime = 0;
+    startSuccessCount = 0;
+    isAllWorkerStarted = false;
+    constructor(options, { log, logger, messenger, isProduction, }) {
+        super();
+        this.options = options;
+        this.log = log;
+        this.logger = logger;
+        this.messenger = messenger;
+        this.isProduction = isProduction;
+    }
+    getAppWorkerFile() {
+        return path.join(getSrcDirname(), 'app_worker.js');
+    }
+    fork() {
+        throw new Error('BaseApp should implement fork.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,102 @@
+import { fork } from 'node:child_process';
+import { sendmessage } from 'sendmessage';
+import { graceful as gracefulExit } from 'graceful-process';
+import { BaseAgentWorker, BaseAgentUtils } from '../../base/agent.js';
+import { terminate } from '../../../terminate.js';
+import { ClusterAgentWorkerError } from '../../../../error/ClusterAgentWorkerError.js';
+export class AgentProcessWorker extends BaseAgentWorker {
+    get workerId() {
+        return this.instance.pid;
+    }
+    send(message) {
+        sendmessage(this.instance, message);
+    }
+    static send(message) {
+        process.send(message);
+    }
+    static kill() {
+        process.exitCode = 1;
+        process.kill(process.pid);
+    }
+    static gracefulExit(options) {
+        gracefulExit(options);
+    }
+}
+export class AgentProcessUtils extends BaseAgentUtils {
+    #agentProcess;
+    #id = 0;
+    instance;
+    fork() {
+        this.startTime = Date.now();
+        const args = [JSON.stringify(this.options)];
+        const forkOptions = {};
+        if (process.platform === 'win32') {
+            forkOptions.windowsHide = true;
+        }
+        // add debug execArgv
+        const debugPort = process.env.EGG_AGENT_DEBUG_PORT ?? 5800;
+        if (this.options.isDebug) {
+            forkOptions.execArgv = process.execArgv.concat([`--inspect-port=${debugPort}`]);
+        }
+        const agentProcess = this.#agentProcess = fork(this.getAgentWorkerFile(), args, forkOptions);
+        const agentWorker = this.instance = new AgentProcessWorker(agentProcess);
+        agentWorker.status = 'starting';
+        agentWorker.id = ++this.#id;
+        this.emit('agent_forked', agentWorker);
+        this.log('[master] agent_worker#%s:%s start with clusterPort:%s', agentWorker.id, agentWorker.workerId, this.options.clusterPort);
+        // send debug message
+        if (this.options.isDebug) {
+            this.messenger.send({
+                to: 'parent',
+                from: 'agent',
+                action: 'debug',
+                data: {
+                    debugPort,
+                    // keep compatibility, should use workerId instead
+                    pid: agentWorker.workerId,
+                    workerId: agentWorker.workerId,
+                },
+            });
+        }
+        // forwarding agent' message to messenger
+        agentProcess.on('message', (msg) => {
+            if (typeof msg === 'string') {
+                msg = {
+                    action: msg,
+                    data: msg,
+                };
+            }
+            msg.from = 'agent';
+            this.messenger.send(msg);
+        });
+        // logger error event
+        agentProcess.on('error', err => {
+            err.name = 'AgentWorkerError';
+            this.logger.error(new ClusterAgentWorkerError(agentWorker.id, agentWorker.workerId, agentWorker.status, err));
+        });
+        // agent exit message
+        agentProcess.once('exit', (code, signal) => {
+            this.messenger.send({
+                action: 'agent-exit',
+                data: {
+                    code,
+                    signal,
+                },
+                to: 'master',
+                from: 'agent',
+            });
+        });
+        return this;
+    }
+    clean() {
+        this.#agentProcess.removeAllListeners();
+    }
+    async kill(timeout) {
+        if (this.#agentProcess) {
+            this.log('[master] kill agent worker with signal SIGTERM');
+            this.clean();
+            await terminate(this.#agentProcess, timeout);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { type Worker as ClusterProcessWorker } from 'node:cluster';
+import { type Options as gracefulExitOptions } from 'graceful-process';
+import { BaseAppWorker, BaseAppUtils } from '../../base/app.js';
+import type { MessageBody } from '../../../messenger.js';
+export declare class AppProcessWorker extends BaseAppWorker<ClusterProcessWorker> {
+    get id(): number;
+    get workerId(): number;
+    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 AppProcessUtils extends BaseAppUtils {
+    fork(): this;
+    kill(timeout: number): Promise<void>;
+}