@fastcar/template-microservices 1.0.0

package/template/src/servers/chat/RoomHandler.ts

@@ -0,0 +1,65 @@
+import { Autowired, Controller, Rule, ValidForm } from "@fastcar/core/annotation";
+import { InteractiveMode } from "@fastcar/rpc";
+import { RPC, RPCMethod } from "@fastcar/rpc/annotation";
+import RoomService from "./RoomService";
+import Result from "@/common/Result";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import { ForwardRpcContext } from "@/types/ForwardRpcContext";
+import AuthServiceRole from "@/annotation/AuthServiceRole";
+import { ServerKind } from "@/common/Constant";
+import RouterService from "@/servers/base/service/RouterService";
+
+@Controller
+@RPC("/room")
+export default class RoomHandler {
+	@Autowired
+	private roomService!: RoomService;
+
+	@Autowired
+	private routerService!: RouterService;
+
+	//加入世界
+	@RPCMethod()
+	@AuthServiceRole(ServerKind.remote)
+	join({}, { session }: ForwardRpcContext) {
+		this.roomService.add(session.settings.get(SessionAttribute.uid), session);
+		return Result.ok();
+	}
+
+	//离开世界
+	@RPCMethod()
+	@AuthServiceRole(ServerKind.remote)
+	leave({}, { session }: ForwardRpcContext) {
+		this.roomService.del(session.settings.get(SessionAttribute.uid));
+		return Result.ok();
+	}
+
+	//向别人发送消息
+	@RPCMethod()
+	@ValidForm
+	@AuthServiceRole(ServerKind.front)
+	sendMsg(
+		@Rule({
+			msg: { maxSize: 1000, required: true },
+			toUid: { required: true, type: "number" },
+		})
+		{ msg, toUid }: { toUid: number; msg: string }
+	) {
+		let otherSession = this.roomService.getSid(toUid);
+		if (!otherSession) {
+			return Result.ok();
+		}
+
+		this.routerService.request({
+			url: "/channelRemote/broadcastBySessionId",
+			serverType: "connector",
+			data: {
+				data: { data: msg, url: "/room/notify", mode: InteractiveMode.notify },
+				sessionId: otherSession.sessionId,
+			},
+			session: otherSession,
+		});
+
+		return Result.ok();
+	}
+}

package/template/src/servers/chat/RoomService.ts

@@ -0,0 +1,24 @@
+import { Service } from "@fastcar/core/annotation";
+import { DataMap } from "@fastcar/core";
+import { ClientSession } from "@fastcar/rpc";
+
+@Service
+export default class RoomService {
+	private onlineMap: DataMap<number, ClientSession>;
+
+	constructor() {
+		this.onlineMap = new DataMap();
+	}
+
+	add(uid: number, session: ClientSession) {
+		this.onlineMap.set(uid, session);
+	}
+
+	getSid(uid: number) {
+		return this.onlineMap.get(uid);
+	}
+
+	del(uid: number) {
+		this.onlineMap.delete(uid);
+	}
+}

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

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

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

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

package/template/src/servers/connector/controller/AccountHandler.ts

