@eggjs/cluster 3.0.1 → 3.1.0-beta.2

package/dist/master.js

@@ -0,0 +1,426 @@
+import { parseOptions } from "./utils/options.js";
+import { WorkerManager } from "./utils/worker_manager.js";
+import { Messenger } from "./utils/messenger.js";
+import { AgentProcessUtils } from "./utils/mode/impl/process/agent.js";
+import { AppProcessUtils } from "./utils/mode/impl/process/app.js";
+import { AgentThreadUtils } from "./utils/mode/impl/worker_threads/agent.js";
+import { AppThreadUtils } from "./utils/mode/impl/worker_threads/app.js";
+import { ClusterWorkerExceptionError } from "./error/ClusterWorkerExceptionError.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";
+
+//#region src/master.ts
+const debug = debuglog("@eggjs/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
+export { Master };

package/dist/utils/messenger.d.ts

@@ -0,0 +1,96 @@
+import { WorkerManager } from "./worker_manager.js";
+import { Master } from "../master.js";
+
+//#region src/utils/messenger.d.ts
+type MessageCharacter = 'agent' | 'app' | 'master' | 'parent';
+interface MessageBody {
+  action: string;
+  data?: unknown;
+  to?: MessageCharacter;
+  from?: MessageCharacter;
+  /**
+   * @deprecated Keep compatible, please use receiverWorkerId instead
+   */
+  receiverPid?: string;
+  receiverWorkerId?: string;
+  senderWorkerId?: string;
+}
+/**
+ * master messenger, provide communication between parent, master, agent and app.
+ *
+ *             ┌────────┐
+ *             │ parent │
+ *            /└────────┘\
+ *           /     |      \
+ *          /  ┌────────┐  \
+ *         /   │ master │   \
+ *        /    └────────┘    \
+ *       /     /         \    \
+ *     ┌───────┐         ┌───────┐
+ *     │ agent │ ------- │  app  │
+ *     └───────┘         └───────┘
+ *
+ *
+ * in app worker
+ *
+ * ```js
+ * process.send({
+ *   action: 'xxx',
+ *   data: '',
+ *   to: 'agent/master/parent', // default to agent
+ * });
+ * ```
+ *
+ * in agent worker
+ *
+ * ```js
+ * process.send({
+ *   action: 'xxx',
+ *   data: '',
+ *   to: 'app/master/parent', // default to app
+ * });
+ * ```
+ *
+ * in parent
+ *
+ * ```js
+ * process.send({
+ *   action: 'xxx',
+ *   data: '',
+ *   to: 'app/agent/master', // default to master
+ * });
+ * ```
+ */
+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;
+}
+//#endregion
+export { MessageBody, Messenger };

package/dist/utils/messenger.js

@@ -0,0 +1,144 @@
+import { debuglog } from "node:util";
+import workerThreads from "node:worker_threads";
+
+//#region src/utils/messenger.ts
+const debug = debuglog("egg/cluster/messenger");
+/**
+* master messenger, provide communication between parent, master, agent and app.
+*
+*             ┌────────┐
+*             │ parent │
+*            /└────────┘\
+*           /     |      \
+*          /  ┌────────┐  \
+*         /   │ master │   \
+*        /    └────────┘    \
+*       /     /         \    \
+*     ┌───────┐         ┌───────┐
+*     │ agent │ ------- │  app  │
+*     └───────┘         └───────┘
+*
+*
+* in app worker
+*
+* ```js
+* process.send({
+*   action: 'xxx',
+*   data: '',
+*   to: 'agent/master/parent', // default to agent
+* });
+* ```
+*
+* in agent worker
+*
+* ```js
+* process.send({
+*   action: 'xxx',
+*   data: '',
+*   to: 'app/master/parent', // default to app
+* });
+* ```
+*
+* in parent
+*
+* ```js
+* process.send({
+*   action: 'xxx',
+*   data: '',
+*   to: 'app/agent/master', // default to master
+* });
+* ```
+*/
+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("%s -> master, data: %j", data.from, data);
+			this.sendToMaster(data);
+			return;
+		}
+		if (data.to === "parent") {
+			debug("%s -> parent, data: %j", data.from, data);
+			this.sendToParent(data);
+			return;
+		}
+		if (data.to === "app") {
+			debug("%s -> %s, data: %j", data.from, data.to, data);
+			this.sendToAppWorker(data);
+			return;
+		}
+		if (data.to === "agent") {
+			debug("%s -> %s, data: %j", data.from, data.to, data);
+			this.sendToAgentWorker(data);
+			return;
+		}
+	}
+	/**
+	* send message to master self
+	* @param {Object} data message body
+	*/
+	sendToMaster(data) {
+		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
+export { Messenger };

package/dist/utils/mode/base/agent.d.ts

@@ -0,0 +1,45 @@
+import { MessageBody, Messenger } from "../../messenger.js";
+import { MasterOptions } from "../../../master.js";
+import { Logger } from "egg-logger";
+import { EventEmitter } from "node:events";
+import { Worker } from "node:worker_threads";
+import { ChildProcess } from "node:child_process";
+
+//#region src/utils/mode/base/agent.d.ts
+declare abstract class BaseAgentWorker<T = ChildProcess | Worker> {
+  #private;
+  instance: T;
+  constructor(instance: T);
+  abstract get workerId(): number;
+  get id(): number;
+  set id(id: number);
+  get status(): string;
+  set status(status: string);
+  abstract send(message: MessageBody): void;
+  static send(_message: MessageBody): void;
+  static kill(): void;
+  static gracefulExit(_options: any): void;
+}
+type LogFun = (msg: any, ...args: any[]) => void;
+declare abstract class BaseAgentUtils extends EventEmitter {
+  protected options: MasterOptions;
+  protected messenger: Messenger;
+  protected log: LogFun;
+  protected logger: Logger;
+  startTime: number;
+  constructor(options: MasterOptions, {
+    log,
+    logger,
+    messenger
+  }: {
+    log: LogFun;
+    logger: Logger;
+    messenger: Messenger;
+  });
+  getAgentWorkerFile(): string;
+  fork(): void;
+  clean(): void;
+  abstract kill(timeout: number): Promise<void>;
+}
+//#endregion
+export { BaseAgentUtils, BaseAgentWorker };