@fastcar/template-microservices 1.0.0

package/template/src/app-pm2.ts

@@ -0,0 +1,191 @@
+//使用pm2启动微服务
+import NetWork from "@/utils/NetWork";
+import * as path from "path";
+import { FileUtil } from "@fastcar/core/utils";
+import * as os from "os";
+import MicroservicesUtils from "./utils/MicroservicesUtils";
+import * as fs from "fs";
+import * as yaml from "yaml";
+import { exec, execSync } from "child_process";
+
+class APPPm2 {
+	exec() {
+		let cmdArgs = MicroservicesUtils.parseArgs(process.argv);
+		let { cmd } = cmdArgs;
+
+		cmd = "start"; // 测试
+
+		switch (cmd) {
+			case "start": {
+				this.start();
+				break;
+			}
+			case "stop": {
+				this.stop();
+				break;
+			}
+			default: {
+				console.log(`未匹配到cmd---->${cmd}`);
+				break;
+			}
+		}
+	}
+
+	async start() {
+		const serverPath = path.join(__dirname, "servers");
+		let microservices = MicroservicesUtils.format(MicroservicesUtils.getMicroservicesConfig());
+		let pargs = MicroservicesUtils.parseArgs(process.argv);
+		let argServerType = Reflect.get(pargs, "serverType");
+		let argServiceId = Reflect.get(pargs, "serviceId");
+		let apps = [];
+
+		for (let serverType in microservices) {
+			if (argServerType && argServerType != serverType) {
+				continue;
+			}
+
+			//判断是否为
+			let item = microservices[serverType];
+			let servers = item.servers;
+			for (let s of servers) {
+				if (argServiceId && argServiceId != s.serviceId) {
+					continue;
+				}
+
+				if (NetWork.isLocalIP(s.host)) {
+					let args: string[] = [];
+
+					args.push(serverType);
+					args.push(s.serviceId);
+
+					console.log(s.serviceId);
+
+					let scriptPath = require.resolve(path.join(serverPath, serverType, "app"));
+					let execArgs: { [key: string]: any } = {
+						name: `${s.serviceId}-usa`,
+						script: scriptPath,
+						args, //动态参数
+						// max_memory_restart: 1024 * 1024 * 1024, //最大重启内存
+						// max_restarts: 1, //最大重启一次
+						// autorestart: true,
+						cwd: __dirname,
+						env: {
+							TZ: "UTC", //替换成统一的时区
+						},
+						wait_ready: true,
+						kill_timeout: 5000,
+					};
+
+					if (FileUtil.getSuffix(scriptPath) == "ts") {
+						execArgs.interpreter = path.join(__dirname, "../", "node_modules", ".bin", "ts-node");
+
+						if (os.type().startsWith("Windows")) {
+							execArgs.exec_mode = "cluster"; //不改为集群模式会有问题
+						}
+
+						if (execArgs?.env) {
+							execArgs.env["TS_NODE_PROJECT"] = path.join(__dirname, "../tsconfig.json");
+						}
+					}
+
+					if (s.debugPort && execArgs.exec_mode != "cluster") {
+						let nodeArgs: string = execArgs.node_args as string;
+						if (!nodeArgs) {
+							execArgs.node_args = "";
+						}
+						execArgs.node_args += ` --inspect=${s.host}:${s.debugPort}`;
+					}
+
+					apps.push(execArgs);
+				}
+			}
+		}
+
+		let execPath = path.join(__dirname, "../", "resource", "ecosystem.config.yml");
+		//写入配置文件
+		fs.writeFileSync(
+			execPath,
+			yaml.stringify({
+				apps,
+			})
+		);
+
+		//先杀掉进程在执行启动
+		execSync(`pm2 stop ${execPath}`);
+		console.log("pm2 stop server complete");
+
+		let execRes = exec(`pm2 start ${execPath}`);
+		execRes.on("exit", () => {
+			console.info("start complete");
+			let startRes = execSync(`pm2 list`);
+			console.log(startRes.toString());
+			process.exit(0);
+		});
+		// setTimeout(() => {
+		// 	execRes.kill();
+		// }, 1000);
+	}
+
+	async stop() {
+		let microservices = MicroservicesUtils.format(MicroservicesUtils.getMicroservicesConfig());
+		let pargs = MicroservicesUtils.parseArgs(process.argv);
+		let argServerType: string = Reflect.get(pargs, "serverType");
+		let argServiceId: string = Reflect.get(pargs, "serviceId");
+
+		let all = false;
+		if (!argServerType && !argServiceId) {
+			all = true;
+		}
+
+		let names: string[] = [];
+		if (all) {
+			Object.values(microservices).forEach((t) => {
+				t.servers.forEach((item) => {
+					if (NetWork.isLocalIP(item.host)) {
+						names.push(item.serviceId);
+					}
+				});
+			});
+		} else {
+			if (!!argServerType) {
+				let t = microservices[argServerType];
+				t.servers.forEach((item) => {
+					if (!argServiceId || item.serviceId == argServiceId) {
+						if (NetWork.isLocalIP(item.host)) {
+							names.push(item.serviceId);
+						}
+					}
+				});
+			} else if (!!argServiceId) {
+				Object.keys(microservices).forEach((k) => {
+					let v = microservices[k];
+					v.servers.forEach((item) => {
+						if (item.serviceId == argServiceId) {
+							if (NetWork.isLocalIP(item.host)) {
+								names.push(item.serviceId);
+							}
+						}
+					});
+				});
+			}
+		}
+
+		if (names.length > 0) {
+			names = names.map((n) => {
+				return `${n}-usa`;
+			});
+
+			let cmdStr = `pm2 stop ${names.join(" ")}`;
+			let execRes = exec(cmdStr);
+			execRes.on("exit", () => {
+				console.log("pm2 stop server list:");
+				names.forEach((item) => {
+					console.log(item);
+				});
+				process.exit(0);
+			});
+		}
+	}
+}
+
+export default new APPPm2().exec();