@@ -0,0 +1,80 @@
+import { Autowired, Controller, Rule, ValidForm } from "@fastcar/core/annotation";
+import { ClientSession, RpcContext, RpcServer } from "@fastcar/rpc";
+import { RPC, RPCMethod } from "@fastcar/rpc/annotation";
+import Result from "@/common/Result";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import RouterService from "@/servers/base/service/RouterService";
+import { ChannelKind, ServerKind } from "@/common/Constant";
+import Code from "@/common/Code";
+import DataService from "@/servers/base/service/DataService";
+
+type DisconnectType = {
+	session: ClientSession;
+	reason: string;
+};
+
+@Controller
+export default class AccountHandler {
+	@Autowired
+	private rpcServer!: RpcServer;
+
+	@Autowired
+	private routerService!: RouterService;
+
+	@Autowired
+	private dataService!: DataService;
+
+	@RPCMethod("/account/login")
+	@ValidForm
+	async login(
+		@Rule({
+			uid: { required: true, type: "number" },
+		})
+		{ uid }: { uid: number },
+		ctx: RpcContext
+	) {
+		//这边做一个校验 如果当前不是front连进来的则拒绝
+		let socketMgr = this.rpcServer.getSocketManager();
+		let socketServer = socketMgr.getSocketServerBySessionId(ctx.sessionId);
+
+		if (!socketServer?.getConfig().extra?.front) {
+			this.rpcServer.kickSessionId(ctx.sessionId, Code.COMMON.SERVER_CONNECT_FORBID.toString());
+			return Result.errorCode(Code.COMMON.SERVER_CONNECT_FORBID);
+		}
+
+		//这边可以进行校验
+		//加入频道 绑定会话
+		socketMgr.bindCustomID(uid.toString(), ctx.sessionId);
+		socketMgr.joinChannelByCustomId(uid.toString(), ChannelKind.FRONT);
+		ctx.settings.set(SessionAttribute.logged, true);
+		ctx.settings.set(SessionAttribute.uid, uid);
+		ctx.settings.set(SessionAttribute.serverKind, ServerKind.front);
+		ctx.settings.set(SessionAttribute.serviceId, this.dataService.getCurrServiceId());
+		ctx.settings.set(SessionAttribute.loginTime, Date.now());
+
+		this.routerService.request({
+			url: "/room/join",
+			serverType: "chat",
+			session: ctx,
+		});
+
+		//便于客户端同步
+		return Result.ok();
+	}
+
+	@RPCMethod()
+	async disconnect({ session, reason }: DisconnectType, ctx: RpcContext) {
+		let uid: number = ctx.settings.get(SessionAttribute.uid);
+		if (!!uid) {
+			this.rpcServer.getSocketManager().removeCustomID(uid.toString());
+
+			this.routerService.request({
+				url: "/room/leave",
+				serverType: "chat",
+				session,
+			});
+		}
+
+		return Result.ok();
+	}
+}

package/template/src/servers/connector/controller/ChannelRemote.ts

@@ -0,0 +1,63 @@
+import { Autowired, Controller, Log } from "@fastcar/core/annotation";
+import { RpcServer, RpcMessage, InteractiveMode } from "@fastcar/rpc";
+import { RPC, RPCMethod } from "@fastcar/rpc/annotation";
+import AuthServiceRole from "@/annotation/AuthServiceRole";
+import { ServerKind } from "@/common/Constant";
+import Result from "@/common/Result";
+import { Logger } from "@fastcar/core";
+
+@Controller
+@RPC("/channelRemote")
+@AuthServiceRole(ServerKind.remote)
+export default class ChannelRemote {
+	@Autowired
+	private rpcServer!: RpcServer;
+
+	@Log()
+	private logger!: Logger;
+
+	@RPCMethod()
+	addChannelByUid(data: { channel: string; uid: number }) {
+		this.rpcServer.getSocketManager().joinChannelByCustomId(data.uid.toString(), data.channel);
+		return Result.ok();
+	}
+
+	@RPCMethod()
+	delChannelByUid(data: { channel: string; uid: string }) {
+		this.rpcServer.getSocketManager().leaveChannelByCustomId(data.uid.toString(), data.channel);
+		return Result.ok();
+	}
+
+	//根据渠道广播
+	@RPCMethod()
+	broadcastByChannel(data: { channel: string; msg: RpcMessage; excludeIds?: string[] }) {
+		this.rpcServer.getSocketManager().sendMsgToCustomIdByChannel(data.channel, Object.assign(data.msg, { firstPriority: true }), data.excludeIds);
+		return Result.ok();
+	}
+
+	//根据单用户广播消息
+	@RPCMethod()
+	broadcastByUid(data: { data: RpcMessage; uid: number }) {
+		this.rpcServer.getSocketManager().sendMsgByCustomId(data.uid.toString(), Object.assign(data.data, { firstPriority: true }));
+		return Result.ok();
+	}
+
+	//消息踢掉
+	@RPCMethod()
+	logoutKick({ sessionId }: { sessionId: string }) {
+		this.rpcServer.getSocketManager().sendMsg(sessionId, {
+			url: "/logout/kick",
+			mode: InteractiveMode.notify,
+		});
+		//这边不强制删除
+		return Result.ok();
+	}
+
+	//强制踢掉
+	@RPCMethod()
+	forceKick({ sessionId }: { sessionId: string }) {
+		this.rpcServer.kickSessionId(sessionId, "force kick");
+		//这边不强制删除
+		return Result.ok();
+	}
+}

package/template/src/servers/connector/middleware/forwardMsg.ts

