@eggjs/cluster 3.0.0-beta.0

package/dist/commonjs/utils/terminate.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminate = terminate;
+const node_util_1 = require("node:util");
+const promises_1 = require("node:timers/promises");
+const node_events_1 = require("node:events");
+const ps_tree_1 = require("@fengmk2/ps-tree");
+const debug = (0, node_util_1.debuglog)('@eggjs/cluster/utils/terminate');
+async function terminate(subProcess, timeout) {
+    const pid = subProcess.process?.pid ?? subProcess.pid;
+    const childPids = await getChildPids(pid);
+    await Promise.all([
+        killProcess(subProcess, timeout),
+        killChildren(childPids, timeout),
+    ]);
+}
+// kill process, if SIGTERM not work, try SIGKILL
+async function killProcess(subProcess, timeout) {
+    // https://github.com/nodejs/node/pull/34312
+    (subProcess.process ?? subProcess).kill('SIGTERM');
+    await Promise.race([
+        (0, node_events_1.once)(subProcess, 'exit'),
+        (0, promises_1.setTimeout)(timeout),
+    ]);
+    if (subProcess.killed) {
+        return;
+    }
+    // SIGKILL: http://man7.org/linux/man-pages/man7/signal.7.html
+    // worker: https://github.com/nodejs/node/blob/master/lib/internal/cluster/worker.js#L22
+    // subProcess.kill is wrapped to subProcess.destroy, it will wait to disconnected.
+    (subProcess.process ?? subProcess).kill('SIGKILL');
+}
+// kill all children processes, if SIGTERM not work, try SIGKILL
+async function killChildren(childrenPids, timeout) {
+    if (childrenPids.length === 0) {
+        return;
+    }
+    kill(childrenPids, 'SIGTERM');
+    const start = Date.now();
+    // if timeout is 1000, it will check twice.
+    const checkInterval = 400;
+    let unterminated = [];
+    while (Date.now() - start < timeout - checkInterval) {
+        await (0, promises_1.setTimeout)(checkInterval);
+        unterminated = getUnterminatedProcesses(childrenPids);
+        if (unterminated.length === 0) {
+            return;
+        }
+    }
+    kill(unterminated, 'SIGKILL');
+}
+async function getChildPids(pid) {
+    let childrenPids = [];
+    try {
+        const children = await (0, ps_tree_1.pstree)(pid);
+        childrenPids = children.map(c => parseInt(c.PID));
+    }
+    catch (err) {
+        // if get children error, just ignore it
+        debug('pstree %s error: %s, ignore it', pid, err);
+    }
+    return childrenPids;
+}
+function kill(pids, signal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch (err) {
+            // ignore
+            debug('kill %s error: %s, signal: %s, ignore it', pid, err, signal);
+        }
+    }
+}
+function getUnterminatedProcesses(pids) {
+    return pids.filter(pid => {
+        try {
+            // success means it's still alive
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            // error means it's dead
+            debug('kill %s error: %s, it still alive', pid, err);
+            return false;
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/utils/worker_manager.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'node:events';
+import { BaseAgentWorker } from './mode/base/agent.js';
+import { BaseAppWorker } from './mode/base/app.js';
+export declare class WorkerManager extends EventEmitter {
+    agent: BaseAgentWorker | null;
+    workers: Map<number, BaseAppWorker<import("worker_threads").Worker | import("cluster").Worker>>;
+    exception: number;
+    timer: NodeJS.Timeout;
+    constructor();
+    getWorkers(): number[];
+    setAgent(agent: BaseAgentWorker): void;
+    getAgent(): BaseAgentWorker<import("child_process").ChildProcess | import("worker_threads").Worker> | null;
+    deleteAgent(): void;
+    setWorker(worker: BaseAppWorker): void;
+    getWorker(workerId: number): BaseAppWorker<import("worker_threads").Worker | import("cluster").Worker> | undefined;
+    deleteWorker(workerId: number): void;
+    listWorkerIds(): number[];
+    listWorkers(): BaseAppWorker<import("worker_threads").Worker | import("cluster").Worker>[];
+    getListeningWorkerIds(): number[];
+    count(): {
+        agent: number;
+        worker: number;
+    };
+    startCheck(): void;
+}

package/dist/commonjs/utils/worker_manager.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerManager = void 0;
+const node_events_1 = require("node:events");
+// worker manager to record agent and worker forked by egg-cluster
+// can do some check stuff here to monitor the healthy
+class WorkerManager extends node_events_1.EventEmitter {
+    agent;
+    workers = new Map();
+    exception = 0;
+    timer;
+    constructor() {
+        super();
+        this.agent = null;
+    }
+    getWorkers() {
+        return Array.from(this.workers.keys());
+    }
+    setAgent(agent) {
+        this.agent = agent;
+    }
+    getAgent() {
+        return this.agent;
+    }
+    deleteAgent() {
+        this.agent = null;
+    }
+    setWorker(worker) {
+        this.workers.set(worker.workerId, worker);
+    }
+    getWorker(workerId) {
+        return this.workers.get(workerId);
+    }
+    deleteWorker(workerId) {
+        this.workers.delete(workerId);
+    }
+    listWorkerIds() {
+        return Array.from(this.workers.keys());
+    }
+    listWorkers() {
+        return Array.from(this.workers.values());
+    }
+    getListeningWorkerIds() {
+        const keys = [];
+        for (const [id, worker] of this.workers.entries()) {
+            if (worker.state === 'listening') {
+                keys.push(id);
+            }
+        }
+        return keys;
+    }
+    count() {
+        return {
+            agent: this.agent?.status === 'started' ? 1 : 0,
+            worker: this.listWorkerIds().length,
+        };
+    }
+    // check agent and worker must both alive
+    // if exception appear 3 times, emit an exception event
+    startCheck() {
+        this.timer = setInterval(() => {
+            const count = this.count();
+            if (count.agent > 0 && count.worker > 0) {
+                this.exception = 0;
+                return;
+            }
+            this.exception++;
+            if (this.exception >= 3) {
+                this.emit('exception', count);
+                clearInterval(this.timer);
+            }
+        }, 10000);
+    }
+}
+exports.WorkerManager = WorkerManager;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/agent_worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/agent_worker.js

@@ -0,0 +1,63 @@
+import { debuglog } from 'node:util';
+import { EggConsoleLogger as ConsoleLogger } from 'egg-logger';
+import { importModule } from '@eggjs/utils';
+import { AgentThreadWorker } from './utils/mode/impl/worker_threads/agent.js';
+import { AgentProcessWorker } from './utils/mode/impl/process/agent.js';
+const debug = debuglog('@eggjs/cluster/agent_worker');
+/**
+ * agent worker is child_process forked by master.
+ *
+ * agent worker only exit in two cases:
+ *  - receive signal SIGTERM, exit code 0 (exit gracefully)
+ *  - receive disconnect event, exit code 110 (maybe master exit in accident)
+ */
+async function main() {
+    // $ node agent_worker.js options
+    const options = JSON.parse(process.argv[2]);
+    if (options.require) {
+        // inject
+        options.require.forEach(mod => {
+            require(mod);
+        });
+    }
+    let AgentWorker;
+    if (options.startMode === 'worker_threads') {
+        AgentWorker = AgentThreadWorker;
+    }
+    else {
+        AgentWorker = AgentProcessWorker;
+    }
+    const consoleLogger = new ConsoleLogger({ level: process.env.EGG_AGENT_WORKER_LOGGER_LEVEL });
+    const { Agent } = await importModule(options.framework);
+    debug('new Agent with options %j', options);
+    let agent;
+    try {
+        agent = new Agent(options);
+    }
+    catch (err) {
+        consoleLogger.error(err);
+        throw err;
+    }
+    function startErrorHandler(err) {
+        consoleLogger.error(err);
+        consoleLogger.error('[agent_worker] start error, exiting with code:1');
+        AgentWorker.kill();
+    }
+    agent.ready((err) => {
+        // don't send started message to master when start error
+        if (err) {
+            return;
+        }
+        agent.removeListener('error', startErrorHandler);
+        AgentWorker.send({ action: 'agent-start', to: 'master' });
+    });
+    // exit if agent start error
+    agent.once('error', startErrorHandler);
+    AgentWorker.gracefulExit({
+        logger: consoleLogger,
+        label: 'agent_worker',
+        beforeExit: () => agent.close(),
+    });
+}
+main();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/app_worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/app_worker.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import { createServer as createHttpServer } from 'node:http';
+import { createServer as createHttpsServer } from 'node:https';
+import { debuglog } from 'node:util';
+import { EggConsoleLogger as ConsoleLogger } from 'egg-logger';
+import { importModule } from '@eggjs/utils';
+import { AppThreadWorker } from './utils/mode/impl/worker_threads/app.js';
+import { AppProcessWorker } from './utils/mode/impl/process/app.js';
+const debug = debuglog('@eggjs/cluster/app_worker');
+async function main() {
+    // $ node app_worker.js options-json-string
+    const options = JSON.parse(process.argv[2]);
+    if (options.require) {
+        // inject
+        for (const mod of options.require) {
+            await importModule(mod);
+        }
+    }
+    let AppWorker;
+    if (options.startMode === 'worker_threads') {
+        AppWorker = AppThreadWorker;
+    }
+    else {
+        AppWorker = AppProcessWorker;
+    }
+    const consoleLogger = new ConsoleLogger({
+        level: process.env.EGG_APP_WORKER_LOGGER_LEVEL,
+    });
+    const { Application } = await importModule(options.framework);
+    debug('new Application with options %j', options);
+    let app;
+    try {
+        app = new Application(options);
+    }
+    catch (err) {
+        consoleLogger.error(err);
+        throw err;
+    }
+    app.ready(startServer);
+    function exitProcess() {
+        // Use SIGTERM kill process, ensure trigger the gracefulExit
+        AppWorker.kill();
+    }
+    // exit if worker start timeout
+    app.once('startTimeout', startTimeoutHandler);
+    function startTimeoutHandler() {
+        consoleLogger.error('[app_worker] start timeout, exiting with code:1');
+        exitProcess();
+    }
+    function startServer(err) {
+        if (err) {
+            consoleLogger.error(err);
+            consoleLogger.error('[app_worker] start error, exiting with code:1');
+            exitProcess();
+            return;
+        }
+        const clusterConfig = app.config.cluster ?? {};
+        const listenConfig = clusterConfig.listen ?? {};
+        const httpsOptions = {
+            ...clusterConfig.https,
+            ...options.https,
+        };
+        const port = options.port = options.port ?? listenConfig.port;
+        const debugPort = options.debugPort;
+        const protocol = (httpsOptions.key && httpsOptions.cert) ? 'https' : 'http';
+        AppWorker.send({
+            to: 'master',
+            action: 'realport',
+            data: {
+                port,
+                protocol,
+            },
+        });
+        app.removeListener('startTimeout', startTimeoutHandler);
+        let server;
+        let debugPortServer;
+        // https config
+        if (protocol === 'https') {
+            httpsOptions.key = fs.readFileSync(httpsOptions.key);
+            httpsOptions.cert = fs.readFileSync(httpsOptions.cert);
+            httpsOptions.ca = httpsOptions.ca && fs.readFileSync(httpsOptions.ca);
+            server = createHttpsServer(httpsOptions, app.callback());
+            if (debugPort) {
+                debugPortServer = createHttpServer(app.callback());
+            }
+        }
+        else {
+            server = createHttpServer(app.callback());
+            if (debugPort) {
+                debugPortServer = server;
+            }
+        }
+        server.once('error', (err) => {
+            consoleLogger.error('[app_worker] server got error: %s, code: %s', err.message, err.code);
+            exitProcess();
+        });
+        // emit `server` event in app
+        app.emit('server', server);
+        if (options.sticky && options.stickyWorkerPort) {
+            server.listen(options.stickyWorkerPort, '127.0.0.1');
+            // Listen to messages was sent from the master. Ignore everything else.
+            AppWorker.on('message', (message, connection) => {
+                if (message !== 'sticky-session:connection') {
+                    return;
+                }
+                // Emulate a connection event on the server by emitting the
+                // event with the connection the master sent us.
+                server.emit('connection', connection);
+                connection.resume();
+            });
+        }
+        else {
+            if (listenConfig.path) {
+                server.listen(listenConfig.path);
+            }
+            else {
+                if (typeof port !== 'number') {
+                    consoleLogger.error('[app_worker] port should be number, but got %s(%s)', port, typeof port);
+                    exitProcess();
+                    return;
+                }
+                const args = [port];
+                if (listenConfig.hostname)
+                    args.push(listenConfig.hostname);
+                debug('listen options %s', args);
+                server.listen(...args);
+            }
+            if (debugPortServer) {
+                debug('listen on debug port: %s', debugPort);
+                debugPortServer.listen(debugPort);
+            }
+        }
+        AppWorker.send({
+            to: 'master',
+            action: 'listening',
+            data: server.address() || { port },
+        });
+    }
+    AppWorker.gracefulExit({
+        logger: consoleLogger,
+        label: 'app_worker',
+        beforeExit: () => app.close(),
+    });
+}
+main();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/dirname.d.ts

@@ -0,0 +1 @@
+export declare function getSrcDirname(): string;

package/dist/esm/dirname.js

@@ -0,0 +1,11 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+export function getSrcDirname() {
+    if (typeof __dirname !== 'undefined') {
+        return __dirname;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return path.dirname(fileURLToPath(import.meta.url));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlybmFtZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaXJuYW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDekMsT0FBTyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBRTdCLE1BQU0sVUFBVSxhQUFhO0lBQzNCLElBQUksT0FBTyxTQUFTLEtBQUssV0FBVyxFQUFFLENBQUM7UUFDckMsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUNELDZEQUE2RDtJQUM3RCxhQUFhO0lBQ2IsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFDdEQsQ0FBQyJ9

package/dist/esm/error/ClusterAgentWorkerError.d.ts

@@ -0,0 +1,10 @@
+export declare class ClusterAgentWorkerError extends Error {
+    id: number;
+    /**
+     * pid in process mode
+     * tid in worker_threads mode
+     */
+    workerId: number;
+    status: string;
+    constructor(id: number, workerId: number, status: string, error: Error);
+}

package/dist/esm/error/ClusterAgentWorkerError.js

@@ -0,0 +1,19 @@
+export class ClusterAgentWorkerError extends Error {
+    id;
+    /**
+     * pid in process mode
+     * tid in worker_threads mode
+     */
+    workerId;
+    status;
+    constructor(id, workerId, status, error) {
+        const message = `Got agent worker error: ${error.message}`;
+        super(message, { cause: error });
+        this.name = this.constructor.name;
+        this.id = id;
+        this.workerId = workerId;
+        this.status = status;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2x1c3RlckFnZW50V29ya2VyRXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXJyb3IvQ2x1c3RlckFnZW50V29ya2VyRXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLHVCQUF3QixTQUFRLEtBQUs7SUFDaEQsRUFBRSxDQUFTO0lBQ1g7OztPQUdHO0lBQ0gsUUFBUSxDQUFTO0lBQ2pCLE1BQU0sQ0FBUztJQUVmLFlBQVksRUFBVSxFQUFFLFFBQWdCLEVBQUUsTUFBYyxFQUFFLEtBQVk7UUFDcEUsTUFBTSxPQUFPLEdBQUcsMkJBQTJCLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUMzRCxLQUFLLENBQUMsT0FBTyxFQUFFLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7UUFDakMsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxJQUFJLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUNiLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1FBQ3JCLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ2xELENBQUM7Q0FDRiJ9

package/dist/esm/error/ClusterWorkerExceptionError.d.ts

@@ -0,0 +1,7 @@
+export declare class ClusterWorkerExceptionError extends Error {
+    count: {
+        agent: number;
+        worker: number;
+    };
+    constructor(agent: number, worker: number);
+}

package/dist/esm/error/ClusterWorkerExceptionError.js

@@ -0,0 +1,14 @@
+export class ClusterWorkerExceptionError extends Error {
+    count;
+    constructor(agent, worker) {
+        const message = `[master] ${agent} agent and ${worker} worker(s) alive, exit to avoid unknown state`;
+        super(message);
+        this.name = this.constructor.name;
+        this.count = {
+            agent,
+            worker,
+        };
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2x1c3RlcldvcmtlckV4Y2VwdGlvbkVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Vycm9yL0NsdXN0ZXJXb3JrZXJFeGNlcHRpb25FcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sMkJBQTRCLFNBQVEsS0FBSztJQUNwRCxLQUFLLENBR0g7SUFFRixZQUFZLEtBQWEsRUFBRSxNQUFjO1FBQ3ZDLE1BQU0sT0FBTyxHQUFHLFlBQVksS0FBSyxjQUFjLE1BQU0sK0NBQStDLENBQUM7UUFDckcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxJQUFJLENBQUMsS0FBSyxHQUFHO1lBQ1gsS0FBSztZQUNMLE1BQU07U0FDUCxDQUFDO1FBQ0YsS0FBSyxDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDbEQsQ0FBQztDQUNGIn0=

package/dist/esm/error/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ClusterAgentWorkerError.js';
+export * from './ClusterWorkerExceptionError.js';

package/dist/esm/error/index.js

@@ -0,0 +1,3 @@
+export * from './ClusterAgentWorkerError.js';
+export * from './ClusterWorkerExceptionError.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXJyb3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGtDQUFrQyxDQUFDIn0=

package/dist/esm/index.d.ts

@@ -0,0 +1,17 @@
+import { Master, MasterOptions } from './master.js';
+import { ClusterOptions, ClusterHTTPSSecureOptions, ClusterStartMode } from './utils/options.js';
+/**
+ * cluster start flow:
+ *
+ * [startCluster] -> master -> agent_worker -> new [Agent]       -> agentWorkerLoader
+ *                         `-> app_worker   -> new [Application] -> appWorkerLoader
+ *
+ */
+/**
+ * start egg app
+ * @function Egg#startCluster
+ * @param {Object} options {@link Master}
+ */
+export declare function startCluster(options: ClusterOptions): Promise<void>;
+export { Master, MasterOptions, ClusterOptions, ClusterHTTPSSecureOptions, ClusterStartMode, };
+export * from './error/index.js';

package/dist/esm/index.js

@@ -0,0 +1,19 @@
+import { Master } from './master.js';
+/**
+ * cluster start flow:
+ *
+ * [startCluster] -> master -> agent_worker -> new [Agent]       -> agentWorkerLoader
+ *                         `-> app_worker   -> new [Application] -> appWorkerLoader
+ *
+ */
+/**
+ * start egg app
+ * @function Egg#startCluster
+ * @param {Object} options {@link Master}
+ */
+export async function startCluster(options) {
+    await new Master(options).ready();
+}
+export { Master, };
+export * from './error/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBaUIsTUFBTSxhQUFhLENBQUM7QUFHcEQ7Ozs7OztHQU1HO0FBRUg7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsWUFBWSxDQUFDLE9BQXVCO0lBQ3hELE1BQU0sSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDcEMsQ0FBQztBQUVELE9BQU8sRUFDTCxNQUFNLEdBRVAsQ0FBQztBQUVGLGNBQWMsa0JBQWtCLENBQUMifQ==

package/dist/esm/master.d.ts

@@ -0,0 +1,90 @@
+import { ReadyEventEmitter } from 'get-ready';
+import { EggConsoleLogger as ConsoleLogger } from 'egg-logger';
+import { ClusterOptions, ParsedClusterOptions } from './utils/options.js';
+import { WorkerManager } from './utils/worker_manager.js';
+import { Messenger } from './utils/messenger.js';
+import { AgentProcessUtils as ProcessAgentWorker } from './utils/mode/impl/process/agent.js';
+import { AppProcessUtils as ProcessAppWorker } from './utils/mode/impl/process/app.js';
+import { AgentThreadUtils as WorkerThreadsAgentWorker } from './utils/mode/impl/worker_threads/agent.js';
+import { AppThreadUtils as WorkerThreadsAppWorker } from './utils/mode/impl/worker_threads/app.js';
+export interface MasterOptions extends ParsedClusterOptions {
+    clusterPort?: number;
+    stickyWorkerPort?: number;
+}
+export declare class Master extends ReadyEventEmitter {
+    #private;
+    options: MasterOptions;
+    isStarted: boolean;
+    workerManager: WorkerManager;
+    messenger: Messenger;
+    isProduction: boolean;
+    agentWorkerIndex: number;
+    closed: boolean;
+    logger: ConsoleLogger;
+    agentWorker: ProcessAgentWorker | WorkerThreadsAgentWorker;
+    appWorker: ProcessAppWorker | WorkerThreadsAppWorker;
+    constructor(options?: ClusterOptions);
+    startByProcess(): void;
+    startByWorkerThreads(): void;
+    detectPorts(): Promise<void>;
+    log(msg: string, ...args: any[]): void;
+    startMasterSocketServer(cb: (err?: Error) => void): void;
+    stickyWorker(ip: string): import("./utils/mode/base/app.js").BaseAppWorker<import("worker_threads").Worker | import("cluster").Worker>;
+    forkAgentWorker(): void;
+    forkAppWorkers(): void;
+    /**
+     * close agent worker, App Worker will closed by cluster
+     *
+     * https://www.exratione.com/2013/05/die-child-process-die/
+     * make sure Agent Worker exit before master exit
+     *
+     * @param {number} timeout - kill agent timeout
+     * @return {Promise} -
+     */
+    killAgentWorker(timeout: number): Promise<void>;
+    killAppWorkers(timeout: number): Promise<void>;
+    /**
+     * Agent Worker exit handler
+     * Will exit during startup, and refork during running.
+     */
+    onAgentExit(data: {
+        /** exit code */
+        code: number;
+        /** received signal */
+        signal: string;
+    }): void;
+    onAgentStart(): void;
+    /**
+     * App Worker exit handler
+     */
+    onAppExit(data: {
+        workerId: number;
+        code: number;
+        signal: string;
+    }): void;
+    /**
+     * after app worker
+     */
+    onAppStart(data: {
+        workerId: number;
+        address: ListeningAddress;
+    }): void;
+    /**
+     * master exit handler
+     */
+    onExit(code: number): void;
+    onSignal(signal: string): void;
+    /**
+     * reload workers, for develop purpose
+     */
+    onReload(): void;
+    close(): Promise<void>;
+    _doClose(): Promise<void>;
+}
+interface ListeningAddress {
+    port: number;
+    protocol: string;
+    address?: string;
+    addressType?: number;
+}
+export {};