package/template/src/common/Code.ts

@@ -0,0 +1,26 @@
+export default {
+	SYS: {
+		OK: 200,
+		NOACCESS: 403, //禁止访问
+		NOT_FOUND: 404, //找不到服务
+		FAIL: 500, //内部错误
+		DISCONNECT: 501, //断线
+		RETRYTIMES: 502,
+		UNAVAILABLE: 503, //不可用
+		TIMEOUT: 504, //超时
+		BUSY: 505,
+	},
+	COMMON: {
+		PARAMETER_ERROR: 10001, //参数错误
+		PERMISSIONS_MISSING: 10002, //缺少权限
+		SERVER_CONNECT_FORBID: 10003, //连接禁止
+	},
+	CENTER: {
+		SERVER_NOT_FOUND: 20001, //服务不存在
+		SERVER_TOKEN_ERROR: 20002, //密码错误
+		SERVER_NOT_LOGIN: 20003, //服务未登录
+	},
+	ACCOUNT: {
+		NOT_LOGIN: 30001, //未登录
+	},
+};

package/template/src/common/Constant.ts

@@ -0,0 +1,28 @@
+export const ServerTypeSymbol = Symbol("ServerType"); //特指每一组的类型
+
+export const ServerMicroservices = "microservices";
+
+//频道
+export enum ChannelKind {
+	"FRONT" = "__front__", //前端服务
+	"REMOTE" = "__remote__", //后端调用服务
+	"CENTER" = "__center__", //中心服务
+}
+
+//进行服务分类
+export enum ServerKind {
+	"front" = "front", //前端程序服务
+	"remote" = "remote", //内部通讯服务
+	"center" = "center", //中心服务
+}
+
+export enum ServerCommonUrl {
+	Connect = "connect_receipt",
+	ServiceStatusNotify = "/center/client/serviceStatusNotify", //客户端服务更新
+	ServiceStatusAllNotify = "/center/client/serviceStatusAllNotify", //全部路由更新
+	ServiceBalance = "/center/rebalance", //重新负载均衡
+	ServiceSyncConfig = "/center/syncConfig", //同步配置
+}
+
+//热更新配置集合
+export const HotConfigKeys = Symbol("hotConfigKeys");

package/template/src/common/Result.ts

@@ -0,0 +1,40 @@
+import { ValidationUtil } from "@fastcar/core/utils";
+import CODE from "./Code";
+
+/***
+ * @version 1.0 封装返回类
+ */
+export default class Result {
+	static ok(data?: Object) {
+		return {
+			code: CODE.SYS.OK,
+			msg: "success",
+			data: ValidationUtil.isNotNull(data) ? data : {},
+		};
+	}
+
+	static errorMsg(msg: string) {
+		return {
+			code: CODE.SYS.FAIL,
+			msg: msg,
+			data: {},
+		};
+	}
+
+	static errorCode(code: number, msg?: string) {
+		let res: { code: number; data: any; msg?: any } = {
+			code: code ? code : CODE.SYS.FAIL,
+			data: {},
+		};
+
+		if (msg) {
+			res.msg = msg;
+		}
+
+		return res;
+	}
+
+	static isOK(code: number) {
+		return code == CODE.SYS.OK;
+	}
+}