@@ -0,0 +1,54 @@
+import Code from "@/common/Code";
+import RouterService from "@/servers/base/service/RouterService";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import { CommonConstant, FastCarApplication } from "@fastcar/core";
+import { RpcContext } from "@fastcar/rpc";
+
+//转发消息
+export default async function forwardMsg(context: RpcContext, next?: Function) {
+	let serverType: string = context.data?.serverType;
+
+	if (!serverType) {
+		//如果namespace是以://开头的
+		let index = context.url.indexOf(":/");
+		if (index != -1) {
+			serverType = context.url.substring(0, index);
+			context.url = context.url.substring(index + 2);
+		}
+	}
+
+	if (!!serverType) {
+		//这边加个二次重定向
+		let customServiceId = "";
+		let app: FastCarApplication = Reflect.get(global, CommonConstant.FastcarApp);
+		let selfServerType = app.getSetting(SessionAttribute.serverType);
+		//本地网关请求
+		if (selfServerType != serverType) {
+			//计算请求
+			let routerService = app.getComponentByTarget<RouterService>(RouterService);
+			if (!routerService) {
+				return (context.body = {
+					code: Code.SYS.NOT_FOUND,
+				});
+			}
+
+			let res = await routerService.request<{ [key: string]: any }, any>({
+				url: context.url,
+				data: context.data,
+				session: {
+					sessionId: context.sessionId,
+					settings: context.settings,
+					connectedTime: context.connectedTime,
+				},
+				serverType,
+				forward: true,
+				customServiceId,
+			});
+			context.body = res;
+		}
+	}
+
+	if (next) {
+		await next();
+	}
+}

package/template/src/servers/web/HelloController.ts

@@ -0,0 +1,51 @@
+import { Autowired, Controller } from "@fastcar/core/annotation";
+import { GET } from "@fastcar/koa/annotation";
+import CenterClient from "../base/service/CenterClient";
+import Result from "../../common/Result";
+import RouterService from "../base/service/RouterService";
+
+@Controller
+export default class HelloController {
+	@Autowired
+	private centerClient!: CenterClient;
+
+	@Autowired
+	private routerService!: RouterService;
+
+	@GET("/")
+	hello() {
+		return this.routerService.request({
+			url: "/room/join",
+			serverType: "chat",
+		});
+	}
+
+	@GET("/serverList")
+	getServerList() {
+		return Result.ok(this.centerClient.getServerMap().toValues());
+	}
+
+	@GET("/test/rebalance")
+	async rebalance() {
+		let res = await this.centerClient.sendBalance();
+		return res;
+	}
+
+	@GET("/test/syncconfig")
+	syncConfig() {
+		this.routerService
+			.request({
+				url: "/center/syncConfig",
+				serverType: "center",
+				data: {
+					key: "SyncConfigService",
+					data: "hello world",
+				},
+			})
+			.then((res) => {
+				console.log(res);
+			});
+
+		return Result.ok();
+	}
+}

package/template/src/servers/web/SyncConfigService.ts

@@ -0,0 +1,13 @@
+import { Logger } from "@fastcar/core";
+import { BeanName, Log, Service } from "@fastcar/core/annotation";
+
+@BeanName("SyncConfigService")
+@Service
+export default class SyncConfigService {
+	@Log()
+	private logger!: Logger;
+
+	load(m: Object) {
+		this.logger.debug(`同步配置更新`, m);
+	}
+}

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

@@ -0,0 +1,15 @@
+import { Application } from "@fastcar/core/annotation";
+import { EnableKoa, KoaMiddleware } from "@fastcar/koa/annotation";
+import { ExceptionGlobalHandler, KoaBodyParser } from "@fastcar/koa";
+import BaseServer from "../base/BaseServer";
+
+@Application
+//开启koa
+//开启异常捕捉 可自定义 通常是放在中间件第一个
+@KoaMiddleware(ExceptionGlobalHandler)
+//开启参数解析
+// @KoaMiddleware(KoaBody)
+@KoaMiddleware(KoaBodyParser)
+class APP extends BaseServer {}
+
+export default new APP();

package/template/src/types/ClientSimpleSession.ts

@@ -0,0 +1,3 @@
+import { ClientSession } from "@fastcar/rpc";
+
+export type ClientSimpleSession = Omit<ClientSession, "serverId">;

package/template/src/types/ForwardRpcContext.ts

