@fastcar/template-microservices 1.0.0

package/template/src/servers/base/service/RouterService.ts

@@ -0,0 +1,185 @@
+import { ReqSession } from "@/types/ReqSession";
+import { Autowired, HotterCallBack, Log, Service } from "@fastcar/core/annotation";
+import { ClientRequestStatic, ClientSession, RetryConfig } from "@fastcar/rpc";
+import Result from "@/common/Result";
+import Code from "@/common/Code";
+import { ValidationUtil } from "@fastcar/core/utils";
+import CenterClient from "@/servers/base/service/CenterClient";
+import { ResultType } from "@/types/ResultType";
+import { Logger } from "@fastcar/core";
+import { nanoid } from "nanoid";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import { ClientSimpleSession } from "@/types/ClientSimpleSession";
+import CODE from "@/common/Code";
+
+/**
+ * @version 1.0 路由导航
+ */
+@HotterCallBack("loadRouteNav")
+@Service
+export default class RouterService {
+	@Autowired
+	private client!: CenterClient;
+
+	@Log()
+	private logger!: Logger;
+
+	public routeNavigation: Record<string, (serverType: string, session: ClientSession) => string> = this.getRouteNav();
+
+	loadRouteNav() {
+		this.logger.debug(`加载导航路由`);
+		this.routeNavigation = this.getRouteNav();
+	}
+
+	//根据uid一致性找servers
+	getServerByUid(serverType: string, session: ClientSession) {
+		let uid: number = session.settings.get(SessionAttribute.uid);
+		if (!uid) {
+			return "";
+		}
+
+		let m = this.client.getServerMap();
+		let list = m.findByAtts({ serverType }).sort((a, b) => {
+			return a.serviceId < b.serviceId ? -1 : 1;
+		});
+
+		if (list.length == 0) {
+			return "";
+		}
+
+		return list[uid % list.length]?.serviceId;
+	}
+
+	getRouteNav() {
+		return {
+			common: (serverType: string) => {
+				let m = this.client.getServerMap();
+				let list = m.findByAtts({ serverType, status: true });
+
+				if (list.length == 0) {
+					return "";
+				}
+				if (list.length == 1) {
+					return list[0].serviceId;
+				}
+
+				let index = Math.floor(Math.random() * list.length);
+
+				return list[index].serviceId || "";
+			},
+			connector: (serverType: string, session: ClientSimpleSession) => {
+				return session.settings.get(SessionAttribute.serviceId);
+			},
+			user: (serverType: string, session: ClientSession) => {
+				let uid: number = session.settings.get(SessionAttribute.uid);
+				if (!uid) {
+					return "";
+				}
+
+				let m = this.client.getServerMap();
+				let list = m.findByAtts({ serverType }).sort((a, b) => {
+					return a.serviceId < b.serviceId ? -1 : 1;
+				});
+
+				if (list.length == 0) {
+					return "";
+				}
+
+				return list[uid % list.length]?.serviceId;
+			},
+		};
+	}
+
+	/**
+	 * @version 1.0 采用懒加载模式 当客户端连接没有时自动创建连接
+	 */
+	async request<T, K>({
+		forward = false,
+		serverType,
+		session,
+		data,
+		url,
+		opts,
+		customServiceId,
+	}: {
+		url: string;
+		data?: T;
+		opts?: RetryConfig;
+		session?: ClientSimpleSession;
+		serverType: string;
+		forward?: boolean;
+		customServiceId?: string;
+		//指定一个serviceID
+	}): Promise<ResultType<K>> {
+		//计算类型
+		let fn = Reflect.get(this.routeNavigation, serverType);
+		if (!fn) {
+			fn = this.routeNavigation.common;
+		}
+
+		if (!session) {
+			session = {
+				sessionId: nanoid(),
+				connectedTime: Date.now(),
+				settings: new Map(),
+			};
+		}
+
+		let serviceId = customServiceId || (await Promise.resolve(Reflect.apply(fn, this, [serverType, session])));
+		if (!serviceId) {
+			return Result.errorCode(Code.SYS.UNAVAILABLE);
+		}
+
+		//找client
+		let rpcClient = await this.client.getRemoteClientByserviceId(serviceId);
+		if (!rpcClient) {
+			this.logger.info(`${serviceId} service unavailable cid:${customServiceId} serverType:${serverType} forward:${forward} url:${url}`);
+			return Result.errorCode(Code.SYS.UNAVAILABLE);
+		}
+
+		let sendData: any = {
+			session: this.sessionTOReqSession(session),
+			forward,
+		};
+
+		if (ValidationUtil.isNotNull(data)) {
+			Reflect.set(sendData, "data", data);
+		}
+
+		//应该是存在code响应码
+		let res: ResultType<K> | null = await ClientRequestStatic({
+			client: rpcClient,
+			url,
+			data: sendData,
+			opts,
+		});
+
+		if (!res) {
+			return Result.errorCode(CODE.SYS.FAIL);
+		}
+
+		return res;
+	}
+
+	sessionTOReqSession(session: ClientSimpleSession): ReqSession {
+		let s: ReqSession = {
+			sessionId: session.sessionId,
+			connectedTime: session.connectedTime,
+			settings: Object.fromEntries(session.settings.entries()),
+			cid: session.cid,
+		};
+
+		return s;
+	}
+
+	reqSessionToSession(session: ReqSession): ClientSimpleSession {
+		let s: ClientSimpleSession = {
+			sessionId: session.sessionId,
+			connectedTime: session.connectedTime,
+			settings: new Map(Object.entries(session.settings)),
+			cid: session.cid,
+		};
+
+		return s;
+	}
+}

