@eggjs/cluster 3.0.0-beta.0

package/dist/commonjs/master.js

@@ -0,0 +1,544 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Master = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const node_v8_1 = __importDefault(require("node:v8"));
+const node_util_1 = __importDefault(require("node:util"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+const get_ready_1 = require("get-ready");
+const detect_port_1 = require("detect-port");
+const cluster_reload_1 = require("cluster-reload");
+const egg_logger_1 = require("egg-logger");
+const utility_1 = require("utility");
+const terminal_link_1 = __importDefault(require("terminal-link"));
+const options_js_1 = require("./utils/options.js");
+const worker_manager_js_1 = require("./utils/worker_manager.js");
+const messenger_js_1 = require("./utils/messenger.js");
+const agent_js_1 = require("./utils/mode/impl/process/agent.js");
+const app_js_1 = require("./utils/mode/impl/process/app.js");
+const agent_js_2 = require("./utils/mode/impl/worker_threads/agent.js");
+const app_js_2 = require("./utils/mode/impl/worker_threads/app.js");
+const ClusterWorkerExceptionError_js_1 = require("./error/ClusterWorkerExceptionError.js");
+class Master extends get_ready_1.ReadyEventEmitter {
+    options;
+    isStarted = false;
+    workerManager;
+    messenger;
+    isProduction;
+    agentWorkerIndex = 0;
+    closed = false;
+    logger;
+    agentWorker;
+    appWorker;
+    #logMethod;
+    #realPort;
+    #protocol;
+    #appAddress;
+    constructor(options) {
+        super();
+        this.#start(options)
+            .catch(err => {
+            this.ready(err);
+        });
+    }
+    async #start(options) {
+        this.options = await (0, options_js_1.parseOptions)(options);
+        this.workerManager = new worker_manager_js_1.WorkerManager();
+        this.messenger = new messenger_js_1.Messenger(this, this.workerManager);
+        this.isProduction = isProduction(this.options);
+        this.#realPort = this.options.port;
+        this.#protocol = this.options.https ? 'https' : 'http';
+        // app started or not
+        this.isStarted = false;
+        this.logger = new egg_logger_1.EggConsoleLogger({ level: process.env.EGG_MASTER_LOGGER_LEVEL ?? 'INFO' });
+        this.#logMethod = 'info';
+        if (this.options.env === 'local' || process.env.NODE_ENV === 'development') {
+            this.#logMethod = 'debug';
+        }
+        // get the real framework info
+        const frameworkPath = this.options.framework;
+        const frameworkPkg = (0, utility_1.readJSONSync)(node_path_1.default.join(frameworkPath, 'package.json'));
+        // set app & agent worker impl
+        if (this.options.startMode === 'worker_threads') {
+            this.startByWorkerThreads();
+        }
+        else {
+            this.startByProcess();
+        }
+        this.log(`[master] =================== ${frameworkPkg.name} start =====================`);
+        this.logger.info(`[master] node version ${process.version}`);
+        /* istanbul ignore next */
+        if ('alinode' in process) {
+            this.logger.info(`[master] alinode version ${process.alinode}`);
+        }
+        this.logger.info(`[master] ${frameworkPkg.name} version ${frameworkPkg.version}`);
+        if (this.isProduction) {
+            this.logger.info('[master] start with options:%s%s', node_os_1.default.EOL, JSON.stringify(this.options, null, 2));
+        }
+        else {
+            this.log('[master] start with options: %j', this.options);
+        }
+        this.log('[master] start with env: isProduction: %s, EGG_SERVER_ENV: %s, NODE_ENV: %s', this.isProduction, this.options.env, process.env.NODE_ENV);
+        const startTime = Date.now();
+        this.ready(() => {
+            this.isStarted = true;
+            const stickyMsg = this.options.sticky ? ' with STICKY MODE!' : '';
+            const startedURL = (0, terminal_link_1.default)(this.#appAddress, this.#appAddress, { fallback: false });
+            this.logger.info('[master] %s started on %s (%sms)%s', frameworkPkg.name, startedURL, Date.now() - startTime, stickyMsg);
+            if (this.options.debugPort) {
+                const url = getAddress({
+                    port: this.options.debugPort,
+                    protocol: 'http',
+                });
+                const debugPortURL = (0, terminal_link_1.default)(url, url, { fallback: false });
+                this.logger.info('[master] %s started debug port on %s', frameworkPkg.name, debugPortURL);
+            }
+            const action = 'egg-ready';
+            this.messenger.send({
+                action,
+                to: 'parent',
+                data: {
+                    port: this.#realPort,
+                    debugPort: this.options.debugPort,
+                    address: this.#appAddress,
+                    protocol: this.#protocol,
+                },
+            });
+            this.messenger.send({
+                action,
+                to: 'app',
+                data: this.options,
+            });
+            this.messenger.send({
+                action,
+                to: 'agent',
+                data: this.options,
+            });
+            // start check agent and worker status
+            if (this.isProduction) {
+                this.workerManager.startCheck();
+            }
+        });
+        this.on('agent-exit', this.onAgentExit.bind(this));
+        this.on('agent-start', this.onAgentStart.bind(this));
+        this.on('app-exit', this.onAppExit.bind(this));
+        this.on('app-start', this.onAppStart.bind(this));
+        this.on('reload-worker', this.onReload.bind(this));
+        // fork app workers after agent started
+        this.once('agent-start', this.forkAppWorkers.bind(this));
+        // get the real port from options and app.config
+        // app worker will send after loading
+        this.on('realport', ({ port, protocol }) => {
+            if (port) {
+                this.#realPort = port;
+            }
+            if (protocol) {
+                this.#protocol = protocol;
+            }
+        });
+        // https://nodejs.org/api/process.html#process_signal_events
+        // https://en.wikipedia.org/wiki/Unix_signal
+        // kill(2) Ctrl-C
+        process.once('SIGINT', this.onSignal.bind(this, 'SIGINT'));
+        // kill(3) Ctrl-\
+        process.once('SIGQUIT', this.onSignal.bind(this, 'SIGQUIT'));
+        // kill(15) default
+        process.once('SIGTERM', this.onSignal.bind(this, 'SIGTERM'));
+        process.once('exit', this.onExit.bind(this));
+        // write pid to file if provided
+        if (this.options.pidFile) {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(this.options.pidFile), { recursive: true });
+            node_fs_1.default.writeFileSync(this.options.pidFile, process.pid.toString(), 'utf-8');
+        }
+        this.detectPorts()
+            .then(() => {
+            this.forkAgentWorker();
+        });
+        // exit when agent or worker exception
+        this.workerManager.on('exception', (count) => {
+            const err = new ClusterWorkerExceptionError_js_1.ClusterWorkerExceptionError(count.agent, count.worker);
+            this.logger.error(err);
+            process.exit(1);
+        });
+    }
+    startByProcess() {
+        this.agentWorker = new agent_js_1.AgentProcessUtils(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+        });
+        this.appWorker = new app_js_1.AppProcessUtils(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+            isProduction: this.isProduction,
+        });
+    }
+    startByWorkerThreads() {
+        this.agentWorker = new agent_js_2.AgentThreadUtils(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+        });
+        this.appWorker = new app_js_2.AppThreadUtils(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+            isProduction: this.isProduction,
+        });
+    }
+    async detectPorts() {
+        // Detect cluster client port
+        try {
+            const clusterPort = await (0, detect_port_1.detectPort)();
+            this.options.clusterPort = clusterPort;
+            // If sticky mode, detect worker port
+            if (this.options.sticky) {
+                const stickyWorkerPort = await (0, detect_port_1.detectPort)();
+                this.options.stickyWorkerPort = stickyWorkerPort;
+            }
+        }
+        catch (err) {
+            this.logger.error(err);
+            process.exit(1);
+        }
+    }
+    log(msg, ...args) {
+        this.logger[this.#logMethod](msg, ...args);
+    }
+    startMasterSocketServer(cb) {
+        // Create the outside facing server listening on our port.
+        node_net_1.default.createServer({
+            pauseOnConnect: true,
+        }, connection => {
+            // We received a connection and need to pass it to the appropriate
+            // worker. Get the worker for this connection's source IP and pass
+            // it the connection.
+            /* istanbul ignore next */
+            if (!connection.remoteAddress) {
+                // This will happen when a client sends an RST(which is set to 1) right
+                // after the three-way handshake to the server.
+                // Read https://en.wikipedia.org/wiki/TCP_reset_attack for more details.
+                connection.destroy();
+            }
+            else {
+                const worker = this.stickyWorker(connection.remoteAddress);
+                worker.instance.send('sticky-session:connection', connection);
+            }
+        }).listen(this.#realPort, cb);
+    }
+    stickyWorker(ip) {
+        const workerNumbers = this.options.workers;
+        const ws = this.workerManager.listWorkerIds();
+        let s = '';
+        for (let i = 0; i < ip.length; i++) {
+            if (!isNaN(parseInt(ip[i]))) {
+                s += ip[i];
+            }
+        }
+        const pid = ws[Number(s) % workerNumbers];
+        return this.workerManager.getWorker(pid);
+    }
+    forkAgentWorker() {
+        this.agentWorker.on('agent_forked', (agent) => {
+            this.workerManager.setAgent(agent);
+        });
+        this.agentWorker.fork();
+    }
+    forkAppWorkers() {
+        this.appWorker.on('worker_forked', (worker) => {
+            this.workerManager.setWorker(worker);
+        });
+        this.appWorker.fork();
+    }
+    /**
+     * 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} -
+     */
+    async killAgentWorker(timeout) {
+        await this.agentWorker.kill(timeout);
+    }
+    async killAppWorkers(timeout) {
+        await this.appWorker.kill(timeout);
+    }
+    /**
+     * Agent Worker exit handler
+     * Will exit during startup, and refork during running.
+     */
+    onAgentExit(data) {
+        if (this.closed)
+            return;
+        this.messenger.send({
+            action: 'egg-pids',
+            to: 'app',
+            data: [],
+        });
+        const agentWorker = this.agentWorker;
+        this.workerManager.deleteAgent();
+        const err = new Error(node_util_1.default.format('[master] agent_worker#%s:%s died (code: %s, signal: %s)', agentWorker.instance.id, agentWorker.instance.workerId, data.code, data.signal));
+        err.name = 'AgentWorkerDiedError';
+        this.logger.error(err);
+        // remove all listeners to avoid memory leak
+        agentWorker.clean();
+        if (this.isStarted) {
+            this.log('[master] try to start a new agent_worker after 1s ...');
+            setTimeout(() => {
+                this.logger.info('[master] new agent_worker starting...');
+                this.forkAgentWorker();
+            }, 1000);
+            this.messenger.send({
+                action: 'agent-worker-died',
+                to: 'parent',
+            });
+        }
+        else {
+            this.logger.error('[master] agent_worker#%s:%s start fail, exiting with code:1', agentWorker.instance.id, agentWorker.instance.workerId);
+            process.exit(1);
+        }
+    }
+    onAgentStart() {
+        this.agentWorker.instance.status = 'started';
+        // Send egg-ready when agent is started after launched
+        if (this.appWorker.isAllWorkerStarted) {
+            this.messenger.send({
+                action: 'egg-ready',
+                to: 'agent',
+                data: this.options,
+            });
+        }
+        this.messenger.send({
+            action: 'egg-pids',
+            to: 'app',
+            data: [this.agentWorker.instance.workerId],
+        });
+        // should send current worker pids when agent restart
+        if (this.isStarted) {
+            this.messenger.send({
+                action: 'egg-pids',
+                to: 'agent',
+                data: this.workerManager.getListeningWorkerIds(),
+            });
+        }
+        this.messenger.send({
+            action: 'agent-start',
+            to: 'app',
+        });
+        this.logger.info('[master] agent_worker#%s:%s started (%sms)', this.agentWorker.instance.id, this.agentWorker.instance.workerId, Date.now() - this.agentWorker.startTime);
+    }
+    /**
+     * App Worker exit handler
+     */
+    onAppExit(data) {
+        if (this.closed)
+            return;
+        const worker = this.workerManager.getWorker(data.workerId);
+        if (!worker.isDevReload) {
+            const signal = data.signal;
+            const message = node_util_1.default.format('[master] app_worker#%s:%s died (code: %s, signal: %s, suicide: %s, state: %s), current workers: %j', worker.id, worker.workerId, worker.exitCode, signal, worker.exitedAfterDisconnect, worker.state, this.workerManager.listWorkerIds());
+            if (this.options.isDebug && signal === 'SIGKILL') {
+                // exit if died during debug
+                this.logger.error(message);
+                this.logger.error('[master] worker kill by debugger, exiting...');
+                setTimeout(() => this.close(), 10);
+            }
+            else {
+                const err = new Error(message);
+                err.name = 'AppWorkerDiedError';
+                this.logger.error(err);
+            }
+        }
+        // remove all listeners to avoid memory leak
+        worker.clean();
+        this.workerManager.deleteWorker(data.workerId);
+        // send message to agent with alive workers
+        this.messenger.send({
+            action: 'egg-pids',
+            to: 'agent',
+            data: this.workerManager.getListeningWorkerIds(),
+        });
+        if (this.appWorker.isAllWorkerStarted) {
+            // cfork will only refork at production mode
+            this.messenger.send({
+                action: 'app-worker-died',
+                to: 'parent',
+            });
+        }
+        else {
+            // exit if died during startup
+            this.logger.error('[master] app_worker#%s:%s start fail, exiting with code:1', worker.id, worker.workerId);
+            process.exit(1);
+        }
+    }
+    /**
+     * after app worker
+     */
+    onAppStart(data) {
+        const address = data.address;
+        // worker should listen stickyWorkerPort when sticky mode
+        if (this.options.sticky) {
+            if (String(address.port) !== String(this.options.stickyWorkerPort)) {
+                return;
+            }
+            // worker should listen REALPORT when not sticky mode
+        }
+        else if (this.options.startMode !== 'worker_threads' &&
+            !isUnixSock(address) &&
+            (String(address.port) !== String(this.#realPort))) {
+            return;
+        }
+        // send message to agent with alive workers
+        this.messenger.send({
+            action: 'egg-pids',
+            to: 'agent',
+            data: this.workerManager.getListeningWorkerIds(),
+        });
+        this.appWorker.startSuccessCount++;
+        const worker = this.workerManager.getWorker(data.workerId);
+        const remain = this.appWorker.isAllWorkerStarted ? 0 : this.options.workers - this.appWorker.startSuccessCount;
+        this.log('[master] app_worker#%s:%s started at %s, remain %s (%sms)', worker.id, worker.workerId, address.port, remain, Date.now() - this.appWorker.startTime);
+        // Send egg-ready when app is started after launched
+        if (this.appWorker.isAllWorkerStarted) {
+            this.messenger.send({
+                action: 'egg-ready',
+                to: 'app',
+                data: this.options,
+            });
+        }
+        // if app is started, it should enable this worker
+        if (this.appWorker.isAllWorkerStarted) {
+            worker.disableRefork = false;
+        }
+        if (this.appWorker.isAllWorkerStarted || this.appWorker.startSuccessCount < this.options.workers) {
+            return;
+        }
+        this.appWorker.isAllWorkerStarted = true;
+        // enable all workers when app started
+        for (const worker of this.workerManager.listWorkers()) {
+            worker.disableRefork = false;
+        }
+        address.protocol = this.#protocol;
+        address.port = this.options.sticky ? this.#realPort : address.port;
+        this.#appAddress = getAddress(address);
+        if (this.options.sticky) {
+            this.startMasterSocketServer(err => {
+                if (err) {
+                    return this.ready(err);
+                }
+                this.ready(true);
+            });
+        }
+        else {
+            this.ready(true);
+        }
+    }
+    /**
+     * master exit handler
+     */
+    onExit(code) {
+        if (this.options.pidFile && node_fs_1.default.existsSync(this.options.pidFile)) {
+            try {
+                node_fs_1.default.unlinkSync(this.options.pidFile);
+            }
+            catch (err) {
+                /* istanbul ignore next */
+                this.logger.error('[master] delete pidFile %s fail with %s', this.options.pidFile, err.message);
+            }
+        }
+        // istanbul can't cover here
+        // https://github.com/gotwarlost/istanbul/issues/567
+        const level = code === 0 ? 'info' : 'error';
+        this.logger[level]('[master] exit with code:%s', code);
+    }
+    onSignal(signal) {
+        if (this.closed)
+            return;
+        this.logger.info('[master] master is killed by signal %s, closing', signal);
+        // logger more info
+        const { used_heap_size, heap_size_limit } = node_v8_1.default.getHeapStatistics();
+        this.logger.info('[master] system memory: total %s, free %s', node_os_1.default.totalmem(), node_os_1.default.freemem());
+        this.logger.info('[master] process info: heap_limit %s, heap_used %s', heap_size_limit, used_heap_size);
+        this.close();
+    }
+    /**
+     * reload workers, for develop purpose
+     */
+    onReload() {
+        this.log('[master] reload %s workers...', this.options.workers);
+        for (const worker of this.workerManager.listWorkers()) {
+            worker.isDevReload = true;
+        }
+        (0, cluster_reload_1.reload)(this.options.workers);
+    }
+    async close() {
+        this.closed = true;
+        try {
+            await this._doClose();
+            this.log('[master] close done, exiting with code:0');
+            process.exit(0);
+        }
+        catch (e) {
+            this.logger.error('[master] close with error: ', e);
+            process.exit(1);
+        }
+    }
+    async _doClose() {
+        // kill app workers
+        // kill agent worker
+        // exit itself
+        const legacyTimeout = process.env.EGG_MASTER_CLOSE_TIMEOUT || '5000';
+        const appTimeout = parseInt(process.env.EGG_APP_CLOSE_TIMEOUT || legacyTimeout);
+        const agentTimeout = parseInt(process.env.EGG_AGENT_CLOSE_TIMEOUT || legacyTimeout);
+        this.logger.info('[master] send kill SIGTERM to app workers, will exit with code:0 after %sms', appTimeout);
+        this.logger.info('[master] wait %sms', appTimeout);
+        try {
+            await this.killAppWorkers(appTimeout);
+        }
+        catch (e) {
+            this.logger.error('[master] app workers exit error: ', e);
+        }
+        this.logger.info('[master] send kill SIGTERM to agent worker, will exit with code:0 after %sms', agentTimeout);
+        this.logger.info('[master] wait %sms', agentTimeout);
+        try {
+            await this.killAgentWorker(agentTimeout);
+        }
+        catch (e) /* istanbul ignore next */ {
+            this.logger.error('[master] agent worker exit error: ', e);
+        }
+    }
+}
+exports.Master = Master;
+function isProduction(options) {
+    if (options.env) {
+        return options.env !== 'local' && options.env !== 'unittest';
+    }
+    return process.env.NODE_ENV === 'production';
+}
+function getAddress({ addressType, address, port, protocol, }) {
+    // unix sock
+    // https://nodejs.org/api/cluster.html#cluster_event_listening_1
+    if (addressType === -1) {
+        return address;
+    }
+    let hostname = address;
+    if (!hostname && process.env.HOST && process.env.HOST !== '0.0.0.0') {
+        hostname = process.env.HOST;
+    }
+    if (!hostname) {
+        hostname = '127.0.0.1';
+    }
+    return `${protocol}://${hostname}:${port}`;
+}
+function isUnixSock(address) {
+    return address.addressType === -1;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"master.js","sourceRoot":"","sources":["../../src/master.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,87 @@
+import type { Master } from '../master.js';
+import type { WorkerManager } from './worker_manager.js';
+export type MessageCharacter = 'agent' | 'app' | 'master' | 'parent';
+export interface MessageBody {
+    action: string;
+    data?: unknown;
+    to?: MessageCharacter;
+    from?: MessageCharacter;
+    receiverPid?: 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;
+}