@@ -0,0 +1,3 @@
+import { RpcContext, ClientSession } from "@fastcar/rpc";
+
+export type ForwardRpcContext = { session: ClientSession; forward: boolean } & RpcContext;

package/template/src/types/ReqSession.ts

@@ -0,0 +1,8 @@
+import { CustomId } from "@fastcar/rpc";
+
+export type ReqSession = {
+	sessionId: string;
+	connectedTime: number; //连接的开始时间
+	cid?: CustomId; //自定义逻辑id 这边可以代指uid
+	settings: { [key: string | symbol]: any }; //自定义设置项
+};

package/template/src/types/ResultType.ts

@@ -0,0 +1,5 @@
+export type ResultType<T> = {
+	code: number;
+	msg?: string;
+	data?: T;
+};

package/template/src/types/ServerMeta.ts

@@ -0,0 +1,48 @@
+import { CodeProtocolEnum, DecodeMsg, EncodeMsg, RetryConfig, SecureClientOptions, SocketEnum } from "@fastcar/rpc";
+import { ServerConfig } from "@fastcar/server";
+
+export type ServerItemConfig = {
+	front: boolean;
+	domainName?: string; //对外访问域名
+	type: SocketEnum; //具体为哪一种型号的连接器
+	server: ServerConfig;
+	extra?: any; //第三方拓展配置 用于灵活的调用第三方
+	clientExtra?: any; //客户端拓展配置
+	encode?: EncodeMsg; //编码解码
+	decode?: DecodeMsg;
+	codeProtocol?: CodeProtocolEnum; //约定协议 json protobuf 默认json
+	secure?: SecureClientOptions;
+	maxConnections?: number; //最大连接数 默认1024
+	disconnectInterval?: number;
+	connectionLimit?: number; //连接数限制 默认1
+	retry?: RetryConfig;
+};
+
+export type ServerMeta = {
+	host: string;
+	debugPort?: number; //调试端口号
+	serviceId: string;
+	clusters?: number; //集群数量
+	list: ServerItemConfig[];
+	retry?: RetryConfig;
+	id: number; //服务唯一ID
+	units?: number; //单元数量 默认100
+};
+
+type ServiceType = string;
+
+export type ServerGroupType = {
+	[key: ServiceType]: {
+		token: string; //当前服务的token 用于认证使用的
+		servers: ServerMeta[];
+	};
+};
+
+export type ServerStatus = {
+	serviceId: string;
+	status: boolean;
+	createTime: number;
+	updateTime: number;
+	serverType: string;
+	centerId: string;
+};

package/template/src/types/SessionAttribute.ts

@@ -0,0 +1,13 @@
+//session的属性key值
+export enum SessionAttribute {
+	logged = "logged", //是否登录
+	serviceId = "serviceId", //服务索引id
+	serverType = "serverType", //自定义服务器类型
+	uid = "uid",
+	serverKind = "serverKind", //服务器分类
+	tid = "tid", //桌子分类
+	gameServerType = "gameServerType", //桌子的gameKey
+	logLoginId = "loginId", //登录日志id
+	loginTime = "loginTime", //登录时间
+	center_serviceId = "center_serviceId", //注册中心服务id
+}

package/template/src/utils/ConnectorUtils.ts

@@ -0,0 +1,25 @@
+import { ServerItemConfig } from "@/types/ServerMeta";
+import { SocketEnum } from "@fastcar/rpc";
+
+export default class ConnectorUtils {
+	static getConnectUrl(item: ServerItemConfig, host: string = "localhost") {
+		let sslFlag = !!item.server.ssl;
+		let defaultPort = sslFlag ? "443" : "80";
+
+		switch (item.type) {
+			case SocketEnum.SocketIO:
+			case SocketEnum.WS: {
+				return `${sslFlag ? "wss" : "ws"}://${host}:${item.server.port || defaultPort}`;
+			}
+			case SocketEnum.MQTT: {
+				return `mqtt://${host}:${item.server.port || defaultPort}`;
+			}
+			case SocketEnum.Grpc: {
+				return `${host}:${item.server.port || defaultPort}`;
+			}
+			default: {
+				return "";
+			}
+		}
+	}
+}

package/template/src/utils/MicroservicesUtils.ts