package/template/src/common/TaskAsync.ts

@@ -0,0 +1,17 @@
+import { AsyncResource } from "async_hooks";
+
+class TaskAsync extends AsyncResource {
+	protected callback: any;
+
+	constructor(callback: any) {
+		super("TaskAsync");
+		this.callback = callback;
+	}
+
+	done(result?: any) {
+		this.runInAsyncScope(this.callback, null, result);
+		this.emitDestroy();
+	}
+}
+
+export default TaskAsync;

package/template/src/hotconfig/ExampleConfigService.ts

@@ -0,0 +1,29 @@
+import { BootPriority, Logger } from "@fastcar/core";
+import { ApplicationStart, BeanName, Log } from "@fastcar/core/annotation";
+import { getHotKey, HotConfigInterface } from "./HotConfigInterface";
+
+@BeanName("ExampleConfigService")
+@ApplicationStart(BootPriority.Common)
+export default class ExampleConfigService implements HotConfigInterface {
+	@Log()
+	private logger!: Logger;
+
+	async run() {
+		this.logger.debug(`初始化配置`);
+	}
+
+	//加载游戏配置
+	load(list: string[], serverType: string) {
+		//通知模板来
+		let keys = getHotKey(__filename);
+		if (keys && !keys.includes(serverType)) {
+			return this.logger.warn(`无需加载配置`);
+		}
+
+		if (!!serverType) {
+			this.logger.debug(`加载单个配置${serverType}`);
+		} else {
+			this.logger.debug(`加载全部配置`);
+		}
+	}
+}

package/template/src/hotconfig/HotConfigInterface.ts

@@ -0,0 +1,43 @@
+import { HotConfigKeys } from "@/common/Constant";
+import { DataMap } from "@fastcar/core";
+
+export interface HotConfigInterface {
+	load(...args: any[]): void;
+}
+
+//设置热更新的模块和key值
+export function setHotKey(filename: string, keys: Array<string>) {
+	if (keys && keys.length > 0) {
+		let m: DataMap<string, string[]> = Reflect.get(global, HotConfigKeys);
+		if (!m) {
+			m = new DataMap<string, string[]>();
+			Reflect.set(global, HotConfigKeys, m);
+		}
+
+		if (keys.length == 0) {
+			m.set(filename, keys);
+		} else {
+			//全局存在的则忽略
+			let currKeys = m.get(filename);
+			if (!!currKeys && currKeys.length == 0) {
+				return;
+			}
+
+			if (!currKeys) {
+				currKeys = [];
+				m.set(filename, currKeys);
+			}
+			keys.forEach((key) => {
+				if (!currKeys.includes(key)) {
+					currKeys.push(key);
+				}
+			});
+		}
+	}
+}
+
+export function getHotKey(filename: string): string[] | undefined {
+	let m: DataMap<string, string[]> = Reflect.get(global, HotConfigKeys);
+
+	return m && m.get(filename);
+}

package/template/src/middleware/checkForm.ts

@@ -0,0 +1,20 @@
+import { RpcContext } from "@fastcar/rpc";
+import Code from "@/common/Code";
+import { ValidError } from "@fastcar/core";
+import Result from "@/common/Result";
+
+//针对表单校验抛出的错误进行处理
+export default async function checkForm(context: RpcContext, next?: Function): Promise<void> {
+	if (next) {
+		try {
+			await next();
+		} catch (e: any) {
+			if (e instanceof ValidError) {
+				context.body = Result.errorCode(Code.COMMON.PARAMETER_ERROR, e?.message);
+				return;
+			}
+
+			throw e;
+		}
+	}
+}

package/template/src/middleware/checkLogin.ts

@@ -0,0 +1,25 @@
+import Result from "@/common/Result";
+import { ClientSession, RpcContext } from "@fastcar/rpc";
+import Code from "@/common/Code";
+import { SessionAttribute } from "../types/SessionAttribute";
+
+//未登录请求的白名单
+const whiteUrls = ["/remote/login", "/connect", "/disconnect", "/account/login"];
+
+//校验登录
+export default async function checkLogin(context: RpcContext & { forward?: boolean; session?: ClientSession }, next?: Function): Promise<void> {
+	let url = context.url;
+	if (url) {
+		if (!whiteUrls.includes(url)) {
+			//校验解析中的session
+			if (!context.session || !context.session.settings.get(SessionAttribute.logged)) {
+				context.body = Result.errorCode(Code.ACCOUNT.NOT_LOGIN);
+				return;
+			}
+		}
+	}
+
+	if (next) {
+		await next();
+	}
+}

