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

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

@@ -1,117 +0,0 @@
-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, AppProcessWorker };

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

@@ -1,22 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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, AgentThreadWorker };

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

@@ -1,13 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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, AppThreadWorker };

package/dist/utils/options.d.ts

@@ -1,83 +0,0 @@
-import { SecureContextOptions } from "node:tls";
-
-//#region src/utils/options.d.ts
-interface ClusterHTTPSSecureOptions {
-  key: SecureContextOptions['key'];
-  cert: SecureContextOptions['cert'];
-  ca?: SecureContextOptions['ca'];
-  passphrase?: SecureContextOptions['passphrase'];
-}
-type ClusterStartMode = 'process' | 'worker_threads';
-/** Cluster start options */
-interface ClusterOptions {
-  /**
-   * specify framework that can be absolute path or npm package
-   */
-  framework?: string;
-  /**
-   * @deprecated please use framework instead
-   */
-  customEgg?: string;
-  /** directory of application, default to `process.cwd()` */
-  baseDir?: string;
-  /**
-   * numbers of app workers, default to `os.cpus().length`
-   */
-  workers?: number | string;
-  /**
-   * listening port, default to `7001`(http) or `8443`(https)
-   */
-  port?: number | string | null;
-  /**
-   * listening a debug port on http protocol
-   */
-  debugPort?: number;
-  /**
-   * https options, { key, cert, ca }, full path
-   */
-  https?: ClusterHTTPSSecureOptions | boolean;
-  /**
-   * @deprecated please use `options.https.key` instead
-   */
-  key?: ClusterHTTPSSecureOptions['key'];
-  /**
-   * @deprecated please use `options.https.cert` instead
-   */
-  cert?: ClusterHTTPSSecureOptions['cert'];
-  /**
-   * will inject into worker/agent process
-   */
-  require?: string | string[];
-  /**
-   * will save master pid to this file
-   */
-  pidFile?: string;
-  /**
-   * custom env, default is `process.env.EGG_SERVER_ENV`
-   */
-  env?: string;
-  /**
-   * default is `'process'`, use `'worker_threads'` to start the app & agent worker by worker_threads
-   */
-  startMode?: ClusterStartMode;
-  /**
-   * startup port of each app worker, such as: `[7001, 7002, 7003]`, only effects when the startMode is `'worker_threads'`
-   */
-  ports?: number[];
-  /**
-   * sticky mode server
-   */
-  sticky?: boolean;
-  /** customized plugins, for unittest */
-  plugins?: object;
-  isDebug?: boolean;
-}
-interface ParsedClusterOptions extends ClusterOptions {
-  port?: number;
-  baseDir: string;
-  workers: number;
-  framework: string;
-  startMode: ClusterStartMode;
-}
-//#endregion
-export { ClusterHTTPSSecureOptions, ClusterOptions, ClusterStartMode, ParsedClusterOptions };

package/dist/utils/options.js

@@ -1,56 +0,0 @@
-import os from "node:os";
-import { debuglog } from "node:util";
-import path from "node:path";
-import fs from "node:fs";
-import assert from "node:assert";
-import { getFrameworkPath, importModule } from "@eggjs/utils";
-
-//#region src/utils/options.ts
-const debug = 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("[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
-export { parseOptions };

package/dist/utils/worker_manager.d.ts

@@ -1,32 +0,0 @@
-import { BaseAgentWorker } from "./mode/base/agent.js";
-import { BaseAppWorker } from "./mode/base/app.js";
-import { EventEmitter } from "node:events";
-import * as worker_threads0 from "worker_threads";
-import * as cluster0 from "cluster";
-import * as child_process0 from "child_process";
-
-//#region src/utils/worker_manager.d.ts
-declare class WorkerManager extends EventEmitter {
-  agent: BaseAgentWorker | null;
-  workers: Map<number, BaseAppWorker<worker_threads0.Worker | cluster0.Worker>>;
-  exception: number;
-  timer: NodeJS.Timeout;
-  constructor();
-  getWorkers(): number[];
-  setAgent(agent: BaseAgentWorker): void;
-  getAgent(): BaseAgentWorker<worker_threads0.Worker | child_process0.ChildProcess> | null;
-  deleteAgent(): void;
-  setWorker(worker: BaseAppWorker): void;
-  getWorker(workerId: number): BaseAppWorker<worker_threads0.Worker | cluster0.Worker> | undefined;
-  deleteWorker(workerId: number): void;
-  listWorkerIds(): number[];
-  listWorkers(): BaseAppWorker<worker_threads0.Worker | cluster0.Worker>[];
-  getListeningWorkerIds(): number[];
-  count(): {
-    agent: number;
-    worker: number;
-  };
-  startCheck(): void;
-}
-//#endregion
-export { WorkerManager };

package/dist/utils/worker_manager.js

@@ -1,68 +0,0 @@
-import { EventEmitter } from "node:events";
-
-//#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
-export { WorkerManager };