package/template/src/servers/center/app.ts

@@ -0,0 +1,14 @@
+import { Application } from "@fastcar/core/annotation";
+import BaseServer from "../base/BaseServer";
+import { RPCMiddleware } from "@fastcar/rpc/annotation";
+import parseSession from "@/middleware/parseSession";
+import checkForm from "@/middleware/checkForm";
+
+@Application
+@RPCMiddleware(checkForm, parseSession)
+class APP extends BaseServer {
+	constructor() {
+		super();
+	}
+}
+export default new APP();

package/template/src/servers/center/controller/EntryController.ts

@@ -0,0 +1,89 @@
+import { Autowired, Controller, Log, Rule, ValidForm } from "@fastcar/core/annotation";
+import { ClientSession, RpcContext, RpcServer } from "@fastcar/rpc";
+import { RPCMethod } from "@fastcar/rpc/annotation";
+import DataService from "@/servers/base/service/DataService";
+import Result from "@/common/Result";
+import Code from "@/common/Code";
+import ServerManager from "../service/ServerManager";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import { ValidationUtil } from "@fastcar/core/utils";
+import { ServerKind } from "@/common/Constant";
+import { Logger } from "@fastcar/core";
+
+type DisconnectType = {
+	session: ClientSession;
+	reason: string;
+};
+
+@Controller
+export default class EntryController {
+	@Autowired
+	private rpcServer!: RpcServer;
+
+	@Autowired
+	private dataService!: DataService;
+
+	@Autowired
+	private serverManager!: ServerManager;
+
+	@Log()
+	private logger!: Logger;
+
+	@RPCMethod()
+	@ValidForm
+	async login(
+		@Rule({
+			serviceId: { required: true },
+			token: { required: true },
+		})
+		{ serviceId, token }: { serviceId: string; token: string },
+		ctx: RpcContext
+	) {
+		//进行校验是否相同
+		let serverMeta = this.dataService.getServerMeta(serviceId);
+		if (!serverMeta) {
+			return Result.errorCode(Code.CENTER.SERVER_NOT_FOUND);
+		}
+
+		if (serverMeta.token != token) {
+			return Result.errorCode(Code.CENTER.SERVER_TOKEN_ERROR);
+		}
+
+		let serverKind = this.dataService.getServerKindByServerType(serverMeta.serverType);
+		this.serverManager.registrationService(serviceId, serverMeta.serverType);
+
+		//加入频道 绑定会话
+		this.rpcServer.getSocketManager().joinChannel(ctx.sessionId, this.dataService.getChannelKindByServerType(serverMeta.serverType));
+		if (serviceId != this.dataService.getCurrServiceId()) {
+			this.rpcServer.getSocketManager().bindCustomID(serviceId, ctx.sessionId);
+			this.rpcServer.getSocketManager().joinChannelByCustomId(serviceId, ServerKind.remote);
+		}
+
+		ctx.settings.set(SessionAttribute.logged, true);
+		ctx.settings.set(SessionAttribute.serviceId, serviceId);
+		ctx.settings.set(SessionAttribute.center_serviceId, serviceId);
+		ctx.settings.set(SessionAttribute.serverKind, serverKind);
+		ctx.settings.set(SessionAttribute.serverType, serverMeta.serverType);
+
+		return Result.ok({ serverList: this.serverManager.getServerList() });
+	}
+
+	@RPCMethod()
+	disconnect({ session, reason }: DisconnectType, ctx: RpcContext) {
+		let serviceId = ctx.settings.get(SessionAttribute.center_serviceId);
+		if (!serviceId) {
+			return Result.ok();
+		}
+
+		let serverType = ctx.settings.get(SessionAttribute.serverType);
+		if (ValidationUtil.isNull(serviceId)) {
+			return Result.errorCode(Code.CENTER.SERVER_NOT_LOGIN);
+		}
+
+		this.rpcServer.getSocketManager().leaveChannel(session.sessionId, this.dataService.getChannelKindByServerType(serverType));
+		this.logger.info(`disconnect---------${serviceId}`);
+		this.serverManager.removeService(serviceId);
+
+		return Result.ok();
+	}
+}