package/template/src/middleware/parseSession.ts

@@ -0,0 +1,44 @@
+//解析session会话
+import { CommonConstant, FastCarApplication } from "@fastcar/core";
+import Code from "@/common/Code";
+import { RpcContext } from "@fastcar/rpc";
+import RouterService from "@/servers/base/service/RouterService";
+import Result from "@/common/Result";
+import { ClientSimpleSession } from "@/types/ClientSimpleSession";
+
+export default async function parseSession(context: RpcContext & { forward?: boolean; session?: ClientSimpleSession }, next?: Function) {
+	let forward: boolean = !!context.data?.forward;
+
+	context.forward = forward;
+	//进行转义
+	let session = context.data?.session;
+
+	if (session) {
+		let app: FastCarApplication = Reflect.get(global, CommonConstant.FastcarApp);
+		let routerService = app.getComponentByTarget<RouterService>(RouterService);
+
+		if (!routerService) {
+			return Result.errorCode(Code.SYS.UNAVAILABLE);
+		}
+
+		//重新拆分赋值
+		if (context.data?.data) {
+			context.data = context.data?.data;
+		}
+		context.session = routerService.reqSessionToSession(session);
+	} else {
+		if (forward) {
+			return Result.errorCode(Code.ACCOUNT.NOT_LOGIN);
+		}
+
+		context.session = {
+			sessionId: context.sessionId,
+			connectedTime: context.connectedTime,
+			settings: context.settings,
+		};
+	}
+
+	if (next) {
+		await next();
+	}
+}

package/template/src/servers/base/BaseServer.ts

@@ -0,0 +1,120 @@
+import { ServerKind, ServerMicroservices } from "@/common/Constant";
+import { ServerGroupType } from "@/types/ServerMeta";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import MicroservicesUtils from "@/utils/MicroservicesUtils";
+import { CommonConstant, FastCarApplication } from "@fastcar/core";
+import { ApplicationSetting, Autowired, ComponentScan, ResourcePath } from "@fastcar/core/annotation";
+import ApplicationHook from "@fastcar/core/src/interface/ApplicationHook";
+import { EnableKoa } from "@fastcar/koa/annotation";
+import { RetryConfig, RpcConfig, RpcMetaData, SocketServerConfig } from "@fastcar/rpc";
+import * as path from "path";
+import { EnableRPC } from "@fastcar/rpc/annotation";
+import ServerManager from "../center/service/ServerManager";
+
+@ResourcePath(path.join(__dirname, "../../../resource"))
+@ApplicationSetting({
+	log: {
+		rootPath: path.join(__dirname, "../../../logs"), //将日志移到最外层
+	},
+})
+@ComponentScan(path.join(__dirname))
+export default class BaseServer implements ApplicationHook {
+	protected serviceId: string;
+	protected serviceType: string;
+
+	@Autowired
+	protected app!: FastCarApplication;
+
+	constructor() {
+		let l = process.argv.length;
+		let args = process.argv.slice(l - 2, l);
+
+		if (args.length < 2) {
+			throw new Error("not found serviceType and serviceId");
+		}
+
+		this.serviceType = args[0];
+		this.serviceId = args[1];
+	}
+
+	//重载微服务配置 二次解析
+	//兼容web应用
+	loadSysConfig() {
+		this.app.setSetting(SessionAttribute.serviceId, this.serviceId);
+		this.app.setSetting(SessionAttribute.serverType, this.serviceType);
+		this.app.setSetting(CommonConstant.APPId, this.serviceId);
+
+		const microservices: ServerGroupType = MicroservicesUtils.format(this.app.getSetting(ServerMicroservices));
+		this.app.setSetting(ServerMicroservices, microservices);
+
+		let list = microservices[this.serviceType] as any;
+		let koaConfig = list?.koa || {};
+
+		//赋值到rpc内 取服务器地址
+		let rpc: Partial<RpcConfig> = this.app.getSetting(RpcMetaData.RpcConfig);
+		if (!rpc) {
+			rpc = {
+				list: [],
+			};
+		}
+
+		for (let item of list.servers) {
+			if (item.serviceId == this.serviceId) {
+				item.list.forEach((citem: SocketServerConfig, index: number) => {
+					if (["http", "https", "http2"].includes(citem.type)) {
+						if (!koaConfig.server) {
+							koaConfig.server = [];
+						}
+						koaConfig.server.push(
+							Object.assign(citem.server, {
+								protocol: citem.type,
+							})
+						);
+					} else {
+						//本质还是rpc服务
+						rpc.list?.push({
+							id: `${this.serviceId}-${index + 1}`, //这个id仅用作socket服务内部标识
+							type: citem.type,
+							server: citem.server,
+							extra: Object.assign({ front: !!citem.front }, citem.extra || {}),
+							serviceType: this.serviceType,
+							encode: citem.encode,
+							decode: citem.decode,
+							codeProtocol: citem.codeProtocol,
+							secure: citem.secure,
+							maxConnections: citem.maxConnections,
+							timeout: citem.timeout,
+						});
+					}
+				});
+				rpc.retry = item.retry as Required<RetryConfig>;
+				break;
+			}
+		}
+
+		if (!!koaConfig && koaConfig.server && koaConfig?.server.length > 0) {
+			this.app.setSetting("koa", koaConfig);
+			EnableKoa(BaseServer); //开启web应用
+		}
+
+		if (!!rpc && rpc?.list && rpc?.list?.length > 0) {
+			this.app.setSetting(RpcMetaData.RpcConfig, rpc);
+			EnableRPC(BaseServer); //开启rpc服务
+		}
+
+		process.nextTick(() => {
+			if (this.serviceType == ServerKind.center) {
+				let serverManager = this.app.getComponentByTarget(ServerManager) as any;
+				serverManager.loadServerList();
+			}
+		});
+	}
+
+	beforeStartServer(): void | Promise<void> {}
+
+	async beforeStopServer(): Promise<void> {}
+
+	async startServer(): Promise<void> {}
+
+	stopServer(): void {}
+}

