@eggjs/cluster 3.0.1 → 3.1.0-beta.10

package/dist/utils/mode/base/agent.js

@@ -0,0 +1,63 @@
+import { getSrcDirname } from "../../../dirname.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { EventEmitter } from "node:events";
+
+//#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
+export { BaseAgentUtils, BaseAgentWorker };

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

@@ -0,0 +1,56 @@
+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 { Worker as Worker$1 } from "node:cluster";
+
+//#region src/utils/mode/base/app.d.ts
+declare abstract class BaseAppWorker<T = Worker | Worker$1> {
+  instance: T;
+  constructor(instance: T);
+  abstract get workerId(): number;
+  abstract get id(): number;
+  get state(): string;
+  set state(state: string);
+  abstract get exitedAfterDisconnect(): boolean;
+  abstract get exitCode(): number;
+  get disableRefork(): boolean;
+  set disableRefork(disableRefork: boolean);
+  get isDevReload(): boolean;
+  set isDevReload(isDevReload: boolean);
+  abstract send(data: MessageBody): void;
+  clean(): void;
+  static get workerId(): number;
+  static on(..._args: any[]): void;
+  static send(_message: MessageBody): void;
+  static kill(): void;
+  static gracefulExit(_options: any): void;
+}
+type LogFun = (msg: any, ...args: any[]) => void;
+declare abstract class BaseAppUtils extends EventEmitter {
+  options: MasterOptions;
+  protected messenger: Messenger;
+  protected log: LogFun;
+  protected logger: Logger;
+  protected isProduction: boolean;
+  startTime: number;
+  startSuccessCount: number;
+  isAllWorkerStarted: boolean;
+  constructor(options: MasterOptions, {
+    log,
+    logger,
+    messenger,
+    isProduction
+  }: {
+    log: LogFun;
+    logger: Logger;
+    messenger: Messenger;
+    isProduction: boolean;
+  });
+  getAppWorkerFile(): string;
+  fork(): void;
+  abstract kill(timeout: number): Promise<void>;
+}
+//#endregion
+export { BaseAppUtils, BaseAppWorker };

package/dist/utils/mode/base/app.js

@@ -0,0 +1,77 @@
+import { getSrcDirname } from "../../../dirname.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { EventEmitter } from "node:events";
+
+//#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
+export { BaseAppUtils, BaseAppWorker };

package/dist/utils/mode/impl/process/agent.d.ts

@@ -0,0 +1,22 @@
+import { BaseAgentUtils, BaseAgentWorker } from "../../base/agent.js";
+import { MessageBody } from "../../../messenger.js";
+import { ChildProcess } from "node:child_process";
+import { Options } from "graceful-process";
+
+//#region src/utils/mode/impl/process/agent.d.ts
+declare class AgentProcessWorker extends BaseAgentWorker<ChildProcess> {
+  get workerId(): number;
+  send(message: MessageBody): void;
+  static send(message: MessageBody): void;
+  static kill(): void;
+  static gracefulExit(options: Options): void;
+}
+declare class AgentProcessUtils extends BaseAgentUtils {
+  #private;
+  instance: AgentProcessWorker;
+  fork(): this;
+  clean(): void;
+  kill(timeout: number): Promise<void>;
+}
+//#endregion
+export { AgentProcessUtils };

package/dist/utils/mode/impl/process/agent.js

@@ -0,0 +1,93 @@
+import { BaseAgentUtils, BaseAgentWorker } from "../../base/agent.js";
+import { terminate } from "../../../terminate.js";
+import { ClusterAgentWorkerError } from "../../../../error/ClusterAgentWorkerError.js";
+import { fork } from "node:child_process";
+import { sendmessage } from "sendmessage";
+import { graceful } from "graceful-process";
+
+//#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
+export { AgentProcessUtils };

package/dist/utils/mode/impl/process/app.d.ts

@@ -0,0 +1,12 @@
+import { BaseAppUtils } from "../../base/app.js";
+import { Options } from "graceful-process";
+import { Worker } from "node:cluster";
+
+//#region src/utils/mode/impl/process/app.d.ts
+
+declare class AppProcessUtils extends BaseAppUtils {
+  fork(): this;
+  kill(timeout: number): Promise<void>;
+}
+//#endregion
+export { AppProcessUtils };

package/dist/utils/mode/impl/process/app.js

@@ -0,0 +1,117 @@
+import { BaseAppUtils, BaseAppWorker } from "../../base/app.js";
+import { terminate } from "../../../terminate.js";
+import { sendmessage } from "sendmessage";
+import { graceful } from "graceful-process";
+import cluster from "node:cluster";
+import { cfork } from "cfork";
+
+//#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
+export { AppProcessUtils };

package/dist/utils/mode/impl/worker_threads/agent.d.ts

@@ -0,0 +1,22 @@
+import { BaseAgentUtils, BaseAgentWorker } from "../../base/agent.js";
+import { MessageBody } from "../../../messenger.js";
+import { Worker } from "node:worker_threads";
+import { Options } from "graceful-process";
+
+//#region src/utils/mode/impl/worker_threads/agent.d.ts
+declare class AgentThreadWorker extends BaseAgentWorker<Worker> {
+  get workerId(): number;
+  send(message: MessageBody): void;
+  static send(message: MessageBody): void;
+  static kill(): void;
+  static gracefulExit(options: Options): void;
+}
+declare class AgentThreadUtils extends BaseAgentUtils {
+  #private;
+  instance: AgentThreadWorker;
+  fork(): void;
+  clean(): void;
+  kill(): Promise<void>;
+}
+//#endregion
+export { AgentThreadUtils };

package/dist/utils/mode/impl/worker_threads/agent.js

@@ -0,0 +1,79 @@
+import { BaseAgentUtils, BaseAgentWorker } from "../../base/agent.js";
+import { ClusterAgentWorkerError } from "../../../../error/ClusterAgentWorkerError.js";
+import workerThreads from "node:worker_threads";
+import "graceful-process";
+
+//#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 { AgentThreadUtils };

package/dist/utils/mode/impl/worker_threads/app.d.ts

@@ -0,0 +1,13 @@
+import { BaseAppUtils } from "../../base/app.js";
+import { Worker } from "node:worker_threads";
+import { Options } from "graceful-process";
+
+//#region src/utils/mode/impl/worker_threads/app.d.ts
+
+declare class AppThreadUtils extends BaseAppUtils {
+  #private;
+  fork(): this;
+  kill(): Promise<void>;
+}
+//#endregion
+export { AppThreadUtils };

package/dist/utils/mode/impl/worker_threads/app.js

@@ -0,0 +1,128 @@
+import { BaseAppUtils, BaseAppWorker } from "../../base/app.js";
+import { Worker, parentPort, threadId } from "node:worker_threads";
+import { setTimeout } from "node:timers/promises";
+
+//#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 { AppThreadUtils };