package/template/src/servers/center/controller/ServerController.ts

@@ -0,0 +1,62 @@
+import AuthServiceRole from "@/annotation/AuthServiceRole";
+import { ChannelKind, ServerCommonUrl, ServerKind } from "@/common/Constant";
+import Result from "@/common/Result";
+import { Autowired, Controller, Log, Rule, ValidForm } from "@fastcar/core/annotation";
+import { RPC, RPCMethod } from "@fastcar/rpc/annotation";
+import ServerManager from "../service/ServerManager";
+import { InteractiveMode, RpcServer } from "@fastcar/rpc";
+import { Logger } from "@fastcar/core";
+
+@Controller
+@RPC("/center")
+@AuthServiceRole(ServerKind.center, ServerKind.remote)
+export default class ServerController {
+	@Autowired
+	private serverManager!: ServerManager;
+
+	@Autowired
+	private rpcServer!: RpcServer;
+
+	@Log()
+	private logger!: Logger;
+
+	@RPCMethod()
+	getServerList() {
+		return Result.ok(this.serverManager.getServerList());
+	}
+
+	@RPCMethod()
+	rebalance() {
+		this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.REMOTE, {
+			url: ServerCommonUrl.ServiceBalance,
+			mode: InteractiveMode.notify,
+		});
+		return Result.ok();
+	}
+
+	@RPCMethod()
+	@ValidForm
+	syncConfig(
+		@Rule({
+			key: { required: true },
+			data: {
+				required: true,
+				type: "array",
+			},
+		})
+		info: {
+			key: string;
+			data: Object;
+		}
+	) {
+		//如果有多个中心服务器 应该去通知其他中心服务对应的参数
+		this.logger.info(`同步配置-------------`);
+		this.rpcServer.getSocketManager().sendMsgToCustomIdByChannel(ServerKind.remote, {
+			url: ServerCommonUrl.ServiceSyncConfig,
+			mode: InteractiveMode.notify,
+			data: info,
+		});
+
+		return Result.ok();
+	}
+}

package/template/src/servers/center/service/ServerManager.ts

