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

package/dist/utils/messenger.d.ts

@@ -0,0 +1,92 @@
+import type { Master } from '../master.ts';
+import type { WorkerManager } from './worker_manager.ts';
+export type MessageCharacter = 'agent' | 'app' | 'master' | 'parent';
+export interface MessageBody {
+    action: string;
+    data?: unknown;
+    to?: MessageCharacter;
+    from?: MessageCharacter;
+    /**
+     * @deprecated Keep compatible, please use receiverWorkerId instead
+     */
+    receiverPid?: string;
+    receiverWorkerId?: string;
+    senderWorkerId?: string;
+}
+/**
+ * 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 declare class Messenger {
+    #private;
+    constructor(master: Master, workerManager: WorkerManager);
+    /**
+     * send message
+     * @param {Object} data message body
+     *  - {String} from from who
+     *  - {String} to to who
+     */
+    send(data: MessageBody): void;
+    /**
+     * send message to master self
+     * @param {Object} data message body
+     */
+    sendToMaster(data: MessageBody): void;
+    /**
+     * send message to parent process
+     * @param {Object} data message body
+     */
+    sendToParent(data: MessageBody): void;
+    /**
+     * send message to app worker
+     * @param {Object} data message body
+     */
+    sendToAppWorker(data: MessageBody): void;
+    /**
+     * send message to agent worker
+     * @param {Object} data message body
+     */
+    sendToAgentWorker(data: MessageBody): void;
+}

package/dist/utils/messenger.js

@@ -0,0 +1,179 @@
+import { debuglog } from 'node:util';
+import workerThreads from 'node:worker_threads';
+const debug = debuglog('egg/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 receiverWorkerId is to who
+        const receiverWorkerId = data.receiverWorkerId ?? data.receiverPid;
+        if (receiverWorkerId) {
+            if (receiverWorkerId === String(process.pid)) {
+                data.to = 'master';
+            }
+            else if (receiverWorkerId === 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) {
+        // e.g: master.on('app-start', 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 receiverWorkerId
+            const receiverWorkerId = data.receiverWorkerId ?? data.receiverPid;
+            if (receiverWorkerId && receiverWorkerId !== 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/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.ts';
+import type { MessageBody, Messenger } from '../../messenger.ts';
+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/utils/mode/base/agent.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+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() {
+        let agentWorkerFile = path.join(getSrcDirname(), 'agent_worker.js');
+        if (!existsSync(agentWorkerFile)) {
+            agentWorkerFile = path.join(getSrcDirname(), 'agent_worker.ts');
+        }
+        return agentWorkerFile;
+    }
+    fork() {
+        throw new Error('BaseAgent should implement fork.');
+    }
+    clean() {
+        throw new Error('BaseAgent should implement clean.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/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.ts';
+import type { MasterOptions } from '../../../master.ts';
+export declare abstract class BaseAppWorker<T = ThreadWorker | ClusterProcessWorker> {
+    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(isDevReload: boolean);
+    abstract send(data: MessageBody): void;
+    clean(): void;
+    static get workerId(): number;
+    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/utils/mode/base/app.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { EventEmitter } from 'node:events';
+import { getSrcDirname } from "../../../dirname.js";
+export class BaseAppWorker {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    get state() {
+        return Reflect.get(this.instance, 'state');
+    }
+    set state(state) {
+        Reflect.set(this.instance, 'state', state);
+    }
+    get disableRefork() {
+        return Reflect.get(this.instance, 'disableRefork');
+    }
+    set disableRefork(disableRefork) {
+        Reflect.set(this.instance, 'disableRefork', disableRefork);
+    }
+    get isDevReload() {
+        return Reflect.get(this.instance, 'isDevReload');
+    }
+    set isDevReload(isDevReload) {
+        Reflect.set(this.instance, 'isDevReload', isDevReload);
+    }
+    clean() {
+        throw new Error('BaseAppWorker should implement clean.');
+    }
+    // static methods use on src/app_worker.ts
+    static get workerId() {
+        throw new Error('BaseAppWorker should implement workerId.');
+    }
+    // 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() {
+        let appWorkerFile = path.join(getSrcDirname(), 'app_worker.js');
+        if (!existsSync(appWorkerFile)) {
+            appWorkerFile = path.join(getSrcDirname(), 'app_worker.ts');
+        }
+        return appWorkerFile;
+    }
+    fork() {
+        throw new Error('BaseApp should implement fork.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/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.ts';
+import type { MessageBody } from '../../../messenger.ts';
+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/utils/mode/impl/process/agent.js

@@ -0,0 +1,103 @@
+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) {
+        message.senderWorkerId = String(process.pid);
+        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/utils/mode/impl/process/app.d.ts

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