@midwayjs/etcd 4.0.0-alpha.1 → 4.0.0-beta.2

package/README.md

@@ -9,4 +9,4 @@ Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 
-[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))
+[MIT]((https://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -1,4 +1,6 @@
+import { IMidwayContainer } from '@midwayjs/core';
 export declare class ETCDConfiguration {
     onReady(container: any): Promise<void>;
+    onStop(container: IMidwayContainer): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -14,6 +14,10 @@ let ETCDConfiguration = class ETCDConfiguration {
     async onReady(container) {
         await container.getAsync(manager_1.ETCDServiceFactory);
     }
+    async onStop(container) {
+        const factory = await container.getAsync(manager_1.ETCDServiceFactory);
+        await factory.stop();
+    }
 };
 exports.ETCDConfiguration = ETCDConfiguration;
 exports.ETCDConfiguration = ETCDConfiguration = __decorate([

package/dist/extension/serviceDiscovery.d.ts

@@ -0,0 +1,39 @@
+import { Etcd3 } from 'etcd3';
+import { ServiceDiscovery, ServiceDiscoveryClient, ILogger } from '@midwayjs/core';
+import { EtcdServiceDiscoveryOptions, EtcdInstanceMetadata } from '../interface';
+export declare class EtcdServiceDiscoverClient extends ServiceDiscoveryClient<Etcd3, EtcdServiceDiscoveryOptions, EtcdInstanceMetadata> {
+    private lease?;
+    private renewTimer?;
+    private readonly ttl;
+    private readonly renewInterval;
+    private logger;
+    private registeredInstance;
+    private onlineInstanceData;
+    constructor(client: Etcd3, serviceDiscoveryOptions: EtcdServiceDiscoveryOptions, logger: ILogger);
+    private getServiceKey;
+    private getInstanceKey;
+    private createLease;
+    private revokeLeaseIfExists;
+    private renewLease;
+    private startRenewTimer;
+    register(instance: EtcdInstanceMetadata): Promise<void>;
+    deregister(): Promise<void>;
+    online(): Promise<void>;
+    offline(): Promise<void>;
+    beforeStop(): Promise<void>;
+}
+export declare class EtcdServiceDiscovery extends ServiceDiscovery<Etcd3, EtcdServiceDiscoveryOptions, EtcdInstanceMetadata, EtcdInstanceMetadata, string> {
+    private etcdServiceFactory;
+    private configService;
+    private etcdServiceDiscoveryOptions;
+    private coreLogger;
+    private listenerStore;
+    init(): Promise<void>;
+    protected getServiceClient(): Etcd3;
+    protected createServiceDiscoverClientImpl(options: EtcdServiceDiscoveryOptions): EtcdServiceDiscoverClient;
+    protected getDefaultServiceDiscoveryOptions(): EtcdServiceDiscoveryOptions;
+    private getListener;
+    getInstances(serviceName: string): Promise<EtcdInstanceMetadata[]>;
+    beforeStop(): Promise<void>;
+}
+//# sourceMappingURL=serviceDiscovery.d.ts.map

package/dist/extension/serviceDiscovery.js

@@ -0,0 +1,232 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EtcdServiceDiscovery = exports.EtcdServiceDiscoverClient = void 0;
+const core_1 = require("@midwayjs/core");
+const manager_1 = require("../manager");
+class EtcdDataListener {
+    constructor(client, serviceName) {
+        this.client = client;
+        this.serviceName = serviceName;
+        this.data = [];
+        this.destroyed = false;
+    }
+    async init() {
+        await this.refresh();
+        this.watcher = await this.client
+            .watch()
+            .prefix(this.getServiceKey())
+            .create();
+        this.watcher.on('put', this.refresh.bind(this));
+        this.watcher.on('delete', this.refresh.bind(this));
+    }
+    getServiceKey() {
+        return `${this.serviceName}`.startsWith('/')
+            ? `${this.serviceName}`
+            : `services/${this.serviceName}`;
+    }
+    async refresh() {
+        if (this.destroyed)
+            return;
+        const key = this.getServiceKey();
+        const response = await this.client.getAll().prefix(key).exec();
+        this.data = response.kvs
+            .map(kv => {
+            try {
+                return JSON.parse(kv.value.toString());
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(Boolean);
+    }
+    getData() {
+        return this.data;
+    }
+    async destroy() {
+        this.destroyed = true;
+        if (this.watcher) {
+            await this.watcher.cancel();
+            this.watcher = null;
+        }
+    }
+}
+class EtcdServiceDiscoverClient extends core_1.ServiceDiscoveryClient {
+    constructor(client, serviceDiscoveryOptions, logger) {
+        super(client, serviceDiscoveryOptions);
+        this.registeredInstance = null;
+        this.onlineInstanceData = null;
+        this.ttl = serviceDiscoveryOptions.ttl || 30;
+        this.renewInterval = Math.floor(this.ttl / 3) * 1000;
+        this.logger = logger;
+    }
+    getServiceKey(serviceName) {
+        const ns = this.options.namespace || 'services';
+        return `${ns}/${serviceName}`;
+    }
+    getInstanceKey(serviceName, instanceId) {
+        return `${this.getServiceKey(serviceName)}/${instanceId}`;
+    }
+    async createLease(ttl = 30) {
+        const lease = this.client.lease(ttl);
+        await lease.grant();
+        return lease;
+    }
+    async revokeLeaseIfExists() {
+        if (this.lease) {
+            try {
+                await this.lease.revoke();
+            }
+            catch (e) {
+                this.logger.debug('[etcd][debug] revokeLease error', this.lease.id.toString(), e);
+            }
+            this.lease = undefined;
+        }
+    }
+    async renewLease() {
+        if (!this.lease) {
+            return;
+        }
+        try {
+            this.logger.debug('[etcd][debug] renewLease', this.lease.id.toString());
+            await this.lease.keepaliveOnce();
+        }
+        catch (error) {
+            this.logger.debug('[etcd][debug] renewLease failed, will revoke and recreate', this.lease.id.toString(), error);
+            await this.revokeLeaseIfExists();
+            this.lease = await this.createLease(this.ttl);
+        }
+    }
+    startRenewTimer() {
+        if (this.renewTimer) {
+            clearInterval(this.renewTimer);
+        }
+        this.renewTimer = setInterval(() => {
+            this.renewLease().catch(error => {
+                this.logger.error('Error in lease renewal timer:', error);
+            });
+        }, this.renewInterval);
+    }
+    async register(instance) {
+        this.registeredInstance = instance;
+        // 注册时默认上线
+        await this.online();
+    }
+    async deregister() {
+        if (this.onlineInstanceData) {
+            await this.offline();
+        }
+        if (this.registeredInstance) {
+            const key = this.getInstanceKey(this.registeredInstance.serviceName, this.registeredInstance.id);
+            await this.client.delete().key(key).exec();
+            this.logger.info(`[midway:etcd] deregister instance: ${this.registeredInstance.id} for service: ${this.registeredInstance.serviceName}`);
+            this.registeredInstance = null;
+        }
+        await this.revokeLeaseIfExists();
+    }
+    async online() {
+        if (!this.registeredInstance) {
+            throw new Error('No instance registered, cannot online.');
+        }
+        // 已经上线则忽略
+        if (this.onlineInstanceData) {
+            return;
+        }
+        const key = this.getInstanceKey(this.registeredInstance.serviceName, this.registeredInstance.id);
+        const value = JSON.stringify(this.registeredInstance);
+        this.lease = await this.createLease(this.registeredInstance.ttl || this.ttl);
+        await this.lease.put(key).value(value);
+        this.logger.info(`[midway:etcd] online instance: ${this.registeredInstance.id} for service: ${this.registeredInstance.serviceName}`);
+        this.startRenewTimer();
+        this.onlineInstanceData = this.registeredInstance;
+    }
+    async offline() {
+        // 已经下线则忽略
+        if (!this.onlineInstanceData) {
+            return;
+        }
+        const key = this.getInstanceKey(this.onlineInstanceData.serviceName, this.onlineInstanceData.id);
+        await this.client.delete().key(key).exec();
+        this.logger.info(`[midway:etcd] offline instance: ${this.onlineInstanceData.id} for service: ${this.onlineInstanceData.serviceName}`);
+        this.onlineInstanceData = null;
+        await this.revokeLeaseIfExists();
+    }
+    async beforeStop() {
+        if (this.renewTimer) {
+            clearInterval(this.renewTimer);
+            this.renewTimer = undefined;
+        }
+        if (this.lease) {
+            await this.lease.revoke();
+        }
+    }
+}
+exports.EtcdServiceDiscoverClient = EtcdServiceDiscoverClient;
+let EtcdServiceDiscovery = class EtcdServiceDiscovery extends core_1.ServiceDiscovery {
+    constructor() {
+        super(...arguments);
+        this.listenerStore = new Map();
+    }
+    async init() {
+        this.etcdServiceDiscoveryOptions = this.configService.getConfiguration('etcd.serviceDiscovery', {});
+    }
+    getServiceClient() {
+        return this.etcdServiceFactory.get(this.etcdServiceDiscoveryOptions.serviceDiscoveryClient ||
+            this.etcdServiceFactory.getDefaultClientName() ||
+            'default');
+    }
+    createServiceDiscoverClientImpl(options) {
+        return new EtcdServiceDiscoverClient(this.getServiceClient(), options, this.coreLogger);
+    }
+    getDefaultServiceDiscoveryOptions() {
+        return this.etcdServiceDiscoveryOptions;
+    }
+    async getListener(serviceName) {
+        if (!this.listenerStore.has(serviceName)) {
+            const listener = new EtcdDataListener(this.getServiceClient(), serviceName);
+            await listener.init();
+            this.listenerStore.set(serviceName, listener);
+        }
+        return this.listenerStore.get(serviceName);
+    }
+    async getInstances(serviceName) {
+        const listener = await this.getListener(serviceName);
+        return listener.getData();
+    }
+    async beforeStop() {
+        await Promise.all(Array.from(this.listenerStore.values()).map(listener => listener.destroy()));
+        this.listenerStore.clear();
+    }
+};
+exports.EtcdServiceDiscovery = EtcdServiceDiscovery;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", manager_1.ETCDServiceFactory)
+], EtcdServiceDiscovery.prototype, "etcdServiceFactory", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayConfigService)
+], EtcdServiceDiscovery.prototype, "configService", void 0);
+__decorate([
+    (0, core_1.Logger)(),
+    __metadata("design:type", Object)
+], EtcdServiceDiscovery.prototype, "coreLogger", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EtcdServiceDiscovery.prototype, "init", null);
+exports.EtcdServiceDiscovery = EtcdServiceDiscovery = __decorate([
+    (0, core_1.Singleton)()
+], EtcdServiceDiscovery);
+//# sourceMappingURL=serviceDiscovery.js.map

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { ETCDConfiguration as Configuration } from './configuration';
 export * from './manager';
+export * from './extension/serviceDiscovery';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -18,4 +18,5 @@ exports.Configuration = void 0;
 var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.ETCDConfiguration; } });
 __exportStar(require("./manager"), exports);
+__exportStar(require("./extension/serviceDiscovery"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,46 @@
+import { ServiceDiscoveryBaseInstance, ServiceDiscoveryOptions, DefaultInstanceMetadata, ServiceFactoryConfigOption } from '@midwayjs/core';
+import { IOptions } from 'etcd3';
+export interface EtcdInstanceMetadata extends ServiceDiscoveryBaseInstance {
+    /**
+     * 服务名称
+     */
+    serviceName: string;
+    /**
+     * 服务实例 ID
+     */
+    id: string;
+    /**
+     * 服务实例的过期时间（秒）
+     */
+    ttl?: number;
+    /**
+     * 服务实例的标签
+     */
+    tags?: string[];
+    /**
+     * 服务实例的元数据
+     */
+    meta?: Record<string, string>;
+    /**
+     * 服务实例的状态
+     */
+    status?: 'UP' | 'DOWN';
+}
+export interface EtcdServiceDiscoveryOptions extends ServiceDiscoveryOptions<EtcdInstanceMetadata> {
+    /**
+     * 命名空间
+     */
+    namespace?: string;
+    /**
+     * 服务信息的过期时间（秒）
+     */
+    ttl?: number;
+    /**
+     * 服务实例配置
+     */
+    serviceOptions?: EtcdInstanceMetadata | ((meta: DefaultInstanceMetadata) => EtcdInstanceMetadata);
+}
+export type MidwayEtcdConfigOptions = ServiceFactoryConfigOption<IOptions> & {
+    serviceDiscovery?: EtcdServiceDiscoveryOptions;
+};
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/manager.js

@@ -14,7 +14,9 @@ const core_1 = require("@midwayjs/core");
 const etcd3_1 = require("etcd3");
 let ETCDServiceFactory = class ETCDServiceFactory extends core_1.ServiceFactory {
     async init() {
-        await this.initClients(this.etcdConfig);
+        await this.initClients(this.etcdConfig, {
+            concurrent: true,
+        });
     }
     async createClient(config) {
         this.logger.info('[midway:etcd] init %s', config.hosts);

package/index.d.ts

@@ -1,8 +1,8 @@
-import { IOptions } from 'etcd3';
+import { MidwayEtcdConfigOptions } from './dist/index';
 export * from './dist/index';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {
-    etcd?: ServiceFactoryConfigOption<IOptions>;
+    etcd?: MidwayEtcdConfigOptions;
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@midwayjs/etcd",
   "description": "midway etcd component",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-beta.2",
   "main": "dist/index.js",
   "typings": "index.d.ts",
   "files": [
@@ -10,8 +10,8 @@
     "index.d.ts"
   ],
   "devDependencies": {
-    "@midwayjs/core": "^4.0.0-alpha.1",
-    "@midwayjs/mock": "^4.0.0-alpha.1"
+    "@midwayjs/core": "^4.0.0-beta.2",
+    "@midwayjs/mock": "^4.0.0-beta.2"
   },
   "dependencies": {
     "etcd3": "1.1.2"
@@ -30,11 +30,11 @@
     "lint": "mwts check"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "14bb4da91805a1cf52f190c0d37a74b395dd6372"
+  "gitHead": "53bfef4c5279da5f09025e4610bdbf64f94f60bd"
 }