@grest-ts/discovery-local 0.0.37 → 0.0.38

package/src/local/GGDiscoveryIPC.ts

@@ -8,10 +8,17 @@ export interface DiscoverApiResult {
     error?: string;
 }
 
+export enum DiscoveryServerKind {
+    Bin = "bin",
+    Embedded = "embedded",
+}
+
 export const GGDiscoveryIPC = {
     discoveryServer: {
         register: IPCServer.defineRequest<GGServiceDiscoveryEntry[], void>("discovery/register"),
         unregister: IPCServer.defineRequest<GGServiceDiscoveryEntry[], void>("discovery/unregister"),
         discoverApi: IPCServer.defineRequest<string, DiscoverApiResult>("discovery/discoverApi"),
+        getServerInfo: IPCServer.defineRequest<undefined, {kind: DiscoveryServerKind}>("discovery/getServerInfo"),
+        requestYield: IPCServer.defineRequest<undefined, void>("discovery/requestYield"),
     }
 }

package/src/local/GGLocalDiscoveryClient.ts

@@ -11,6 +11,18 @@ import {SERVER_ERROR} from "@grest-ts/schema";
  */
 export const GG_LOCAL_ROUTER_PORT = "GG_LOCAL_ROUTER_PORT"
 
+/** Default port for the local discovery router. Centralised so a future
+ *  change (env-var override, per-environment isolation) has one hook. */
+export function getLocalDiscoveryPort(): number {
+    const v = process.env[GG_LOCAL_ROUTER_PORT];
+    if (v === undefined) return 9000;
+    const n = Number(v);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new Error(`Invalid ${GG_LOCAL_ROUTER_PORT}=${v}, expected positive integer`);
+    }
+    return n;
+}
+
 export class GGLocalDiscoveryClient extends GGDiscoveryClient {
 
     public override readonly isLocal = true;
@@ -77,12 +89,34 @@ export class GGLocalDiscoveryClient extends GGDiscoveryClient {
     }
 
     protected async ensureConnected(): Promise<void> {
-        if (!this.client.isConnected()) {
-            await this.client.connect();
+        if (this.client.isConnected()) return;
+        // Retry with backoff: when the router runs as its own process
+        // (e.g. launched via the `discovery-local` bin), a runtime can
+        // come up before the router has bound its port. Tolerate that
+        // instead of failing the runtime's startup outright.
+        const maxRetries = 20;
+        for (let attempt = 0; ; attempt++) {
+            try {
+                await this.client.connect();
+                return;
+            } catch (err: any) {
+                if (attempt >= maxRetries || !isConnectionError(err)) throw err;
+                GGLog.debug(this, "Waiting for discovery router...");
+                await new Promise(r => setTimeout(r, Math.min(500 * Math.pow(1.5, attempt), 5000)));
+            }
         }
     }
 }
 
+/** True for the transient socket errors seen while a router process is
+ *  still coming up — worth retrying, unlike a real protocol failure. */
+function isConnectionError(err: any): boolean {
+    const codes = ["ECONNREFUSED", "ETIMEDOUT", "ECONNRESET", "ENOENT"];
+    const has = (code?: string) => code !== undefined && codes.includes(code);
+    return has(err?.code) || has(err?.cause?.code)
+        || has(err?.originalError?.code) || has(err?.originalError?.cause?.code);
+}
+
 /**
  * What consumers need to discover and connect to a service
  */

package/src/local/GGLocalDiscoveryResilientClient.ts

@@ -1,15 +1,19 @@
 import {GGLog} from "@grest-ts/logger";
 import {IPCServer} from "@grest-ts/ipc";
 import {GGLocalDiscoveryServer} from "./GGLocalDiscoveryServer";
-import {GGLocalDiscoveryClient} from "./GGLocalDiscoveryClient";
+import {GGLocalDiscoveryClient, getLocalDiscoveryPort} from "./GGLocalDiscoveryClient";
+import {GGDiscoveryIPC, DiscoveryServerKind} from "./GGDiscoveryIPC";
 
 export class GGLocalDiscoveryResilientClient extends GGLocalDiscoveryClient {
 
     private discoveryServer?: GGLocalDiscoveryServer;
     private isLeader = false;
     private isShuttingDown = false;
+    /** Once any bin has held the port in this runtime's lifetime, never
+     *  bid for it again. In-memory only. */
+    private seenBinBasedMaster = false;
 
-    constructor(port = 9000) {
+    constructor(port = getLocalDiscoveryPort()) {
         super(port);
     }
 
@@ -32,12 +36,18 @@ export class GGLocalDiscoveryResilientClient extends GGLocalDiscoveryClient {
 
     private async becomeLeaderOrFollower(): Promise<void> {
         if (this.isShuttingDown) return;
+        if (this.seenBinBasedMaster) return this.connectToLeader();
 
-        const server = new IPCServer(this.port);
-        const router = new GGLocalDiscoveryServer(server);
+        const router = new GGLocalDiscoveryServer(new IPCServer(this.port));
         if (await router.start()) {
             this.discoveryServer = router;
             this.isLeader = true;
+            router.onYield = async () => {
+                this.seenBinBasedMaster = true;
+                this.isLeader = false;
+                this.discoveryServer = undefined;
+                await this.connectToLeader();
+            };
             GGLog.info(this, "This instance is LEADER");
         } else {
             this.isLeader = false;
@@ -52,6 +62,11 @@ export class GGLocalDiscoveryResilientClient extends GGLocalDiscoveryClient {
         try {
             await this.client.connect();
 
+            if (!this.seenBinBasedMaster) {
+                const info = await this.client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.getServerInfo, undefined);
+                if (info.kind === DiscoveryServerKind.Bin) this.seenBinBasedMaster = true;
+            }
+
             this.client.onClose(async () => {
                 if (this.isShuttingDown) return;
                 GGLog.warn(this, "Leader died");

package/src/local/GGLocalDiscoveryServer.ts

@@ -5,7 +5,7 @@ import {FirstStrategy} from "./routing/strategies/FirstStrategy";
 import {LastStrategy} from "./routing/strategies/LastStrategy";
 import {RandomStrategy} from "./routing/strategies/RandomStrategy";
 import {RoundRobinStrategy} from "./routing/strategies/RoundRobinStrategy";
-import {GGDiscoveryIPC} from "./GGDiscoveryIPC";
+import {GGDiscoveryIPC, DiscoveryServerKind} from "./GGDiscoveryIPC";
 import {GGServiceDiscoveryEntry} from "./GGLocalDiscoveryClient";
 
 export const ROUTING_STRATEGIES = {
@@ -32,8 +32,9 @@ export class GGLocalDiscoveryServer {
     private readonly server: IPCServer;
     private readonly routes: Map<string, RegisteredEntry[]> = new Map();
     private readonly routingStrategies: Map<string, RoutingStrategy> = new Map();
-
-    constructor(server: IPCServer) {
+    public onYield?: () => Promise<void>;
+  
+    constructor(server: IPCServer, public readonly kind: DiscoveryServerKind = DiscoveryServerKind.Embedded) {
         this.server = server;
 
         // Socket handlers for framework communication
@@ -57,6 +58,17 @@ export class GGLocalDiscoveryServer {
             return {success: false, error: "Service '" + apiName + "' is not registered! Did you forget to start it?"};
         });
 
+        this.server.onFrameworkMessage(GGDiscoveryIPC.discoveryServer.getServerInfo, async () => ({kind: this.kind}));
+
+        // Defer release so the ack flushes before we close the socket.
+        // onYield owners (e.g. resilient client) own teardown themselves.
+        this.server.onFrameworkMessage(GGDiscoveryIPC.discoveryServer.requestYield, async () => {
+            setTimeout(async () => {
+                await this.teardown();
+                await this.onYield?.();
+            }, 10);
+        });
+
         this.server.setRouteProxyResolver((path) => {
             return this.matchRoute(path)?.baseUrl || undefined;
         })

package/src/local/yield.test.ts

@@ -0,0 +1,70 @@
+import {IPCServer, IPCClient} from "@grest-ts/ipc";
+import {GGLocatorScope} from "@grest-ts/locator";
+import {GGLocalDiscoveryServer} from "./GGLocalDiscoveryServer";
+import {GGLocalDiscoveryResilientClient} from "./GGLocalDiscoveryResilientClient";
+import {GGDiscoveryIPC, DiscoveryServerKind} from "./GGDiscoveryIPC";
+
+async function startServer(kind: DiscoveryServerKind): Promise<{server: GGLocalDiscoveryServer, port: number}> {
+    const ipc = new IPCServer(0);
+    const server = new GGLocalDiscoveryServer(ipc, kind);
+    if (!(await server.start())) throw new Error("bind failed");
+    return {server, port: ipc.getPort()};
+}
+
+async function isPortFree(port: number): Promise<boolean> {
+    const probe = new IPCServer(port);
+    const ok = await probe.start();
+    if (ok) await probe.teardown();
+    return ok;
+}
+
+describe("yield protocol", () => {
+
+    beforeEach(() => {
+        new GGLocatorScope("YieldProtocolTest").enter();
+    });
+
+    test("getServerInfo returns kind; requestYield without onYield tears down", async () => {
+        const {server, port} = await startServer(DiscoveryServerKind.Bin);
+        const client = new IPCClient(port);
+        await client.connect();
+        const info = await client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.getServerInfo, undefined);
+        expect(info.kind).toBe(DiscoveryServerKind.Bin);
+        await client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.requestYield, undefined);
+        client.disconnect();
+        await new Promise(r => setTimeout(r, 100));
+        expect(await isPortFree(port)).toBe(true);
+        await server.teardown().catch((): undefined => undefined);
+    });
+
+    test("requestYield invokes onYield after teardown", async () => {
+        const {server, port} = await startServer(DiscoveryServerKind.Embedded);
+        let firedAfterTeardown = false;
+        server.onYield = async () => { firedAfterTeardown = await isPortFree(port); };
+        const client = new IPCClient(port);
+        await client.connect();
+        await client.sendFrameworkRequest(GGDiscoveryIPC.discoveryServer.requestYield, undefined);
+        client.disconnect();
+        await new Promise(r => setTimeout(r, 100));
+        expect(firedAfterTeardown).toBe(true);
+        expect(await isPortFree(port)).toBe(true);
+    });
+
+    test("resilient client that connected to a bin never re-bids after the bin dies", async () => {
+        const {server: bin, port} = await startServer(DiscoveryServerKind.Bin);
+
+        // Sub-scope with a no-op lifecycle owner so the client constructor
+        // (which does setWithLifecycle on GG_DISCOVERY) doesn't throw.
+        const subscope = new GGLocatorScope("ResilientClientTest");
+        subscope.setLifecycleOwner(() => undefined);
+        subscope.enter();
+        const resilient = new GGLocalDiscoveryResilientClient(port);
+        await resilient.register();
+
+        await bin.teardown();
+        await new Promise(r => setTimeout(r, 200));
+
+        expect(await isPortFree(port)).toBe(true);
+        await resilient.unregister();
+    });
+});