@@ -0,0 +1,101 @@
+import { ServerMicroservices } from "@/common/Constant";
+import { ServerGroupType, ServerItemConfig, ServerMeta } from "@/types/ServerMeta";
+import { CommonConstant } from "@fastcar/core";
+import { FileUtil, MixTool } from "@fastcar/core/utils";
+import * as path from "path";
+
+//格式化微服务配置
+export default class MicroservicesUtils {
+	static getMicroservicesConfig(): ServerGroupType {
+		let resPath = path.join(__dirname, "../../", "resource");
+		let sysConfig = FileUtil.getApplicationConfig(resPath, CommonConstant.Application);
+		let env = sysConfig.application.env;
+		sysConfig = FileUtil.getApplicationConfig(resPath, `${CommonConstant.Application}-${env}`, sysConfig);
+
+		const microservices: ServerGroupType = sysConfig.settings.get(ServerMicroservices);
+		if (!microservices) {
+			throw new Error("not found microservices");
+		}
+
+		return microservices;
+	}
+
+	static format(microservices: ServerGroupType): ServerGroupType {
+		let newMicroservices = {};
+		Object.keys(microservices).forEach((serverType) => {
+			//判断是否为
+			let item = microservices[serverType];
+			let servers = item.servers;
+
+			let n: {
+				token: string; //当前服务的token 用于认证使用的
+				servers: ServerMeta[];
+			} = {
+				token: item.token,
+				servers: [],
+			};
+
+			servers.forEach((citem, index) => {
+				let clusters = citem.clusters || 1;
+				let units = citem.units || 100;
+				let [stype, proto] = citem?.serviceId?.split("-") || "";
+				let commonBody: ServerMeta = {
+					host: citem.host,
+					serviceId: `${stype || serverType}-${proto || "server"}-`,
+					list: citem.list,
+					retry: citem.retry,
+					id: 0,
+				};
+
+				if (citem.debugPort) {
+					commonBody.debugPort = commonBody.debugPort;
+				}
+
+				let addNum = citem.list.length;
+
+				for (let i = 0; i < clusters; i++) {
+					let newItem: ServerMeta = Object.create(commonBody); //copy原型链
+					MixTool.copyProperties(newItem, JSON.parse(JSON.stringify(commonBody))); //copy序列化的值
+
+					if (newItem.debugPort) {
+						newItem.debugPort = newItem.debugPort + i;
+					}
+					newItem.serviceId = newItem.serviceId + ((index + 1) * units + (i + 1));
+					newItem.id = i;
+
+					newItem.list = newItem.list.map((n) => {
+						let t: ServerItemConfig = Object.assign({}, n);
+						let skipNum = i * addNum;
+
+						if (!!t.server.port) {
+							t.server.port = t.server.port + skipNum;
+						} else {
+							t.server.port = t.server.ssl ? 443 + skipNum : 80 + skipNum;
+						}
+
+						return t;
+					});
+
+					n.servers.push(newItem);
+				}
+			});
+
+			Reflect.set(newMicroservices, serverType, Object.assign({}, item, n));
+		});
+
+		return newMicroservices;
+	}
+
+	//格式化命令行参数
+	static parseArgs(args: string[]) {
+		let proto: { [key: string]: string } = {};
+		args.forEach((item: string) => {
+			let list = item.split("=");
+			if (list.length == 2) {
+				Reflect.set(proto, list[0].trim(), list[1].trim());
+			}
+		});
+
+		return proto;
+	}
+}

package/template/src/utils/NetWork.ts

@@ -0,0 +1,31 @@
+import { Context } from "koa";
+import * as os from "os";
+
+const localIps: string[] = ["127.0.0.1", "localhost", "0.0.0.0"];
+(function () {
+	let ifaces = os.networkInterfaces();
+	for (let key in ifaces) {
+		let details = ifaces[key];
+		details?.forEach((item) => {
+			if (item.family === "IPv4" && !localIps.includes(item.address)) {
+				localIps.push(item.address);
+			}
+		});
+	}
+})();
+
+export default class NetWork {
+	//判断是否为本地ip
+	static isLocalIP(host: string): boolean {
+		return localIps.includes(host);
+	}
+}
+
+export function getIP(ctx: Context): string {
+	let req = ctx.request;
+	let ips = req.headers["x-forwarded-for"] || req.headers["x-real-ip"] || ctx.ip;
+	if (Array.isArray(ips)) {
+		return ips[0] || "";
+	}
+	return ips;
+}