@grest-ts/discovery-local 0.0.6 → 0.0.8

package/src/local/GGLocalDiscoveryClient.ts

@@ -1,94 +1,94 @@
-import {GG_DISCOVERY, GGDiscoveryClient, GGServiceRegistration} from "@grest-ts/discovery";
-import {GGLog} from "@grest-ts/logger";
-import {IPCClient} from "@grest-ts/ipc";
-import {GGLocator, GGLocatorServiceType} from "@grest-ts/locator";
-import {GGDiscoveryIPC} from "./GGDiscoveryIPC";
-import {SERVER_ERROR} from "@grest-ts/schema";
-
-/**
- * ENV variable key when running in tests, for example - this would be PORT of the service discovery instance.
- * If running in tests, the test itself also acts as a service discovery of sorts, allowing multiple instances to run in parallel.
- */
-export const GG_LOCAL_ROUTER_PORT = "GG_LOCAL_ROUTER_PORT"
-
-export class GGLocalDiscoveryClient extends GGDiscoveryClient {
-
-    public override readonly isLocal = true;
-    public readonly port;
-    protected readonly entries: GGServiceDiscoveryEntry[] = [];
-    protected readonly client: IPCClient;
-
-    constructor(port?: number) {
-        if (port === undefined) {
-            throw new Error("No port specified for local router");
-        }
-        super();
-        this.port = port;
-        this.client = new IPCClient(port);
-        GGLog.info(this, "Started on port: " + this.port);
-
-        GGLocator.getScope().setWithLifecycle(GG_DISCOVERY, this, {
-            type: GGLocatorServiceType.SERVICE_DISCOVERY,
-            start: () => this.register(),
-            teardown: () => this.unregister()
-        })
-    }
-
-    public registerRoutes(registrations: GGServiceRegistration[]): void {
-        for (const reg of registrations) {
-            this.entries.push({
-                api: reg.api,
-                baseUrl: `${reg.protocol}://localhost:${reg.port}`,
-                pathPrefix: reg.pathPrefix
-            });
-        }
-    }
-
-    public async discoverApi(apiName: string): Promise<string> {
-        await this.ensureConnected();
-        const res = await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.discoverApi, apiName);
-        if (res.success && res.url) {
-            return res.url;
-        } else {
-            throw new SERVER_ERROR({
-                displayMessage: res.error ?? "Unknown error",
-                debugData: {apiName}
-            })
-        }
-    }
-
-    public async register(): Promise<void> {
-        await this.ensureConnected();
-        if (this.entries.length > 0) {
-            await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.register, this.entries);
-        }
-        GGLog.info(this, `Registered ${this.entries.length} routes`);
-    }
-
-    public async unregister(): Promise<void> {
-        if (this.entries.length > 0 && this.client.isConnected()) {
-            try {
-                await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.unregister, this.entries);
-            } catch (err: any) {
-                GGLog.error(this, err);
-            }
-        }
-        this.client.disconnect();
-    }
-
-    protected async ensureConnected(): Promise<void> {
-        if (!this.client.isConnected()) {
-            await this.client.connect();
-        }
-    }
-}
-
-/**
- * What consumers need to discover and connect to a service
- */
-export interface GGServiceDiscoveryEntry {
-    api: string;
-    baseUrl: string;     // Complete base URL: "http://localhost:8080" or "http://service-name:8080"
-    pathPrefix: string;  // Path to append: "/api/users/"
-}
-
+import {GG_DISCOVERY, GGDiscoveryClient, GGServiceRegistration} from "@grest-ts/discovery";
+import {GGLog} from "@grest-ts/logger";
+import {IPCClient} from "@grest-ts/ipc";
+import {GGLocator, GGLocatorServiceType} from "@grest-ts/locator";
+import {GGDiscoveryIPC} from "./GGDiscoveryIPC";
+import {SERVER_ERROR} from "@grest-ts/schema";
+
+/**
+ * ENV variable key when running in tests, for example - this would be PORT of the service discovery instance.
+ * If running in tests, the test itself also acts as a service discovery of sorts, allowing multiple instances to run in parallel.
+ */
+export const GG_LOCAL_ROUTER_PORT = "GG_LOCAL_ROUTER_PORT"
+
+export class GGLocalDiscoveryClient extends GGDiscoveryClient {
+
+    public override readonly isLocal = true;
+    public readonly port;
+    protected readonly entries: GGServiceDiscoveryEntry[] = [];
+    protected readonly client: IPCClient;
+
+    constructor(port?: number) {
+        if (port === undefined) {
+            throw new Error("No port specified for local router");
+        }
+        super();
+        this.port = port;
+        this.client = new IPCClient(port);
+        GGLog.info(this, "Started on port: " + this.port);
+
+        GGLocator.getScope().setWithLifecycle(GG_DISCOVERY, this, {
+            type: GGLocatorServiceType.SERVICE_DISCOVERY,
+            start: () => this.register(),
+            teardown: () => this.unregister()
+        })
+    }
+
+    public registerRoutes(registrations: GGServiceRegistration[]): void {
+        for (const reg of registrations) {
+            this.entries.push({
+                api: reg.api,
+                baseUrl: `${reg.protocol}://localhost:${reg.port}`,
+                pathPrefix: reg.pathPrefix
+            });
+        }
+    }
+
+    public async discoverApi(apiName: string): Promise<string> {
+        await this.ensureConnected();
+        const res = await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.discoverApi, apiName);
+        if (res.success && res.url) {
+            return res.url;
+        } else {
+            throw new SERVER_ERROR({
+                displayMessage: res.error ?? "Unknown error",
+                debugData: {apiName}
+            })
+        }
+    }
+
+    public async register(): Promise<void> {
+        await this.ensureConnected();
+        if (this.entries.length > 0) {
+            await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.register, this.entries);
+        }
+        GGLog.info(this, `Registered ${this.entries.length} routes`);
+    }
+
+    public async unregister(): Promise<void> {
+        if (this.entries.length > 0 && this.client.isConnected()) {
+            try {
+                await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.unregister, this.entries);
+            } catch (err: any) {
+                GGLog.error(this, err);
+            }
+        }
+        this.client.disconnect();
+    }
+
+    protected async ensureConnected(): Promise<void> {
+        if (!this.client.isConnected()) {
+            await this.client.connect();
+        }
+    }
+}
+
+/**
+ * What consumers need to discover and connect to a service
+ */
+export interface GGServiceDiscoveryEntry {
+    api: string;
+    baseUrl: string;     // Complete base URL: "http://localhost:8080" or "http://service-name:8080"
+    pathPrefix: string;  // Path to append: "/api/users/"
+}
+

package/src/local/GGLocalDiscoveryResilientClient.ts

@@ -1,104 +1,104 @@
-import {GGLog} from "@grest-ts/logger";
-import {IPCServer} from "@grest-ts/ipc";
-import {GGLocalDiscoveryServer} from "./GGLocalDiscoveryServer";
-import {GGLocalDiscoveryClient} from "./GGLocalDiscoveryClient";
-
-export class GGLocalDiscoveryResilientClient extends GGLocalDiscoveryClient {
-
-    private discoveryServer?: GGLocalDiscoveryServer;
-    private isLeader = false;
-    private isShuttingDown = false;
-
-    constructor(port = 9000) {
-        super(port);
-    }
-
-    public override async register(): Promise<void> {
-        if (!this.isLeader && !this.discoveryServer && !this.client.isConnected()) {
-            await this.becomeLeaderOrFollower();
-        }
-        await super.register();
-    }
-
-    public override async unregister(): Promise<void> {
-        this.isShuttingDown = true;
-        await super.unregister();
-
-        if (this.discoveryServer) {
-            await this.discoveryServer.teardown();
-            this.discoveryServer = undefined;
-        }
-    }
-
-    private async becomeLeaderOrFollower(): Promise<void> {
-        if (this.isShuttingDown) return;
-
-        const server = new IPCServer(this.port);
-        const router = new GGLocalDiscoveryServer(server);
-        if (await router.start()) {
-            this.discoveryServer = router;
-            this.isLeader = true;
-            GGLog.info(this, "This instance is LEADER");
-        } else {
-            this.isLeader = false;
-            GGLog.info(this, "This instance is FOLLOWER");
-            await this.connectToLeader();
-        }
-    }
-
-    private async connectToLeader(): Promise<void> {
-        if (this.isShuttingDown) return;
-
-        try {
-            await this.client.connect();
-
-            this.client.onClose(async () => {
-                if (this.isShuttingDown) return;
-                GGLog.warn(this, "Leader died");
-                await this.becomeLeaderOrFollower();
-                if (this.isLeader && this.entries.length > 0) {
-                    await super.register();
-                }
-            });
-
-            GGLog.debug(this, "Connected to leader");
-        } catch (err: any) {
-            GGLog.error(this, `Failed to connect to leader: ${err.message}`);
-            await this.delay(1000);
-            await this.connectToLeader();
-        }
-    }
-
-    protected override async ensureConnected(): Promise<void> {
-        const maxRetries = 20;
-        let retryCount = 0;
-
-        while (true) {
-            try {
-                await super.ensureConnected();
-                return;
-            } catch (err: any) {
-                if (retryCount < maxRetries && this.isConnectionError(err)) {
-                    GGLog.debug(this, `Waiting for router...`);
-                    await this.delay(Math.min(500 * Math.pow(1.5, retryCount), 5000));
-                    retryCount++;
-                    continue;
-                }
-                throw err;
-            }
-        }
-    }
-
-    private delay(ms: number): Promise<void> {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-
-    private isConnectionError(err: any): boolean {
-        const codes = ['ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET'];
-        const hasCode = (code?: string) => code !== undefined && codes.includes(code);
-        return hasCode(err?.code) ||
-            hasCode(err?.cause?.code) ||
-            hasCode(err?.originalError?.code) ||
-            hasCode(err?.originalError?.cause?.code);
-    }
-}
+import {GGLog} from "@grest-ts/logger";
+import {IPCServer} from "@grest-ts/ipc";
+import {GGLocalDiscoveryServer} from "./GGLocalDiscoveryServer";
+import {GGLocalDiscoveryClient} from "./GGLocalDiscoveryClient";
+
+export class GGLocalDiscoveryResilientClient extends GGLocalDiscoveryClient {
+
+    private discoveryServer?: GGLocalDiscoveryServer;
+    private isLeader = false;
+    private isShuttingDown = false;
+
+    constructor(port = 9000) {
+        super(port);
+    }
+
+    public override async register(): Promise<void> {
+        if (!this.isLeader && !this.discoveryServer && !this.client.isConnected()) {
+            await this.becomeLeaderOrFollower();
+        }
+        await super.register();
+    }
+
+    public override async unregister(): Promise<void> {
+        this.isShuttingDown = true;
+        await super.unregister();
+
+        if (this.discoveryServer) {
+            await this.discoveryServer.teardown();
+            this.discoveryServer = undefined;
+        }
+    }
+
+    private async becomeLeaderOrFollower(): Promise<void> {
+        if (this.isShuttingDown) return;
+
+        const server = new IPCServer(this.port);
+        const router = new GGLocalDiscoveryServer(server);
+        if (await router.start()) {
+            this.discoveryServer = router;
+            this.isLeader = true;
+            GGLog.info(this, "This instance is LEADER");
+        } else {
+            this.isLeader = false;
+            GGLog.info(this, "This instance is FOLLOWER");
+            await this.connectToLeader();
+        }
+    }
+
+    private async connectToLeader(): Promise<void> {
+        if (this.isShuttingDown) return;
+
+        try {
+            await this.client.connect();
+
+            this.client.onClose(async () => {
+                if (this.isShuttingDown) return;
+                GGLog.warn(this, "Leader died");
+                await this.becomeLeaderOrFollower();
+                if (this.isLeader && this.entries.length > 0) {
+                    await super.register();
+                }
+            });
+
+            GGLog.debug(this, "Connected to leader");
+        } catch (err: any) {
+            GGLog.error(this, `Failed to connect to leader: ${err.message}`);
+            await this.delay(1000);
+            await this.connectToLeader();
+        }
+    }
+
+    protected override async ensureConnected(): Promise<void> {
+        const maxRetries = 20;
+        let retryCount = 0;
+
+        while (true) {
+            try {
+                await super.ensureConnected();
+                return;
+            } catch (err: any) {
+                if (retryCount < maxRetries && this.isConnectionError(err)) {
+                    GGLog.debug(this, `Waiting for router...`);
+                    await this.delay(Math.min(500 * Math.pow(1.5, retryCount), 5000));
+                    retryCount++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+
+    private delay(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    private isConnectionError(err: any): boolean {
+        const codes = ['ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET'];
+        const hasCode = (code?: string) => code !== undefined && codes.includes(code);
+        return hasCode(err?.code) ||
+            hasCode(err?.cause?.code) ||
+            hasCode(err?.originalError?.code) ||
+            hasCode(err?.originalError?.cause?.code);
+    }
+}