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

package/dist/agent-griHEaCW.js

@@ -0,0 +1,246 @@
+import { getSrcDirname, terminate } from "./terminate-w3g0oQgq.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { EventEmitter } from "node:events";
+import workerThreads from "node:worker_threads";
+import { fork } from "node:child_process";
+import { sendmessage } from "sendmessage";
+import { graceful } from "graceful-process";
+
+//#region src/utils/mode/base/agent.ts
+var BaseAgentWorker = class {
+	instance;
+	#instanceId;
+	#instanceStatus;
+	constructor(instance) {
+		this.instance = instance;
+	}
+	get id() {
+		return this.#instanceId;
+	}
+	set id(id) {
+		this.#instanceId = id;
+	}
+	get status() {
+		return this.#instanceStatus;
+	}
+	set status(status) {
+		this.#instanceStatus = status;
+	}
+	static send(_message) {
+		throw new Error("BaseAgentWorker should implement send.");
+	}
+	static kill() {
+		throw new Error("BaseAgentWorker should implement kill.");
+	}
+	static gracefulExit(_options) {
+		throw new Error("BaseAgentWorker should implement gracefulExit.");
+	}
+};
+var BaseAgentUtils = class extends EventEmitter {
+	options;
+	messenger;
+	log;
+	logger;
+	startTime = 0;
+	constructor(options, { log, logger, messenger }) {
+		super();
+		this.options = options;
+		this.log = log;
+		this.logger = logger;
+		this.messenger = messenger;
+	}
+	getAgentWorkerFile() {
+		let agentWorkerFile = path.join(getSrcDirname(), "agent_worker.js");
+		if (!existsSync(agentWorkerFile)) agentWorkerFile = path.join(getSrcDirname(), "agent_worker.ts");
+		return agentWorkerFile;
+	}
+	fork() {
+		throw new Error("BaseAgent should implement fork.");
+	}
+	clean() {
+		throw new Error("BaseAgent should implement clean.");
+	}
+};
+
+//#endregion
+//#region src/error/ClusterAgentWorkerError.ts
+var ClusterAgentWorkerError = class extends Error {
+	id;
+	/**
+	* pid in process mode
+	* tid in worker_threads mode
+	*/
+	workerId;
+	status;
+	constructor(id, workerId, status, error) {
+		const message = `Got agent worker error: ${error.message}`;
+		super(message, { cause: error });
+		this.name = this.constructor.name;
+		this.id = id;
+		this.workerId = workerId;
+		this.status = status;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+
+//#endregion
+//#region src/utils/mode/impl/process/agent.ts
+var AgentProcessWorker = class extends BaseAgentWorker {
+	get workerId() {
+		return this.instance.pid;
+	}
+	send(message) {
+		sendmessage(this.instance, message);
+	}
+	static send(message) {
+		message.senderWorkerId = String(process.pid);
+		process.send(message);
+	}
+	static kill() {
+		process.exitCode = 1;
+		process.kill(process.pid);
+	}
+	static gracefulExit(options) {
+		graceful(options);
+	}
+};
+var AgentProcessUtils = class extends BaseAgentUtils {
+	#agentProcess;
+	#id = 0;
+	instance;
+	fork() {
+		this.startTime = Date.now();
+		const args = [JSON.stringify(this.options)];
+		const forkOptions = {};
+		if (process.platform === "win32") forkOptions.windowsHide = true;
+		const debugPort = process.env.EGG_AGENT_DEBUG_PORT ?? 5800;
+		if (this.options.isDebug) forkOptions.execArgv = process.execArgv.concat([`--inspect-port=${debugPort}`]);
+		const agentProcess = this.#agentProcess = fork(this.getAgentWorkerFile(), args, forkOptions);
+		const agentWorker = this.instance = new AgentProcessWorker(agentProcess);
+		agentWorker.status = "starting";
+		agentWorker.id = ++this.#id;
+		this.emit("agent_forked", agentWorker);
+		this.log("[master] agent_worker#%s:%s start with clusterPort:%s", agentWorker.id, agentWorker.workerId, this.options.clusterPort);
+		if (this.options.isDebug) this.messenger.send({
+			to: "parent",
+			from: "agent",
+			action: "debug",
+			data: {
+				debugPort,
+				pid: agentWorker.workerId,
+				workerId: agentWorker.workerId
+			}
+		});
+		agentProcess.on("message", (msg) => {
+			if (typeof msg === "string") msg = {
+				action: msg,
+				data: msg
+			};
+			msg.from = "agent";
+			this.messenger.send(msg);
+		});
+		agentProcess.on("error", (err) => {
+			err.name = "AgentWorkerError";
+			this.logger.error(new ClusterAgentWorkerError(agentWorker.id, agentWorker.workerId, agentWorker.status, err));
+		});
+		agentProcess.once("exit", (code, signal) => {
+			this.messenger.send({
+				action: "agent-exit",
+				data: {
+					code,
+					signal
+				},
+				to: "master",
+				from: "agent"
+			});
+		});
+		return this;
+	}
+	clean() {
+		this.#agentProcess.removeAllListeners();
+	}
+	async kill(timeout) {
+		if (this.#agentProcess) {
+			this.log("[master] kill agent worker with signal SIGTERM");
+			this.clean();
+			await terminate(this.#agentProcess, timeout);
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/mode/impl/worker_threads/agent.ts
+var AgentThreadWorker = class extends BaseAgentWorker {
+	get workerId() {
+		return this.instance.threadId;
+	}
+	send(message) {
+		this.instance.postMessage(message);
+	}
+	static send(message) {
+		message.senderWorkerId = String(workerThreads.threadId);
+		workerThreads.parentPort.postMessage(message);
+	}
+	static kill() {
+		process.exit(1);
+	}
+	static gracefulExit(options) {
+		const { beforeExit } = options;
+		process.on("exit", async (code) => {
+			if (typeof beforeExit === "function") await beforeExit();
+			process.exit(code);
+		});
+	}
+};
+var AgentThreadUtils = class extends BaseAgentUtils {
+	#worker;
+	#id = 0;
+	instance;
+	fork() {
+		this.startTime = Date.now();
+		const argv = [JSON.stringify(this.options)];
+		const agentPath = this.getAgentWorkerFile();
+		const worker = this.#worker = new workerThreads.Worker(agentPath, { argv });
+		const agentWorker = this.instance = new AgentThreadWorker(worker);
+		this.emit("agent_forked", agentWorker);
+		agentWorker.status = "starting";
+		agentWorker.id = ++this.#id;
+		this.log("[master] agent_worker#%s:%s start with worker_threads", agentWorker.id, agentWorker.workerId);
+		worker.on("message", (msg) => {
+			if (typeof msg === "string") msg = {
+				action: msg,
+				data: msg
+			};
+			msg.from = "agent";
+			this.messenger.send(msg);
+		});
+		worker.on("error", (err) => {
+			this.logger.error(new ClusterAgentWorkerError(agentWorker.id, agentWorker.workerId, agentWorker.status, err));
+		});
+		worker.once("exit", (code, signal) => {
+			this.messenger.send({
+				action: "agent-exit",
+				data: {
+					code,
+					signal
+				},
+				to: "master",
+				from: "agent"
+			});
+		});
+	}
+	clean() {
+		this.#worker.removeAllListeners();
+	}
+	async kill() {
+		if (this.#worker) {
+			this.log(`[master] kill agent worker#${this.#id} (worker_threads) by worker.terminate()`);
+			this.clean();
+			await this.#worker.terminate();
+		}
+	}
+};
+
+//#endregion
+export { AgentProcessUtils, AgentProcessWorker, AgentThreadUtils, AgentThreadWorker, ClusterAgentWorkerError };

package/dist/agent_worker.js

@@ -1,5 +1,5 @@
-import { AgentProcessWorker } from "./utils/mode/impl/process/agent.js";
-import { AgentThreadWorker } from "./utils/mode/impl/worker_threads/agent.js";
+import "./terminate-w3g0oQgq.js";
+import { AgentProcessWorker, AgentThreadWorker } from "./agent-griHEaCW.js";
 import { debuglog } from "node:util";
 import { EggConsoleLogger } from "egg-logger";
 import { importModule } from "@eggjs/utils";

package/dist/app-5Was1vub.js

@@ -0,0 +1,315 @@
+import { getSrcDirname, terminate } from "./terminate-w3g0oQgq.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { EventEmitter } from "node:events";
+import { Worker, parentPort, threadId } from "node:worker_threads";
+import { sendmessage } from "sendmessage";
+import { graceful } from "graceful-process";
+import { setTimeout } from "node:timers/promises";
+import cluster from "node:cluster";
+import { cfork } from "cfork";
+
+//#region src/utils/mode/base/app.ts
+var BaseAppWorker = class {
+	instance;
+	constructor(instance) {
+		this.instance = instance;
+	}
+	get state() {
+		return Reflect.get(this.instance, "state");
+	}
+	set state(state) {
+		Reflect.set(this.instance, "state", state);
+	}
+	get disableRefork() {
+		return Reflect.get(this.instance, "disableRefork");
+	}
+	set disableRefork(disableRefork) {
+		Reflect.set(this.instance, "disableRefork", disableRefork);
+	}
+	get isDevReload() {
+		return Reflect.get(this.instance, "isDevReload");
+	}
+	set isDevReload(isDevReload) {
+		Reflect.set(this.instance, "isDevReload", isDevReload);
+	}
+	clean() {
+		throw new Error("BaseAppWorker should implement clean.");
+	}
+	static get workerId() {
+		throw new Error("BaseAppWorker should implement workerId.");
+	}
+	static on(..._args) {
+		throw new Error("BaseAppWorker should implement on.");
+	}
+	static send(_message) {
+		throw new Error("BaseAgentWorker should implement send.");
+	}
+	static kill() {
+		throw new Error("BaseAppWorker should implement kill.");
+	}
+	static gracefulExit(_options) {
+		throw new Error("BaseAgentWorker should implement gracefulExit.");
+	}
+};
+var BaseAppUtils = class extends EventEmitter {
+	options;
+	messenger;
+	log;
+	logger;
+	isProduction;
+	startTime = 0;
+	startSuccessCount = 0;
+	isAllWorkerStarted = false;
+	constructor(options, { log, logger, messenger, isProduction }) {
+		super();
+		this.options = options;
+		this.log = log;
+		this.logger = logger;
+		this.messenger = messenger;
+		this.isProduction = isProduction;
+	}
+	getAppWorkerFile() {
+		let appWorkerFile = path.join(getSrcDirname(), "app_worker.js");
+		if (!existsSync(appWorkerFile)) appWorkerFile = path.join(getSrcDirname(), "app_worker.ts");
+		return appWorkerFile;
+	}
+	fork() {
+		throw new Error("BaseApp should implement fork.");
+	}
+};
+
+//#endregion
+//#region src/utils/mode/impl/process/app.ts
+var AppProcessWorker = class extends BaseAppWorker {
+	get id() {
+		return this.instance.id;
+	}
+	get workerId() {
+		return this.instance.process.pid;
+	}
+	get exitedAfterDisconnect() {
+		return this.instance.exitedAfterDisconnect;
+	}
+	get exitCode() {
+		return this.instance.process.exitCode;
+	}
+	send(message) {
+		sendmessage(this.instance, message);
+	}
+	clean() {
+		this.instance.removeAllListeners();
+	}
+	static get workerId() {
+		return process.pid;
+	}
+	static on(event, listener) {
+		process.on(event, listener);
+	}
+	static send(message) {
+		message.senderWorkerId = String(process.pid);
+		process.send(message);
+	}
+	static kill() {
+		process.exitCode = 1;
+		process.kill(process.pid);
+	}
+	static gracefulExit(options) {
+		graceful(options);
+	}
+};
+var AppProcessUtils = class extends BaseAppUtils {
+	fork() {
+		this.startTime = Date.now();
+		this.startSuccessCount = 0;
+		const args = [JSON.stringify(this.options)];
+		this.log("[master] start appWorker with args %j (process)", args);
+		cfork({
+			exec: this.getAppWorkerFile(),
+			args,
+			silent: false,
+			count: this.options.workers,
+			refork: this.isProduction,
+			windowsHide: process.platform === "win32"
+		});
+		let debugPort = process.debugPort;
+		cluster.on("fork", (worker) => {
+			const appWorker = new AppProcessWorker(worker);
+			this.emit("worker_forked", appWorker);
+			appWorker.disableRefork = true;
+			worker.on("message", (msg) => {
+				if (typeof msg === "string") msg = {
+					action: msg,
+					data: msg
+				};
+				msg.from = "app";
+				this.messenger.send(msg);
+			});
+			this.log("[master] app_worker#%s:%s start, state: %s, current workers: %j", appWorker.id, appWorker.workerId, appWorker.state, Object.keys(cluster.workers));
+			if (this.options.isDebug) {
+				debugPort++;
+				this.messenger.send({
+					to: "parent",
+					from: "app",
+					action: "debug",
+					data: {
+						debugPort,
+						pid: appWorker.workerId,
+						workerId: appWorker.workerId
+					}
+				});
+			}
+		});
+		cluster.on("disconnect", (worker) => {
+			const appWorker = new AppProcessWorker(worker);
+			this.log("[master] app_worker#%s:%s disconnect, suicide: %s, state: %s, current workers: %j", appWorker.id, appWorker.workerId, appWorker.exitedAfterDisconnect, appWorker.state, Object.keys(cluster.workers));
+		});
+		cluster.on("exit", (worker, code, signal) => {
+			const appWorker = new AppProcessWorker(worker);
+			this.messenger.send({
+				action: "app-exit",
+				data: {
+					workerId: appWorker.workerId,
+					code,
+					signal
+				},
+				to: "master",
+				from: "app"
+			});
+		});
+		return this;
+	}
+	async kill(timeout) {
+		await Promise.all(Object.keys(cluster.workers).map((id) => {
+			const worker = cluster.workers[id];
+			Reflect.set(worker, "disableRefork", true);
+			return terminate(worker.process, timeout);
+		}));
+	}
+};
+
+//#endregion
+//#region src/utils/mode/impl/worker_threads/app.ts
+var AppThreadWorker = class extends BaseAppWorker {
+	#state = "none";
+	#id;
+	constructor(instance, id) {
+		super(instance);
+		this.#id = id;
+	}
+	get id() {
+		return this.#id;
+	}
+	get workerId() {
+		return this.instance.threadId;
+	}
+	get state() {
+		return this.#state;
+	}
+	set state(val) {
+		this.#state = val;
+	}
+	get exitedAfterDisconnect() {
+		return true;
+	}
+	get exitCode() {
+		return 0;
+	}
+	send(message) {
+		this.instance.postMessage(message);
+	}
+	clean() {
+		this.instance.removeAllListeners();
+	}
+	static get workerId() {
+		return threadId;
+	}
+	static on(event, listener) {
+		parentPort.on(event, listener);
+	}
+	static send(message) {
+		message.senderWorkerId = String(threadId);
+		parentPort.postMessage(message);
+	}
+	static kill() {
+		process.exit(1);
+	}
+	static gracefulExit(options) {
+		process.on("exit", async (code) => {
+			if (typeof options.beforeExit === "function") await options.beforeExit();
+			process.exit(code);
+		});
+	}
+};
+var AppThreadUtils = class extends BaseAppUtils {
+	#workers = [];
+	#forkSingle(appPath, options, id) {
+		const worker = new Worker(appPath, options);
+		this.#workers.push(worker);
+		const appWorker = new AppThreadWorker(worker, id);
+		this.emit("worker_forked", appWorker);
+		appWorker.disableRefork = true;
+		worker.on("message", (msg) => {
+			if (typeof msg === "string") msg = {
+				action: msg,
+				data: msg
+			};
+			msg.from = "app";
+			this.messenger.send(msg);
+		});
+		this.log("[master] app_worker#%s (tid:%s) start", appWorker.id, appWorker.workerId);
+		let debugPort = process.debugPort;
+		if (this.options.isDebug) {
+			debugPort++;
+			this.messenger.send({
+				to: "parent",
+				from: "app",
+				action: "debug",
+				data: {
+					debugPort,
+					pid: appWorker.workerId,
+					workerId: appWorker.workerId
+				}
+			});
+		}
+		worker.on("exit", async (code) => {
+			appWorker.state = "dead";
+			this.messenger.send({
+				action: "app-exit",
+				data: {
+					workerId: appWorker.workerId,
+					code
+				},
+				to: "master",
+				from: "app"
+			});
+			await setTimeout(1e3);
+			this.#forkSingle(appPath, options, id);
+		});
+	}
+	fork() {
+		this.startTime = Date.now();
+		this.startSuccessCount = 0;
+		const ports = this.options.ports ?? [];
+		if (!ports.length) ports.push(this.options.port);
+		this.options.workers = ports.length;
+		let i = 0;
+		do {
+			const options = Object.assign({}, this.options, { port: ports[i] });
+			const argv = [JSON.stringify(options)];
+			this.#forkSingle(this.getAppWorkerFile(), { argv }, ++i);
+		} while (i < ports.length);
+		return this;
+	}
+	async kill() {
+		for (const worker of this.#workers) {
+			const id = Reflect.get(worker, "id");
+			this.log(`[master] kill app worker#${id} (worker_threads) by worker.terminate()`);
+			worker.removeAllListeners();
+			worker.terminate();
+		}
+	}
+};
+
+//#endregion
+export { AppProcessUtils, AppProcessWorker, AppThreadUtils, AppThreadWorker };

package/dist/app_worker.js

@@ -1,5 +1,5 @@
-import { AppProcessWorker } from "./utils/mode/impl/process/app.js";
-import { AppThreadWorker } from "./utils/mode/impl/worker_threads/app.js";
+import "./terminate-w3g0oQgq.js";
+import { AppProcessWorker, AppThreadWorker } from "./app-5Was1vub.js";
 import { debuglog } from "node:util";
 import fs from "node:fs";
 import { EggConsoleLogger } from "egg-logger";