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

package/dist/app-5Was1vub.js

@@ -1,315 +0,0 @@
-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/terminate-w3g0oQgq.js

@@ -1,71 +0,0 @@
-import { debuglog } from "node:util";
-import path from "node:path";
-import { once } from "node:events";
-import { fileURLToPath } from "node:url";
-import { ChildProcess } from "node:child_process";
-import { setTimeout } from "node:timers/promises";
-import { pstree } from "@fengmk2/ps-tree";
-
-//#region src/dirname.ts
-function getSrcDirname() {
-	if (typeof __dirname !== "undefined") return __dirname;
-	return path.dirname(fileURLToPath(import.meta.url));
-}
-
-//#endregion
-//#region src/utils/terminate.ts
-const debug = debuglog("egg/cluster/utils/terminate");
-async function terminate(subProcess, timeout) {
-	const pid = subProcess.process?.pid ?? subProcess.pid;
-	const childPids = await getChildPids(pid);
-	await Promise.all([killProcess(subProcess, timeout), killChildren(childPids, timeout)]);
-}
-async function killProcess(subProcess, timeout) {
-	(subProcess.process ?? subProcess).kill("SIGTERM");
-	await Promise.race([once(subProcess, "exit"), setTimeout(timeout)]);
-	if (subProcess.killed) return;
-	(subProcess.process ?? subProcess).kill("SIGKILL");
-}
-async function killChildren(childrenPids, timeout) {
-	if (childrenPids.length === 0) return;
-	kill(childrenPids, "SIGTERM");
-	const start = Date.now();
-	const checkInterval = 400;
-	let unterminated = [];
-	while (Date.now() - start < timeout - checkInterval) {
-		await setTimeout(checkInterval);
-		unterminated = getUnterminatedProcesses(childrenPids);
-		if (unterminated.length === 0) return;
-	}
-	kill(unterminated, "SIGKILL");
-}
-async function getChildPids(pid) {
-	let childrenPids = [];
-	try {
-		childrenPids = (await pstree(pid)).map((c) => parseInt(c.PID));
-	} catch (err) {
-		debug("pstree %s error: %s, ignore it", pid, err);
-	}
-	return childrenPids;
-}
-function kill(pids, signal) {
-	for (const pid of pids) try {
-		process.kill(pid, signal);
-	} catch (err) {
-		debug("kill %s error: %s, signal: %s, ignore it", pid, err, signal);
-	}
-}
-function getUnterminatedProcesses(pids) {
-	return pids.filter((pid) => {
-		try {
-			process.kill(pid, 0);
-			return true;
-		} catch (err) {
-			debug("kill %s error: %s, it still alive", pid, err);
-			return false;
-		}
-	});
-}
-
-//#endregion
-export { getSrcDirname, terminate };