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

package/dist/index.js

@@ -1,8 +1,696 @@
-import "./utils/options.js";
-import { ClusterAgentWorkerError } from "./error/ClusterAgentWorkerError.js";
-import { ClusterWorkerExceptionError } from "./error/ClusterWorkerExceptionError.js";
-import { Master } from "./master.js";
+import "./terminate-w3g0oQgq.js";
+import { AgentProcessUtils, AgentThreadUtils, ClusterAgentWorkerError } from "./agent-griHEaCW.js";
+import { AppProcessUtils, AppThreadUtils } from "./app-5Was1vub.js";
+import os from "node:os";
+import v8 from "node:v8";
+import util, { debuglog } from "node:util";
+import path from "node:path";
+import fs from "node:fs";
+import net from "node:net";
+import { ReadyEventEmitter } from "get-ready";
+import { detectPort } from "detect-port";
+import { reload } from "cluster-reload";
+import { EggConsoleLogger } from "egg-logger";
+import { readJSONSync } from "utility";
+import terminalLink from "terminal-link";
+import assert from "node:assert";
+import { getFrameworkPath, importModule } from "@eggjs/utils";
+import { EventEmitter } from "node:events";
+import workerThreads from "node:worker_threads";
 
+//#region src/utils/options.ts
+const debug$2 = debuglog("egg/cluster/utils/options");
+async function parseOptions(options) {
+	options = {
+		baseDir: process.cwd(),
+		port: options?.https ? 8443 : void 0,
+		startMode: "process",
+		env: process.env.EGG_SERVER_ENV,
+		...options
+	};
+	const pkgPath = path.join(options.baseDir, "package.json");
+	assert(fs.existsSync(pkgPath), `${pkgPath} should exist`);
+	options.framework = getFrameworkPath({
+		baseDir: options.baseDir,
+		framework: options.framework ?? options.customEgg
+	});
+	debug$2("[parseOptions] %o", options);
+	const egg = await importModule(options.framework, { paths: [options.baseDir] });
+	assert(egg.Application, `should define Application in ${options.framework}`);
+	assert(egg.Agent, `should define Agent in ${options.framework}`);
+	if (options.https === true) {
+		console.warn("[@eggjs/cluster:deprecated] [master] Please use `https: { key, cert, ca }` instead of `https: true`");
+		options.https = {
+			key: options.key,
+			cert: options.cert
+		};
+	}
+	if (options.https) {
+		assert(options.https.key, "options.https.key should exists");
+		if (typeof options.https.key === "string") assert(fs.existsSync(options.https.key), "options.https.key file should exists");
+		assert(options.https.cert, "options.https.cert should exists");
+		if (typeof options.https.cert === "string") assert(fs.existsSync(options.https.cert), "options.https.cert file should exists");
+		if (typeof options.https.ca === "string") assert(fs.existsSync(options.https.ca), "options.https.ca file should exists");
+	}
+	if (options.port && typeof options.port === "string") options.port = parseInt(options.port);
+	if (options.port === null) options.port = void 0;
+	if (options.workers && typeof options.workers === "string") options.workers = parseInt(options.workers);
+	if (!options.workers) options.workers = os.cpus().length;
+	if (options.require) {
+		if (typeof options.require === "string") options.require = [options.require];
+	}
+	if (process.env.NODE_ENV === "production") process.env.NO_DEPRECATION = "*";
+	const isDebug = process.execArgv.some((argv) => argv.includes("--debug") || argv.includes("--inspect"));
+	if (isDebug) options.isDebug = isDebug;
+	return options;
+}
+
+//#endregion
+//#region src/utils/worker_manager.ts
+var WorkerManager = class extends EventEmitter {
+	agent;
+	workers = /* @__PURE__ */ 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
+		};
+	}
+	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);
+			}
+		}, 1e4);
+	}
+};
+
+//#endregion
+//#region src/utils/messenger.ts
+const debug$1 = 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
+* });
+* ```
+*/
+var Messenger = class {
+	#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";
+		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";
+		if (!data.to) {
+			if (data.from === "agent") data.to = "app";
+			if (data.from === "app") data.to = "agent";
+			if (data.from === "parent") data.to = "master";
+		}
+		if (data.to === "master") {
+			debug$1("%s -> master, data: %j", data.from, data);
+			this.sendToMaster(data);
+			return;
+		}
+		if (data.to === "parent") {
+			debug$1("%s -> parent, data: %j", data.from, data);
+			this.sendToParent(data);
+			return;
+		}
+		if (data.to === "app") {
+			debug$1("%s -> %s, data: %j", data.from, data.to, data);
+			this.sendToAppWorker(data);
+			return;
+		}
+		if (data.to === "agent") {
+			debug$1("%s -> %s, data: %j", data.from, data.to, data);
+			this.sendToAgentWorker(data);
+			return;
+		}
+	}
+	/**
+	* send message to master self
+	* @param {Object} data message body
+	*/
+	sendToMaster(data) {
+		this.#master.emit(data.action, data.data);
+	}
+	/**
+	* send message to parent process
+	* @param {Object} data message body
+	*/
+	sendToParent(data) {
+		if (!this.#hasParent) return;
+		process.send(data);
+	}
+	/**
+	* send message to app worker
+	* @param {Object} data message body
+	*/
+	sendToAppWorker(data) {
+		for (const worker of this.#workerManager.listWorkers()) {
+			if (worker.state === "disconnected") continue;
+			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);
+	}
+};
+
+//#endregion
+//#region src/error/ClusterWorkerExceptionError.ts
+var ClusterWorkerExceptionError = class 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);
+	}
+};
+
+//#endregion
+//#region src/master.ts
+const debug = debuglog("egg/cluster/master");
+var Master = class 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";
+		this.isStarted = false;
+		this.logger = new 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";
+		const frameworkPath = this.options.framework;
+		const frameworkPkg = readJSONSync(path.join(frameworkPath, "package.json"));
+		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
+			});
+			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));
+		this.once("agent-start", this.forkAppWorkers.bind(this));
+		this.on("realport", ({ port, protocol }) => {
+			if (port) this.#realPort = port;
+			if (protocol) this.#protocol = protocol;
+		});
+		process.once("SIGINT", this.onSignal.bind(this, "SIGINT"));
+		process.once("SIGQUIT", this.onSignal.bind(this, "SIGQUIT"));
+		process.once("SIGTERM", this.onSignal.bind(this, "SIGTERM"));
+		process.once("exit", this.onExit.bind(this));
+		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();
+		});
+		this.workerManager.on("exception", (count) => {
+			const err = new ClusterWorkerExceptionError(count.agent, count.worker);
+			this.logger.error(err);
+			process.exit(1);
+		});
+	}
+	startByProcess() {
+		this.agentWorker = new AgentProcessUtils(this.options, {
+			log: this.log.bind(this),
+			logger: this.logger,
+			messenger: this.messenger
+		});
+		this.appWorker = new AppProcessUtils(this.options, {
+			log: this.log.bind(this),
+			logger: this.logger,
+			messenger: this.messenger,
+			isProduction: this.isProduction
+		});
+	}
+	startByWorkerThreads() {
+		this.agentWorker = new AgentThreadUtils(this.options, {
+			log: this.log.bind(this),
+			logger: this.logger,
+			messenger: this.messenger
+		});
+		this.appWorker = new AppThreadUtils(this.options, {
+			log: this.log.bind(this),
+			logger: this.logger,
+			messenger: this.messenger,
+			isProduction: this.isProduction
+		});
+	}
+	async detectPorts() {
+		try {
+			const clusterPort = await detectPort();
+			this.options.clusterPort = clusterPort;
+			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) {
+		net.createServer({ pauseOnConnect: true }, (connection) => {
+			/* istanbul ignore next */
+			if (!connection.remoteAddress) connection.destroy();
+			else this.stickyWorker(connection.remoteAddress).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);
+		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();
+			}, 1e3);
+			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";
+		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]
+		});
+		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") {
+				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);
+			}
+		}
+		worker.clean();
+		this.workerManager.deleteWorker(data.workerId);
+		this.messenger.send({
+			action: "egg-pids",
+			to: "agent",
+			data: this.workerManager.getListeningWorkerIds()
+		});
+		if (this.appWorker.isAllWorkerStarted) this.messenger.send({
+			action: "app-worker-died",
+			to: "parent"
+		});
+		else {
+			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;
+		if (this.options.sticky) {
+			if (String(address.port) !== String(this.options.stickyWorkerPort)) return;
+		} else if (this.options.startMode !== "worker_threads" && !isUnixSock(address) && String(address.port) !== String(this.#realPort)) return;
+		worker.state = "listening";
+		this.messenger.send({
+			action: "egg-pids",
+			to: "agent",
+			data: this.workerManager.getListeningWorkerIds()
+		});
+		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);
+		if (this.appWorker.isAllWorkerStarted) this.messenger.send({
+			action: "egg-ready",
+			to: "app",
+			data: this.options
+		});
+		if (this.appWorker.isAllWorkerStarted) worker.disableRefork = false;
+		if (this.appWorker.isAllWorkerStarted || this.appWorker.startSuccessCount < this.options.workers) return;
+		this.appWorker.isAllWorkerStarted = true;
+		for (const worker$1 of this.workerManager.listWorkers()) worker$1.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);
+		}
+		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);
+		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() {
+		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) {
+			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 }) {
+	if (addressType === -1) return address;
+	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;
+}
+
+//#endregion
 //#region src/index.ts
 /**
 * cluster start flow: