refactor(consul): consul's implementation was refactored (#3109)

packages/consul/package.json

@@ -13,12 +13,11 @@
  "@midwayjs/core": "^3.11.15",
  "@midwayjs/koa": "^3.11.15",
  "@midwayjs/mock": "^3.11.15",
- "@types/consul": "0.40.0",
  "@types/sinon": "10.0.16",
  "nock": "13.3.2"
  },
  "dependencies": {
- "consul": "1.2.0"
+ "consul": "2.0.0-next.1"
  },
  "keywords": [
  "consul"

packages/consul/src/config/config.default.ts

@@ -1,17 +1,5 @@
+import { IConsulOptions } from '../interface';
+
 export default {
- consul: {
- provider: {
- register: false,
- host: '127.0.0.1',
- port: 8500,
- strategy: 'random',
- },
- service: {
- id: null,
- name: null,
- tags: [],
- address: null,
- port: 7001,
- },
- },
+ consul: {} as IConsulOptions,
 };

packages/consul/src/configuration.ts

@@ -1,15 +1,4 @@
-import {
- Config,
- Configuration,
- ILifeCycle,
- IMidwayApplication,
- IMidwayContainer,
-} from '@midwayjs/core';
-import {
- IConsulProviderInfoOptions,
- IConsulRegisterInfoOptions,
-} from './interface';
-import { ConsulProvider } from './lib/provider';
+import { Configuration, ILifeCycle } from '@midwayjs/core';
 import * as DefaultConfig from './config/config.default';
 
 @Configuration({
@@ -20,81 +9,4 @@ import * as DefaultConfig from './config/config.default';
  },
  ],
 })
-export class ConsulConfiguration implements ILifeCycle {
- /**
- * 有关 consul server 的配置
- */
- @Config('consul.provider')
- consulProviderConfig: IConsulProviderInfoOptions;
-
- /**
- * 有关 service registry 注册的信息
- */
- @Config('consul.service')
- consulRegisterConfig: IConsulRegisterInfoOptions;
-
- get consulProvider(): ConsulProvider {
- const symbol = Symbol('consulProvider');
- this[symbol] =
- this[symbol] || new ConsulProvider(this.consulProviderConfig);
- return this[symbol];
- }
-
- /**
- * 注册自己的条件
- * 由于环境的复杂性(多网卡、自动端口冲突) address 和 port 必须提供
- */
- get shouldBeRegisterMe(): boolean {
- const { address, port } = this.consulRegisterConfig;
- return this.consulProviderConfig.register && address.length > 0 && port > 0;
- }
-
- /**
- * 注册 consul 服务
- * @param container 容器 IoC
- * @param app 应用 App
- */
- async registerConsul(
- container: IMidwayContainer,
- app: IMidwayApplication
- ): Promise<void> {
- const config = this.consulRegisterConfig;
- const { address, port } = this.consulRegisterConfig;
- // 把原始的 consul 对象注入到容器
- container.registerObject('consul:consul', this.consulProvider.getConsul());
- if (this.shouldBeRegisterMe) {
- config.name = config.name || app.getProjectName();
- config.id = config.id || `${config.name}:${address}:${port}`;
- if (!config.check && (config.check as any) !== false) {
- config.check = ['egg', 'koa', 'express'].includes(app.getNamespace())
- ? {
- http: `http://${address}:${port}/consul/health/self/check`,
- interval: '3s',
- }
- : {
- tcp: `${address}:${port}`,
- interval: '3s',
- };
- }
- Object.assign(this.consulRegisterConfig, config);
- await this.consulProvider.registerService(this.consulRegisterConfig);
- }
- }
-
- async onServerReady(
- container: IMidwayContainer,
- app?: IMidwayApplication
- ): Promise<void> {
- await this.registerConsul(container, app);
- }
-
- async onStop(): Promise<void> {
- if (
- this.consulProviderConfig.register &&
- this.consulProviderConfig.deregister
- ) {
- const { id } = this.consulRegisterConfig;
- await this.consulProvider.deregisterService({ id });
- }
- }
-}
+export class ConsulConfiguration implements ILifeCycle {}

packages/consul/src/consul.service.ts