package/template/src/servers/base/common/BackSessionEntryController.ts

@@ -0,0 +1,33 @@
+import { Autowired, Controller } from "@fastcar/core/annotation";
+import { RPC, RPCMethod } from "@fastcar/rpc/annotation";
+import BackSessionService from "../service/BackSessionService";
+import Result from "@/common/Result";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import RouterService from "../service/RouterService";
+import { ReqSession } from "@/types/ReqSession";
+
+@Controller
+@RPC("/backSession")
+export default class BackSessionEntryController {
+	@Autowired
+	private backSessionService!: BackSessionService;
+
+	@Autowired
+	private routerService!: RouterService;
+
+	@RPCMethod()
+	join({ session }: { session: ReqSession }) {
+		this.backSessionService.join(this.routerService.reqSessionToSession(session));
+
+		return Result.ok();
+	}
+
+	@RPCMethod()
+	leave({ session }: { session: ReqSession }) {
+		let clientSession = this.routerService.reqSessionToSession(session);
+		let uid = clientSession.settings.get(SessionAttribute.uid);
+		this.backSessionService.remove(uid);
+
+		return Result.ok();
+	}
+}

package/template/src/servers/base/common/RemoteController.ts

@@ -0,0 +1,70 @@
+import { Autowired, Controller, Rule, ValidForm } from "@fastcar/core/annotation";
+import { RpcContext, RpcServer } from "@fastcar/rpc";
+import { RPC, RPCMethod } from "@fastcar/rpc/annotation";
+import DataService from "@/servers/base/service/DataService";
+import Result from "@/common/Result";
+import Code from "@/common/Code";
+import { SessionAttribute } from "@/types/SessionAttribute";
+import ServerManager from "@/servers/center/service/ServerManager";
+
+//内部服务公用的接口
+@Controller
+@RPC("/remote")
+export default class EntryController {
+	@Autowired
+	private rpcServer!: RpcServer;
+
+	@Autowired
+	private dataService!: DataService;
+
+	@Autowired
+	private serverManager!: ServerManager;
+
+	@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.rpcServer.getSocketManager().joinChannel(ctx.sessionId, this.dataService.getChannelKindByServerType(serverMeta.serverType));
+		ctx.settings.set(SessionAttribute.logged, true);
+		ctx.settings.set(SessionAttribute.serviceId, serviceId);
+		ctx.settings.set(SessionAttribute.serverKind, serverKind);
+		ctx.settings.set(SessionAttribute.serverType, serverMeta.serverType);
+
+		//便于客户端同步
+		return Result.ok();
+	}
+
+	@RPCMethod()
+	@ValidForm
+	async health({}, ctx: RpcContext) {
+		let logged = ctx.settings.get(SessionAttribute.logged);
+		if (logged) {
+			let serviceId = ctx.settings.get(SessionAttribute.serviceId);
+			if (!this.serverManager.updateServiceUpdateTime(serviceId)) {
+				// this.rpcServer.kickSessionId(ctx.sessionId, "status is error");
+				return Result.errorCode(Code.SYS.NOACCESS);
+			}
+		}
+
+		return Result.ok();
+	}
+}