Project Init

node_modules/@module-federation/dts-plugin/dist/Broker-DRFgFvXI.js

@@ -0,0 +1,783 @@
+const require_Action = require('./Action-CzhPMw2i.js');
+let fs = require("fs");
+fs = require_Action.__toESM(fs);
+let path = require("path");
+path = require_Action.__toESM(path);
+let _module_federation_sdk = require("@module-federation/sdk");
+let net = require("net");
+net = require_Action.__toESM(net);
+let os = require("os");
+os = require_Action.__toESM(os);
+let isomorphic_ws = require("isomorphic-ws");
+isomorphic_ws = require_Action.__toESM(isomorphic_ws);
+let http = require("http");
+let node_schedule = require("node-schedule");
+node_schedule = require_Action.__toESM(node_schedule);
+let url = require("url");
+
+//#region src/server/message/API/API.ts
+let APIKind = /* @__PURE__ */ function(APIKind) {
+	APIKind["UPDATE_SUBSCRIBER"] = "UPDATE_SUBSCRIBER";
+	APIKind["RELOAD_WEB_CLIENT"] = "RELOAD_WEB_CLIENT";
+	APIKind["FETCH_TYPES"] = "FETCH_TYPES";
+	return APIKind;
+}({});
+var API = class extends require_Action.Message {
+	constructor(content, kind) {
+		super("API", kind);
+		const { code, payload } = content;
+		this.code = code;
+		this.payload = payload;
+	}
+};
+
+//#endregion
+//#region src/server/message/API/UpdateSubscriber.ts
+var UpdateSubscriberAPI = class extends API {
+	constructor(payload) {
+		super({
+			code: 0,
+			payload
+		}, APIKind.UPDATE_SUBSCRIBER);
+	}
+};
+
+//#endregion
+//#region src/server/message/API/ReloadWebClient.ts
+var ReloadWebClientAPI = class extends API {
+	constructor(payload) {
+		super({
+			code: 0,
+			payload
+		}, APIKind.RELOAD_WEB_CLIENT);
+	}
+};
+
+//#endregion
+//#region src/server/message/API/FetchTypes.ts
+var FetchTypesAPI = class extends API {
+	constructor(payload) {
+		super({
+			code: 0,
+			payload
+		}, APIKind.FETCH_TYPES);
+	}
+};
+
+//#endregion
+//#region src/server/message/Log/Log.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel["LOG"] = "LOG";
+	LogLevel["WARN"] = "WARN";
+	LogLevel["ERROR"] = "ERROR";
+	return LogLevel;
+}({});
+let LogKind = /* @__PURE__ */ function(LogKind) {
+	LogKind["BrokerExitLog"] = "BrokerExitLog";
+	LogKind["PublisherRegisteredLog"] = "PublisherRegisteredLog";
+	return LogKind;
+}({});
+var Log = class extends require_Action.Message {
+	constructor(level, kind, ignoreVerbose = false) {
+		super("Log", kind);
+		this.ignoreVerbose = false;
+		this.level = level;
+		this.ignoreVerbose = ignoreVerbose;
+	}
+};
+
+//#endregion
+//#region src/server/message/Log/BrokerExitLog.ts
+var BrokerExitLog = class extends Log {
+	constructor() {
+		super(LogLevel.LOG, LogKind.BrokerExitLog);
+	}
+};
+
+//#endregion
+//#region src/server/utils/log.ts
+const logger = (0, _module_federation_sdk.createLogger)(`[ ${require_Action.MF_SERVER_IDENTIFIER} ]`);
+function fileLog(msg, module, level) {
+	if (!process?.env?.["FEDERATION_DEBUG"]) return;
+	try {
+		const logDir = ".mf";
+		const logFile = path.join(logDir, "typesGenerate.log");
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+		fs.appendFileSync(logFile, `[${timestamp}] [${level.toUpperCase()}] ${module} - ${msg}\n`);
+	} catch {}
+}
+function error(error, action, from) {
+	const err = error instanceof Error ? error : /* @__PURE__ */ new Error(`${action} error`);
+	fileLog(`[${action}] error: ${err}`, from, "fatal");
+	return err.toString();
+}
+
+//#endregion
+//#region src/server/utils/getIPV4.ts
+const localIpv4 = "127.0.0.1";
+const getIpv4Interfaces = () => {
+	try {
+		const interfaces = os.default.networkInterfaces();
+		const ipv4Interfaces = [];
+		Object.values(interfaces).forEach((detail) => {
+			detail?.forEach((detail) => {
+				const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
+				if (detail.family === familyV4Value && detail.address !== localIpv4) ipv4Interfaces.push(detail);
+			});
+		});
+		return ipv4Interfaces;
+	} catch (_err) {
+		return [];
+	}
+};
+const getIPV4 = () => {
+	return (getIpv4Interfaces()[0] || { address: localIpv4 }).address;
+};
+
+//#endregion
+//#region src/server/utils/index.ts
+function getIdentifier(options) {
+	const { ip, name } = options;
+	return `mf ${_module_federation_sdk.SEPARATOR}${name}${ip ? `${_module_federation_sdk.SEPARATOR}${ip}` : ""}`;
+}
+function fib(n) {
+	let i = 2;
+	const res = [
+		0,
+		1,
+		1
+	];
+	while (i <= n) {
+		res[i] = res[i - 1] + res[i - 2];
+		i++;
+	}
+	return res[n];
+}
+function getFreePort() {
+	return new Promise((resolve, reject) => {
+		const server = net.default.createServer();
+		server.unref();
+		server.on("error", reject);
+		server.listen(0, () => {
+			const { port } = server.address();
+			server.close(() => {
+				resolve(port);
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/server/Publisher.ts
+var Publisher = class {
+	constructor(ctx) {
+		this._name = ctx.name;
+		this._ip = ctx.ip;
+		this._remoteTypeTarPath = ctx.remoteTypeTarPath;
+		this._subscribers = /* @__PURE__ */ new Map();
+		this._ws = ctx.ws;
+		this.dynamicRemoteMap = /* @__PURE__ */ new Map();
+	}
+	get identifier() {
+		return getIdentifier({
+			name: this._name,
+			ip: this._ip
+		});
+	}
+	get name() {
+		return this._name;
+	}
+	get ip() {
+		return this._ip;
+	}
+	get remoteTypeTarPath() {
+		return this._remoteTypeTarPath;
+	}
+	get hasSubscribes() {
+		return Boolean(this._subscribers.size);
+	}
+	get subscribers() {
+		return this._subscribers;
+	}
+	addSubscriber(identifier, subscriber) {
+		fileLog(`${this.name} set subscriber: ${identifier}`, "Publisher", "info");
+		this._subscribers.set(identifier, subscriber);
+	}
+	removeSubscriber(identifier) {
+		if (this._subscribers.has(identifier)) {
+			fileLog(`${this.name} removeSubscriber: ${identifier}`, "Publisher", "warn");
+			this._subscribers.delete(identifier);
+		}
+	}
+	notifySubscriber(subscriberIdentifier, options) {
+		const subscriber = this._subscribers.get(subscriberIdentifier);
+		if (!subscriber) {
+			fileLog(`[notifySubscriber] ${this.name} notifySubscriber: ${subscriberIdentifier}, does not exits`, "Publisher", "error");
+			return;
+		}
+		const api = new UpdateSubscriberAPI(options);
+		subscriber.send(JSON.stringify(api));
+		fileLog(`[notifySubscriber] ${this.name} notifySubscriber: ${JSON.stringify(subscriberIdentifier)}, message: ${JSON.stringify(api)}`, "Publisher", "info");
+	}
+	fetchRemoteTypes(options) {
+		fileLog(`[fetchRemoteTypes] ${this.name} fetchRemoteTypes, options: ${JSON.stringify(options)}, ws: ${Boolean(this._ws)}`, "Publisher", "info");
+		if (!this._ws) return;
+		const api = new FetchTypesAPI(options);
+		this._ws.send(JSON.stringify(api));
+	}
+	notifySubscribers(options) {
+		const api = new UpdateSubscriberAPI(options);
+		this.broadcast(api);
+	}
+	broadcast(message) {
+		if (this.hasSubscribes) this._subscribers.forEach((subscriber, key) => {
+			fileLog(`[BroadCast] ${this.name} notifySubscriber: ${key}, PID: ${process.pid}, message: ${JSON.stringify(message)}`, "Publisher", "info");
+			subscriber.send(JSON.stringify(message));
+		});
+		else fileLog(`[BroadCast] ${this.name}'s subscribe is empty`, "Publisher", "warn");
+	}
+	close() {
+		this._ws = void 0;
+		this._subscribers.forEach((_subscriber, identifier) => {
+			fileLog(`[BroadCast] close ${this.name} remove: ${identifier}`, "Publisher", "warn");
+			this.removeSubscriber(identifier);
+		});
+	}
+};
+
+//#endregion
+//#region src/server/message/Action/Update.ts
+let UpdateKind = /* @__PURE__ */ function(UpdateKind) {
+	UpdateKind["UPDATE_TYPE"] = "UPDATE_TYPE";
+	UpdateKind["RELOAD_PAGE"] = "RELOAD_PAGE";
+	return UpdateKind;
+}({});
+
+//#endregion
+//#region src/server/broker/Broker.ts
+var Broker = class Broker {
+	static {
+		this.WEB_SOCKET_CONNECT_MAGIC_ID = require_Action.WEB_SOCKET_CONNECT_MAGIC_ID;
+	}
+	static {
+		this.DEFAULT_WEB_SOCKET_PORT = require_Action.DEFAULT_WEB_SOCKET_PORT;
+	}
+	static {
+		this.DEFAULT_SECURE_WEB_SOCKET_PORT = 16324;
+	}
+	static {
+		this.DEFAULT_WAITING_TIME = 1.5 * 60 * 60 * 1e3;
+	}
+	constructor() {
+		this._publisherMap = /* @__PURE__ */ new Map();
+		this._webClientMap = /* @__PURE__ */ new Map();
+		this._tmpSubscriberShelter = /* @__PURE__ */ new Map();
+		this._scheduleJob = null;
+		this._setSchedule();
+		this._startWsServer();
+		this._stopWhenSIGTERMOrSIGINT();
+		this._handleUnexpectedExit();
+	}
+	get hasPublishers() {
+		return Boolean(this._publisherMap.size);
+	}
+	async _startWsServer() {
+		const wsHandler = (ws, req) => {
+			const { url: reqUrl = "" } = req;
+			const { query } = (0, url.parse)(reqUrl, true);
+			const { WEB_SOCKET_CONNECT_MAGIC_ID } = query;
+			if (WEB_SOCKET_CONNECT_MAGIC_ID === Broker.WEB_SOCKET_CONNECT_MAGIC_ID) {
+				ws.on("message", (message) => {
+					try {
+						const text = message.toString();
+						const action = JSON.parse(text);
+						fileLog(`${action?.kind} action received `, "Broker", "info");
+						this._takeAction(action, ws);
+					} catch (error) {
+						fileLog(`parse action message error: ${error}`, "Broker", "error");
+					}
+				});
+				ws.on("error", (e) => {
+					fileLog(`parse action message error: ${e}`, "Broker", "error");
+				});
+			} else {
+				ws.send("Invalid CONNECT ID.");
+				fileLog("Invalid CONNECT ID.", "Broker", "warn");
+				ws.close();
+			}
+		};
+		const server = (0, http.createServer)();
+		this._webSocketServer = new isomorphic_ws.default.Server({ noServer: true });
+		this._webSocketServer.on("error", (err) => {
+			fileLog(`ws error: \n${err.message}\n ${err.stack}`, "Broker", "error");
+		});
+		this._webSocketServer.on("listening", () => {
+			fileLog(`WebSocket server is listening on port ${Broker.DEFAULT_WEB_SOCKET_PORT}`, "Broker", "info");
+		});
+		this._webSocketServer.on("connection", wsHandler);
+		this._webSocketServer.on("close", (code) => {
+			fileLog(`WebSocket Server Close with Code ${code}`, "Broker", "warn");
+			this._webSocketServer && this._webSocketServer.close();
+			this._webSocketServer = void 0;
+		});
+		server.on("upgrade", (req, socket, head) => {
+			if (req.url) {
+				const { pathname } = (0, url.parse)(req.url);
+				if (pathname === "/") this._webSocketServer?.handleUpgrade(req, socket, head, (ws) => {
+					this._webSocketServer?.emit("connection", ws, req);
+				});
+			}
+		});
+		server.listen(Broker.DEFAULT_WEB_SOCKET_PORT);
+	}
+	async _takeAction(action, client) {
+		const { kind, payload } = action;
+		if (kind === require_Action.ActionKind.ADD_PUBLISHER) await this._addPublisher(payload, client);
+		if (kind === require_Action.ActionKind.UPDATE_PUBLISHER) await this._updatePublisher(payload, client);
+		if (kind === require_Action.ActionKind.ADD_SUBSCRIBER) await this._addSubscriber(payload, client);
+		if (kind === require_Action.ActionKind.EXIT_SUBSCRIBER) await this._removeSubscriber(payload, client);
+		if (kind === require_Action.ActionKind.EXIT_PUBLISHER) await this._removePublisher(payload, client);
+		if (kind === require_Action.ActionKind.ADD_WEB_CLIENT) await this._addWebClient(payload, client);
+		if (kind === require_Action.ActionKind.NOTIFY_WEB_CLIENT) await this._notifyWebClient(payload, client);
+		if (kind === require_Action.ActionKind.FETCH_TYPES) await this._fetchTypes(payload, client);
+		if (kind === require_Action.ActionKind.ADD_DYNAMIC_REMOTE) this._addDynamicRemote(payload);
+	}
+	async _addPublisher(context, client) {
+		const { name, ip, remoteTypeTarPath } = context ?? {};
+		const identifier = getIdentifier({
+			name,
+			ip
+		});
+		if (this._publisherMap.has(identifier)) {
+			fileLog(`[${require_Action.ActionKind.ADD_PUBLISHER}] ${identifier} has been added, this action will be ignored`, "Broker", "warn");
+			return;
+		}
+		try {
+			const publisher = new Publisher({
+				name,
+				ip,
+				remoteTypeTarPath,
+				ws: client
+			});
+			this._publisherMap.set(identifier, publisher);
+			fileLog(`[${require_Action.ActionKind.ADD_PUBLISHER}] ${identifier} Adding Publisher Succeed`, "Broker", "info");
+			const tmpSubScribers = this._getTmpSubScribers(identifier);
+			if (tmpSubScribers) {
+				fileLog(`[${require_Action.ActionKind.ADD_PUBLISHER}] consumeTmpSubscriber set ${publisher.name}’s subscribers `, "Broker", "info");
+				this._consumeTmpSubScribers(publisher, tmpSubScribers);
+				this._clearTmpSubScriberRelation(identifier);
+			}
+		} catch (err) {
+			const msg = error(err, require_Action.ActionKind.ADD_PUBLISHER, "Broker");
+			client.send(msg);
+			client.close();
+		}
+	}
+	async _updatePublisher(context, client) {
+		const { name, updateMode, updateKind, updateSourcePaths, remoteTypeTarPath, ip } = context ?? {};
+		const identifier = getIdentifier({
+			name,
+			ip
+		});
+		if (!this._publisherMap.has(identifier)) {
+			fileLog(`[${require_Action.ActionKind.UPDATE_PUBLISHER}] ${identifier} has not been started, this action will be ignored
+        this._publisherMap: ${JSON.stringify(this._publisherMap.entries())}
+        `, "Broker", "warn");
+			return;
+		}
+		try {
+			const publisher = this._publisherMap.get(identifier);
+			fileLog(`[${require_Action.ActionKind.UPDATE_PUBLISHER}] ${identifier} update, and notify subscribers to update`, "Broker", "info");
+			if (publisher) {
+				publisher.notifySubscribers({
+					remoteTypeTarPath,
+					name,
+					updateMode,
+					updateKind,
+					updateSourcePaths: updateSourcePaths || []
+				});
+				this._publisherMap.forEach((p) => {
+					if (p.name === publisher.name) return;
+					const dynamicRemoteInfo = p.dynamicRemoteMap.get(identifier);
+					if (dynamicRemoteInfo) {
+						fileLog(`dynamicRemoteInfo: ${JSON.stringify(dynamicRemoteInfo)}, identifier:${identifier} publish: ${p.name}`, "Broker", "info");
+						p.fetchRemoteTypes({
+							remoteInfo: dynamicRemoteInfo,
+							once: false
+						});
+					}
+				});
+			}
+		} catch (err) {
+			const msg = error(err, require_Action.ActionKind.UPDATE_PUBLISHER, "Broker");
+			client.send(msg);
+			client.close();
+		}
+	}
+	async _fetchTypes(context, _client) {
+		const { name, ip, remoteInfo } = context ?? {};
+		const identifier = getIdentifier({
+			name,
+			ip
+		});
+		try {
+			const publisher = this._publisherMap.get(identifier);
+			fileLog(`[${require_Action.ActionKind.FETCH_TYPES}] ${identifier} fetch types`, "Broker", "info");
+			if (publisher) publisher.fetchRemoteTypes({
+				remoteInfo,
+				once: true
+			});
+		} catch (err) {
+			fileLog(`[${require_Action.ActionKind.FETCH_TYPES}] ${identifier} fetch types fail , error info: ${err}`, "Broker", "error");
+		}
+	}
+	_addDynamicRemote(context) {
+		const { name, ip, remoteInfo, remoteIp } = context ?? {};
+		const identifier = getIdentifier({
+			name,
+			ip
+		});
+		const publisher = this._publisherMap.get(identifier);
+		const remoteId = getIdentifier({
+			name: remoteInfo.name,
+			ip: remoteIp
+		});
+		fileLog(`[${require_Action.ActionKind.ADD_DYNAMIC_REMOTE}] identifier:${identifier},publisher: ${publisher.name}, remoteId:${remoteId}`, "Broker", "error");
+		if (!publisher || publisher.dynamicRemoteMap.has(remoteId)) return;
+		publisher.dynamicRemoteMap.set(remoteId, remoteInfo);
+	}
+	async _addSubscriber(context, client) {
+		const { publishers, name: subscriberName } = context ?? {};
+		publishers.forEach((publisher) => {
+			const { name, ip } = publisher;
+			const identifier = getIdentifier({
+				name,
+				ip
+			});
+			if (!this._publisherMap.has(identifier)) {
+				fileLog(`[${require_Action.ActionKind.ADD_SUBSCRIBER}]: ${identifier} has not been started, ${subscriberName} will add the relation to tmp shelter`, "Broker", "warn");
+				this._addTmpSubScriberRelation({
+					name: getIdentifier({
+						name: context.name,
+						ip: context.ip
+					}),
+					client
+				}, publisher);
+				return;
+			}
+			try {
+				const registeredPublisher = this._publisherMap.get(identifier);
+				if (registeredPublisher) {
+					registeredPublisher.addSubscriber(getIdentifier({
+						name: subscriberName,
+						ip: context.ip
+					}), client);
+					fileLog(`[${require_Action.ActionKind.ADD_SUBSCRIBER}]: ${identifier} has been started, Adding Subscriber ${subscriberName} Succeed, this.__publisherMap are: ${JSON.stringify(Array.from(this._publisherMap.entries()))}`, "Broker", "info");
+					registeredPublisher.notifySubscriber(getIdentifier({
+						name: subscriberName,
+						ip: context.ip
+					}), {
+						updateKind: UpdateKind.UPDATE_TYPE,
+						updateMode: require_Action.UpdateMode.PASSIVE,
+						updateSourcePaths: [registeredPublisher.name],
+						remoteTypeTarPath: registeredPublisher.remoteTypeTarPath,
+						name: registeredPublisher.name
+					});
+					fileLog(`[${require_Action.ActionKind.ADD_SUBSCRIBER}]: notifySubscriber Subscriber ${subscriberName}, updateMode: "PASSIVE",  updateSourcePaths: ${registeredPublisher.name}`, "Broker", "info");
+				}
+			} catch (err) {
+				const msg = error(err, require_Action.ActionKind.ADD_SUBSCRIBER, "Broker");
+				client.send(msg);
+				client.close();
+			}
+		});
+	}
+	async _removeSubscriber(context, client) {
+		const { publishers } = context ?? {};
+		const subscriberIdentifier = getIdentifier({
+			name: context?.name,
+			ip: context?.ip
+		});
+		publishers.forEach((publisher) => {
+			const { name, ip } = publisher;
+			const identifier = getIdentifier({
+				name,
+				ip
+			});
+			const registeredPublisher = this._publisherMap.get(identifier);
+			if (!registeredPublisher) {
+				fileLog(`[${require_Action.ActionKind.EXIT_SUBSCRIBER}], ${identifier} does not exit `, "Broker", "warn");
+				return;
+			}
+			try {
+				fileLog(`[${require_Action.ActionKind.EXIT_SUBSCRIBER}], ${identifier} will exit `, "Broker", "INFO");
+				registeredPublisher.removeSubscriber(subscriberIdentifier);
+				this._clearTmpSubScriberRelation(identifier);
+				if (!registeredPublisher.hasSubscribes) this._publisherMap.delete(identifier);
+				if (!this.hasPublishers) this.exit();
+			} catch (err) {
+				const msg = error(err, require_Action.ActionKind.EXIT_SUBSCRIBER, "Broker");
+				client.send(msg);
+				client.close();
+			}
+		});
+	}
+	async _removePublisher(context, client) {
+		const { name, ip } = context ?? {};
+		const identifier = getIdentifier({
+			name,
+			ip
+		});
+		const publisher = this._publisherMap.get(identifier);
+		if (!publisher) {
+			fileLog(`[${require_Action.ActionKind.EXIT_PUBLISHER}]: ${identifier}} has not been added, this action will be ingored`, "Broker", "warn");
+			return;
+		}
+		try {
+			const { subscribers } = publisher;
+			subscribers.forEach((subscriber, subscriberIdentifier) => {
+				this._addTmpSubScriberRelation({
+					name: subscriberIdentifier,
+					client: subscriber
+				}, {
+					name: publisher.name,
+					ip: publisher.ip
+				});
+				fileLog(`[${require_Action.ActionKind.EXIT_PUBLISHER}]: ${identifier} is removing , subscriber: ${subscriberIdentifier} will be add  tmpSubScriberRelation`, "Broker", "info");
+			});
+			this._publisherMap.delete(identifier);
+			fileLog(`[${require_Action.ActionKind.EXIT_PUBLISHER}]: ${identifier} is removed `, "Broker", "info");
+			if (!this.hasPublishers) {
+				fileLog(`[${require_Action.ActionKind.EXIT_PUBLISHER}]: _publisherMap is empty, all server will exit `, "Broker", "warn");
+				this.exit();
+			}
+		} catch (err) {
+			const msg = error(err, require_Action.ActionKind.EXIT_PUBLISHER, "Broker");
+			client.send(msg);
+			client.close();
+		}
+	}
+	async _addWebClient(context, client) {
+		const { name } = context ?? {};
+		const identifier = getIdentifier({ name });
+		if (this._webClientMap.has(identifier)) fileLog(`${identifier}} has been added, this action will override prev WebClient`, "Broker", "warn");
+		try {
+			this._webClientMap.set(identifier, client);
+			fileLog(`${identifier} adding WebClient Succeed`, "Broker", "info");
+		} catch (err) {
+			const msg = error(err, require_Action.ActionKind.ADD_WEB_CLIENT, "Broker");
+			client.send(msg);
+			client.close();
+		}
+	}
+	async _notifyWebClient(context, client) {
+		const { name, updateMode } = context ?? {};
+		const identifier = getIdentifier({ name });
+		const webClient = this._webClientMap.get(identifier);
+		if (!webClient) {
+			fileLog(`[${require_Action.ActionKind.NOTIFY_WEB_CLIENT}] ${identifier} has not been added, this action will be ignored`, "Broker", "warn");
+			return;
+		}
+		try {
+			const api = new ReloadWebClientAPI({
+				name,
+				updateMode
+			});
+			webClient.send(JSON.stringify(api));
+			fileLog(`[${require_Action.ActionKind.NOTIFY_WEB_CLIENT}] Notify ${name} WebClient Succeed`, "Broker", "info");
+		} catch (err) {
+			const msg = error(err, require_Action.ActionKind.NOTIFY_WEB_CLIENT, "Broker");
+			client.send(msg);
+			client.close();
+		}
+	}
+	_addTmpSubScriberRelation(subscriber, publisher) {
+		const publisherIdentifier = getIdentifier({
+			name: publisher.name,
+			ip: publisher.ip
+		});
+		const subscriberIdentifier = subscriber.name;
+		const shelter = this._tmpSubscriberShelter.get(publisherIdentifier);
+		if (!shelter) {
+			const map = /* @__PURE__ */ new Map();
+			map.set(subscriberIdentifier, subscriber);
+			this._tmpSubscriberShelter.set(publisherIdentifier, {
+				subscribers: map,
+				timestamp: Date.now()
+			});
+			fileLog(`[AddTmpSubscriberRelation] ${publisherIdentifier}'s subscriber has ${subscriberIdentifier} `, "Broker", "info");
+			return;
+		}
+		if (shelter.subscribers.get(subscriberIdentifier)) {
+			fileLog(`[AddTmpSubscriberRelation] ${publisherIdentifier} and ${subscriberIdentifier} relation has been added`, "Broker", "warn");
+			shelter.subscribers.set(subscriberIdentifier, subscriber);
+			shelter.timestamp = Date.now();
+		} else {
+			fileLog(`AddTmpSubscriberLog ${publisherIdentifier}'s shelter has been added, update shelter.subscribers ${subscriberIdentifier}`, "Broker", "warn");
+			shelter.subscribers.set(subscriberIdentifier, subscriber);
+		}
+	}
+	_getTmpSubScribers(publisherIdentifier) {
+		return this._tmpSubscriberShelter.get(publisherIdentifier)?.subscribers;
+	}
+	_consumeTmpSubScribers(publisher, tmpSubScribers) {
+		tmpSubScribers.forEach((tmpSubScriber, identifier) => {
+			fileLog(`notifyTmpSubScribers ${publisher.name} will be add a subscriber: ${identifier} `, "Broker", "warn");
+			publisher.addSubscriber(identifier, tmpSubScriber.client);
+			publisher.notifySubscriber(identifier, {
+				updateKind: UpdateKind.UPDATE_TYPE,
+				updateMode: require_Action.UpdateMode.PASSIVE,
+				updateSourcePaths: [publisher.name],
+				remoteTypeTarPath: publisher.remoteTypeTarPath,
+				name: publisher.name
+			});
+		});
+	}
+	_clearTmpSubScriberRelation(identifier) {
+		this._tmpSubscriberShelter.delete(identifier);
+	}
+	_clearTmpSubScriberRelations() {
+		this._tmpSubscriberShelter.clear();
+	}
+	_disconnect() {
+		this._publisherMap.forEach((publisher) => {
+			publisher.close();
+		});
+	}
+	_setSchedule() {
+		const rule = new node_schedule.default.RecurrenceRule();
+		if (Number(process.env["FEDERATION_SERVER_TEST"])) {
+			const interval = Number(process.env["FEDERATION_SERVER_TEST"]) / 1e3;
+			const second = [];
+			for (let i = 0; i < 60; i = i + interval) second.push(i);
+			rule.second = second;
+		} else {
+			rule.second = 0;
+			rule.hour = [
+				0,
+				3,
+				6,
+				9,
+				12,
+				15,
+				18
+			];
+			rule.minute = 0;
+		}
+		const serverTest = Number(process.env["FEDERATION_SERVER_TEST"]);
+		this._scheduleJob = node_schedule.default.scheduleJob(rule, () => {
+			this._tmpSubscriberShelter.forEach((tmpSubscriber, identifier) => {
+				fileLog(` _clearTmpSubScriberRelation ${identifier},  ${Date.now() - tmpSubscriber.timestamp >= (process.env["GARFISH_MODULE_SERVER_TEST"] ? serverTest : Broker.DEFAULT_WAITING_TIME)}`, "Broker", "info");
+				if (Date.now() - tmpSubscriber.timestamp >= (process.env["FEDERATION_SERVER_TEST"] ? serverTest : Broker.DEFAULT_WAITING_TIME)) this._clearTmpSubScriberRelation(identifier);
+			});
+		});
+	}
+	_clearSchedule() {
+		if (!this._scheduleJob) return;
+		this._scheduleJob.cancel();
+		this._scheduleJob = null;
+	}
+	_stopWhenSIGTERMOrSIGINT() {
+		process.on("SIGTERM", () => {
+			this.exit();
+		});
+		process.on("SIGINT", () => {
+			this.exit();
+		});
+	}
+	_handleUnexpectedExit() {
+		process.on("unhandledRejection", (error) => {
+			console.error("Unhandled Rejection Error: ", error);
+			fileLog(`Unhandled Rejection Error: ${error}`, "Broker", "fatal");
+			process.exit(1);
+		});
+		process.on("uncaughtException", (error) => {
+			console.error("Unhandled Exception Error: ", error);
+			fileLog(`Unhandled Rejection Error: ${error}`, "Broker", "fatal");
+			process.exit(1);
+		});
+	}
+	async start() {}
+	exit() {
+		const brokerExitLog = new BrokerExitLog();
+		this.broadcast(JSON.stringify(brokerExitLog));
+		this._disconnect();
+		this._clearSchedule();
+		this._clearTmpSubScriberRelations();
+		this._webSocketServer && this._webSocketServer.close();
+		this._secureWebSocketServer && this._secureWebSocketServer.close();
+		process.exit(0);
+	}
+	broadcast(message) {
+		fileLog(`[broadcast] exit info : ${JSON.stringify(message)}`, "Broker", "warn");
+		this._webSocketServer?.clients.forEach((client) => {
+			client.send(JSON.stringify(message));
+		});
+		this._secureWebSocketServer?.clients.forEach((client) => {
+			client.send(JSON.stringify(message));
+		});
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'APIKind', {
+  enumerable: true,
+  get: function () {
+    return APIKind;
+  }
+});
+Object.defineProperty(exports, 'Broker', {
+  enumerable: true,
+  get: function () {
+    return Broker;
+  }
+});
+Object.defineProperty(exports, 'LogKind', {
+  enumerable: true,
+  get: function () {
+    return LogKind;
+  }
+});
+Object.defineProperty(exports, 'UpdateKind', {
+  enumerable: true,
+  get: function () {
+    return UpdateKind;
+  }
+});
+Object.defineProperty(exports, 'fib', {
+  enumerable: true,
+  get: function () {
+    return fib;
+  }
+});
+Object.defineProperty(exports, 'fileLog', {
+  enumerable: true,
+  get: function () {
+    return fileLog;
+  }
+});
+Object.defineProperty(exports, 'getFreePort', {
+  enumerable: true,
+  get: function () {
+    return getFreePort;
+  }
+});
+Object.defineProperty(exports, 'getIPV4', {
+  enumerable: true,
+  get: function () {
+    return getIPV4;
+  }
+});
+Object.defineProperty(exports, 'getIdentifier', {
+  enumerable: true,
+  get: function () {
+    return getIdentifier;
+  }
+});
+Object.defineProperty(exports, 'logger', {
+  enumerable: true,
+  get: function () {
+    return logger;
+  }
+});