@@ -0,0 +1,158 @@
+import {
+ Autoload,
+ Config,
+ Destroy,
+ Init,
+ Inject,
+ MidwayError,
+ MidwayInformationService,
+ Provide,
+ Singleton,
+} from '@midwayjs/core';
+import Consul from 'consul';
+import { IConsulOptions, IServiceHealth, IServiceNode } from './interface';
+
+export class MidwayConsulError extends MidwayError {
+ constructor(message: string) {
+ super(message);
+ }
+}
+
+@Provide()
+@Autoload()
+@Singleton()
+export class ConsulService {
+ @Config('consul')
+ private config: IConsulOptions;
+
+ @Inject()
+ private infoSrv: MidwayInformationService;
+
+ serviceId: string;
+
+ private instance: Consul;
+
+ get consul(): Consul {
+ return this.instance;
+ }
+
+ private selectRandomService(arr: Array<any>) {
+ for (let i = arr.length - 1; i > 0; i--) {
+ const j = Math.floor(Math.random() * (i + 1));
+ [arr[i], arr[j]] = [arr[j], arr[i]];
+ }
+ return arr[Math.floor(Math.random() * arr.length)];
+ }
+
+ @Init()
+ //eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ //@ts-ignore
+ private async autoRegister() {
+ try {
+ this.instance = new Consul(this.config.options);
+ const { register } = this.config;
+ if (register) {
+ const { id, name, port, address, check, checks } = register;
+ // 如果没有配置健康监测,则视为顶层为web主框架,同时使用内置http的/health为健康检查的接口
+ if (!check && !checks?.length) {
+ register.check = {
+ http: `http://${address}:${port}/health`,
+ interval: '5s',
+ ttl: '30s',
+ };
+ }
+ const serviceName = name || this.infoSrv.getPkg().name;
+ this.serviceId = id;
+ if (!this.serviceId) {
+ this.serviceId = `${serviceName}:${address}:${port}`;
+ }
+ Object.assign(register, {
+ id: this.serviceId,
+ name: serviceName,
+ });
+ await this.instance.agent.service.register(register);
+ }
+ } catch (e) {
+ throw new MidwayConsulError(`Service startup failure: ${e.message}`);
+ }
+ }
+
+ private async loadAllService(
+ options: Consul.Catalog.Service.NodesOptions
+ ): Promise<Array<IServiceNode>> {
+ const services: Array<IServiceNode> =
+ await this.instance.catalog.service.nodes(options);
+ if (!services.length) {
+ throw new MidwayConsulError(
+ `no available service instance named ${options.service}`
+ );
+ }
+ return services;
+ }
+
+ /**
+ * Select an available service instance by name and datacenter
+ * @param {string} serviceName the service name
+ * @param {Consul.Catalog.Service.NodesOptions} options the NodesOptions
+ */
+ async select(
+ serviceName: string,
+ options?: Omit<Consul.Catalog.Service.NodesOptions, 'service'>
+ ) {
+ const checkOpt = options || {};
+ let checkedArr: Array<IServiceHealth>;
+ try {
+ checkedArr = await this.instance.health.checks({
+ ...checkOpt,
+ service: serviceName,
+ });
+ } catch (e) {
+ if (e?.response?.statusCode === 404) {
+ checkedArr = [];
+ } else {
+ throw new MidwayConsulError(e.message);
+ }
+ }
+ if (!checkedArr.length) {
+ throw new MidwayConsulError(
+ `no available service instance named ${serviceName}`
+ );
+ }
+ const passed: Array<IServiceHealth> = checkedArr.filter(
+ service => service.Status === 'passing'
+ );
+ if (!passed.length) {
+ throw new MidwayConsulError(
+ `The health status of services ${serviceName} is abnormal`
+ );
+ }
+ const opt = options || {};
+ const allNodes = await this.loadAllService({
+ ...opt,
+ service: serviceName,
+ });
+ const matched = allNodes.filter(r => {
+ return passed.some(a => a.ServiceID === r.ServiceID);
+ });
+ if (!matched.length) {
+ throw new MidwayConsulError(
+ `no available service instance named ${serviceName}`
+ );
+ }
+ return this.selectRandomService(matched) as IServiceNode;
+ }
+
+ @Destroy()
+ //eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ //@ts-ignore
+ private async autoDeregister() {
+ try {
+ const { deregister } = this.config;
+ if (this.serviceId && deregister !== false) {
+ await this.instance?.agent.service.deregister(this.serviceId);
+ }
+ } catch (e) {
+ throw new MidwayConsulError(e.message);
+ }
+ }
+}

packages/consul/src/controller/consul.ts

@@ -1,11 +1,9 @@
 import { Controller, Get } from '@midwayjs/core';
 
-@Controller('/consul')
+@Controller('/', { ignoreGlobalPrefix: true })
 export class ConsulController {
- @Get('/health/self/check')
- async healthCheck(): Promise<any> {
- return {
- status: 'success',
- };
+ @Get('/health')
+ async healthCheck() {
+ return 'success';
  }
 }

packages/consul/src/index.ts

@@ -1,4 +1,4 @@
 export { ConsulConfiguration as Configuration } from './configuration';
 export * from './controller/consul';
-export * from './service/balancer';
 export * from './interface';
+export * from './consul.service';