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

package/dist/master.js

@@ -0,0 +1,553 @@
+import os from 'node:os';
+import v8 from 'node:v8';
+import util from 'node:util';
+import path from 'node:path';
+import fs from 'node:fs';
+import net from 'node:net';
+import { debuglog } from 'node:util';
+import { ReadyEventEmitter } from 'get-ready';
+import { detectPort } from 'detect-port';
+import { reload } from 'cluster-reload';
+import { EggConsoleLogger as ConsoleLogger } from 'egg-logger';
+import { readJSONSync } from 'utility';
+import terminalLink from 'terminal-link';
+import { parseOptions } from "./utils/options.js";
+import { WorkerManager } from "./utils/worker_manager.js";
+import { Messenger } from "./utils/messenger.js";
+import { AgentProcessWorker, AgentProcessUtils as ProcessAgentWorker } from "./utils/mode/impl/process/agent.js";
+import { AppProcessWorker, AppProcessUtils as ProcessAppWorker } from "./utils/mode/impl/process/app.js";
+import { AgentThreadWorker, AgentThreadUtils as WorkerThreadsAgentWorker, } from "./utils/mode/impl/worker_threads/agent.js";
+import { AppThreadWorker, AppThreadUtils as WorkerThreadsAppWorker } from "./utils/mode/impl/worker_threads/app.js";
+import { ClusterWorkerExceptionError } from "./error/ClusterWorkerExceptionError.js";
+const debug = debuglog('egg/cluster/master');
+export class Master extends 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 parseOptions(options);
+        this.workerManager = new WorkerManager();
+        this.messenger = new 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 ConsoleLogger({ 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 = readJSONSync(path.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', os.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 = terminalLink(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 = terminalLink(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 }) => {
+            // this.logger.info('[master] got realport: %s, protocol: %s', 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) {
+            fs.mkdirSync(path.dirname(this.options.pidFile), { recursive: true });
+            fs.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(count.agent, count.worker);
+            this.logger.error(err);
+            process.exit(1);
+        });
+    }
+    startByProcess() {
+        this.agentWorker = new ProcessAgentWorker(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+        });
+        this.appWorker = new ProcessAppWorker(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+            isProduction: this.isProduction,
+        });
+    }
+    startByWorkerThreads() {
+        this.agentWorker = new WorkerThreadsAgentWorker(this.options, {
+            log: this.log.bind(this),
+            logger: this.logger,
+            messenger: this.messenger,
+        });
+        this.appWorker = new WorkerThreadsAppWorker(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 detectPort();
+            this.options.clusterPort = clusterPort;
+            // If sticky mode, detect worker port
+            if (this.options.sticky) {
+                const stickyWorkerPort = await 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.
+        net
+            .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(util.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 = util.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 worker = this.workerManager.getWorker(data.workerId);
+        debug('got app_worker#%s:%s app-start event, data: %j', worker.id, worker.workerId, 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;
+        }
+        worker.state = 'listening';
+        // send message to agent with alive workers
+        this.messenger.send({
+            action: 'egg-pids',
+            to: 'agent',
+            data: this.workerManager.getListeningWorkerIds(),
+        });
+        // send message to app with current agent worker id
+        this.messenger.send({
+            action: 'egg-pids',
+            to: 'app',
+            data: [this.agentWorker.instance.workerId],
+            receiverWorkerId: String(worker.workerId),
+            receiverPid: String(worker.workerId),
+        });
+        this.appWorker.startSuccessCount++;
+        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 && fs.existsSync(this.options.pidFile)) {
+            try {
+                fs.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 } = v8.getHeapStatistics();
+        this.logger.info('[master] system memory: total %s, free %s', os.totalmem(), os.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;
+        }
+        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);
+        }
+    }
+}
+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;
+    }
+    // {"address":"::","family":"IPv6","port":17001}
+    if (address === '::') {
+        address = '';
+    }
+    if (!address && process.env.HOST && process.env.HOST !== '0.0.0.0') {
+        address = process.env.HOST;
+    }
+    if (!address) {
+        address = '127.0.0.1';
+    }
+    return `${protocol}://${address}:${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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"}