@@ -0,0 +1,336 @@
+import ConnectorUtils from "@/utils/ConnectorUtils";
+import Code from "@/common/Code";
+import { ChannelKind, ServerCommonUrl, ServerKind } from "@/common/Constant";
+import DataService from "@/servers/base/service/DataService";
+import { ServerStatus } from "@/types/ServerMeta";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import { DataMap, Logger, FastCarApplication } from "@fastcar/core";
+import { Autowired, Log, Service, Value } from "@fastcar/core/annotation";
+import { ClientRequestStatic, InteractiveMode, RpcAsyncService, RpcClient, RpcServer } from "@fastcar/rpc";
+import { EnableScheduling, ScheduledInterval, TimeUnit, TimeUnitNum } from "@fastcar/timer";
+
+@Service
+@EnableScheduling
+export default class ServerManager implements RpcAsyncService {
+	private serverMap: DataMap<string, ServerStatus>;
+
+	@Autowired
+	private dataService!: DataService;
+
+	@Autowired
+	private rpcServer!: RpcServer;
+
+	@Log()
+	private logger!: Logger;
+
+	private centerClientMap: DataMap<string, RpcClient>;
+
+	@Autowired
+	private app!: FastCarApplication;
+
+	@Value("application.env")
+	env!: string;
+
+	constructor() {
+		this.serverMap = new DataMap();
+		this.centerClientMap = new DataMap();
+	}
+
+	loadServerList() {
+		let obj = this.dataService.getMicroservices();
+		let existServerIds: string[] = [];
+		let change = false;
+
+		for (let serverType of Object.keys(obj)) {
+			let item = obj[serverType];
+			item.servers.forEach((citem) => {
+				existServerIds.push(citem.serviceId);
+				if (!this.serverMap.has(citem.serviceId)) {
+					change = true;
+					this.serverMap.set(citem.serviceId, {
+						serviceId: citem.serviceId,
+						status: false,
+						createTime: Date.now(),
+						updateTime: Date.now(),
+						serverType,
+						centerId: "",
+					});
+				}
+			});
+		}
+
+		//刷新服务列表
+		let ids = [...this.serverMap.keys()];
+		for (let id of ids) {
+			if (!existServerIds.includes(id)) {
+				this.serverMap.delete(id);
+				change = true;
+			}
+		}
+
+		//广播全局
+		if (change) {
+			this.logger.debug(this.getServerList());
+			this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.REMOTE, {
+				url: ServerCommonUrl.ServiceStatusAllNotify,
+				data: this.getServerList(),
+				mode: InteractiveMode.notify,
+			});
+		}
+	}
+
+	//注册服务
+	registrationService(serviceId: string, serverType: string): ServerStatus {
+		this.logger.info(`${serviceId} Service Registration`);
+
+		let centerId = this.dataService.getCurrServiceId();
+
+		let serverStatus: ServerStatus = { serviceId, status: true, createTime: Date.now(), updateTime: Date.now(), serverType, centerId };
+		this.updateServerStatus(serverStatus);
+		this.broadcastUpdateService(serviceId);
+		return serverStatus;
+	}
+
+	//更新服务
+	updateServiceUpdateTime(serviceId: string) {
+		let item = this.serverMap.get(serviceId);
+		if (item) {
+			item.updateTime = Date.now();
+			if (item.status) {
+				//重新登录
+				return true;
+			} else {
+				this.logger.debug(`service status is error ${serviceId}`);
+			}
+		} else {
+			this.logger.debug(`service not found ${serviceId}`);
+		}
+
+		return false;
+	}
+
+	//移除服务
+	removeService(serviceId: string): boolean {
+		let item = this.serverMap.get(serviceId);
+
+		if (!item) {
+			return false;
+		}
+
+		this.logger.debug(`${serviceId} Service Remove`);
+		item.status = false;
+		item.createTime = Date.now();
+		this.updateServerStatus(item);
+
+		//如果是中心服务则找出挂载在这个上面的服务
+		let kind = this.dataService.getServerKindByServerType(item.serverType);
+		if (kind == ServerKind.center) {
+			let statusList = this.serverMap.findByAtts({ centerId: serviceId });
+			statusList.forEach((citem: ServerStatus) => {
+				if (citem.serverType.toLowerCase() == ServerKind.center) {
+					return;
+				}
+
+				// this.logger.debug(`${citem.serviceId} Service Remove`);
+				citem.status = false;
+				this.updateServerStatus(citem);
+			});
+
+			this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.REMOTE, {
+				url: ServerCommonUrl.ServiceStatusAllNotify,
+				data: this.getServerList(),
+				mode: InteractiveMode.notify,
+			});
+		} else {
+			this.broadcastUpdateService(serviceId);
+		}
+
+		return true;
+	}
+
+	//增量通知客户端
+	broadcastUpdateService(serviceId: string) {
+		let status = this.serverMap.get(serviceId);
+
+		if (status) {
+			this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.REMOTE, {
+				url: ServerCommonUrl.ServiceStatusNotify,
+				data: status,
+				mode: InteractiveMode.notify,
+			});
+
+			let kind = this.dataService.getServerKindByServerType(status.serverType);
+			if (kind == ServerKind.remote) {
+				this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.CENTER, {
+					url: ServerCommonUrl.ServiceStatusNotify,
+					data: status,
+					mode: InteractiveMode.notify,
+				});
+			}
+		}
+	}
+
+	getServerList() {
+		return this.serverMap.toValues().sort(); //字典排序
+	}
+
+	//这边有个定时任务检测中心服务是否
+	//1.找所有的中心服务器 并进行互连
+	//2.逐一进行登录 并将服务列表进行比对汇总
+	@ScheduledInterval({ fixedRate: 5, fixedRateString: TimeUnit.second, initialDelay: 500 })
+	async checkOtherCenter() {
+		let centerInfo = this.dataService.getServerGroup(ServerKind.center);
+		let serviceId = this.app.getSetting(SessionAttribute.serviceId);
+		let flag = false;
+
+		for (let server of centerInfo.servers) {
+			if (server.serviceId == serviceId) {
+				continue;
+			}
+
+			let client = this.centerClientMap.get(server.serviceId);
+			if (!client || !client.isConnect()) {
+				//先关掉前一个
+				if (client) {
+					client.close();
+					this.centerClientMap.delete(server.serviceId);
+				}
+				this.logger.debug("开始检测登录");
+				for (let citem of server.list) {
+					client = new RpcClient(
+						{
+							url: ConnectorUtils.getConnectUrl(citem, server.host), //连接地址
+							type: citem.type, //具体为哪一种型号的连接器
+							extra: citem.clientExtra, //第三方拓展参数
+							encode: citem.encode, //解码器
+							decode: citem.decode,
+							secure: citem.secure,
+							ssl: citem.server.ssl,
+							disconnectInterval: citem.disconnectInterval,
+							connectionLimit: citem.connectionLimit || 1,
+						},
+						this,
+						citem.retry
+					);
+					await client.start();
+					if (client.isConnect()) {
+						this.centerClientMap.set(server.serviceId, client);
+						let loginFlag = await this.loginOtherCenter(server.serviceId);
+						if (!flag && loginFlag) {
+							flag = true;
+						}
+						this.logger.debug("校验完毕");
+						break;
+					} else {
+						client.close();
+					}
+				}
+			}
+
+			if (!this.centerClientMap.has(server.serviceId)) {
+				this.logger.error(`${server.serviceId} connection lost`);
+			}
+		}
+
+		if (flag) {
+			//全局消息广播
+			this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.REMOTE, {
+				url: ServerCommonUrl.ServiceStatusAllNotify,
+				data: this.getServerList(),
+				mode: InteractiveMode.notify,
+			});
+		}
+	}
+
+	//定时检测健康状态
+	@ScheduledInterval({ fixedRate: 1, fixedRateString: TimeUnit.minute, initialDelay: 500 })
+	checkHealth() {
+		let list = this.serverMap.toValues();
+		let nowTime = Date.now();
+
+		list.forEach((item) => {
+			if (item.centerId == this.dataService.getCurrServiceId()) {
+				//检测更新时间
+				if (nowTime - item.updateTime > TimeUnitNum.minute * 5 && item.status) {
+					this.logger.info(`removeService------------${item.serviceId}`);
+					this.removeService(item.serviceId);
+				}
+			}
+		});
+	}
+
+	async loginOtherCenter(serviceId: string) {
+		let client = this.centerClientMap.get(serviceId);
+
+		if (client) {
+			let centerInfo = this.dataService.getServerGroup(ServerKind.center);
+
+			let res = await ClientRequestStatic<{ serviceId: string; token: string }, { code: number; data: { serverList: ServerStatus[] } }>({
+				url: "/login",
+				data: {
+					serviceId: this.app.getSetting(SessionAttribute.serviceId),
+					token: centerInfo.token,
+				},
+				client,
+				// opts: {
+				// 	timeout: 1000,
+				// 	retryCount: 1,
+				// },
+			});
+			if (!res || res.code != Code.SYS.OK) {
+				this.logger.error(`login center error`);
+				client.close();
+			} else {
+				//同步list
+				let updateFlagNotify: boolean = false;
+				res.data.serverList.forEach((s) => {
+					let f = this.updateServerStatus(s);
+					if (!updateFlagNotify && f) {
+						updateFlagNotify = true;
+					}
+				});
+
+				return updateFlagNotify;
+			}
+		}
+
+		return false;
+	}
+
+	updateServerStatus(s: ServerStatus): boolean {
+		let flag: boolean = false;
+		let serviceId = s.serviceId;
+		let beforeStatus = this.serverMap.get(serviceId);
+
+		if (!beforeStatus) {
+			this.serverMap.set(serviceId, s);
+			flag = true;
+		} else {
+			if (s.createTime > beforeStatus.createTime) {
+				this.serverMap.set(serviceId, s);
+				flag = true;
+			}
+		}
+
+		return flag;
+	}
+
+	async handleMsg(url: string, data: Object): Promise<void | Object> {
+		switch (url) {
+			case ServerCommonUrl.ServiceStatusNotify: {
+				let m = data as ServerStatus;
+				if (this.updateServerStatus(m)) {
+					this.rpcServer.getSocketManager().sendMsgByChannel(ChannelKind.REMOTE, {
+						url: ServerCommonUrl.ServiceStatusNotify,
+						data: m,
+						mode: InteractiveMode.notify,
+					});
+				}
+				break;
+			}
+			default: {
+				break;
+			}
+		}
+	}
+}