Add logic back to try to reconnect to the app websocket if socket is closed

README.md

@@ -179,8 +179,9 @@ You need `holochain` and `hc` on your path, best to get them from nix with `nix-
 
 To perform the pre-requisite DNA compilation steps, and run the Nodejs test, run:
 ```bash
-nix-shell
-./run-test.sh
+nix develop
+./build-fixture.sh
+npm run test
 ```
 
 ## Contribute

src/api/app/websocket.ts

@@ -1,7 +1,12 @@
 import Emittery, { UnsubscribeFunction } from "emittery";
 import { omit } from "lodash-es";
 import { AgentPubKey, CellId, InstalledAppId, RoleName } from "../../types.js";
-import { AppInfo, CellType, MemproofMap } from "../admin/index.js";
+import {
+  AppAuthenticationToken,
+  AppInfo,
+  CellType,
+  MemproofMap,
+} from "../admin/index.js";
 import {
   catchError,
   DEFAULT_TIMEOUT,
@@ -77,6 +82,7 @@ export class AppWebsocket implements AppClient {
     CallZomeResponseGeneric<Uint8Array>,
     CallZomeResponse
   >;
+  private readonly appAuthenticationToken: AppAuthenticationToken;
 
   cachedAppInfo?: AppInfo | null;
 
@@ -110,6 +116,7 @@ export class AppWebsocket implements AppClient {
   private constructor(
     client: WsClient,
     appInfo: AppInfo,
+    token: AppAuthenticationToken,
     callZomeTransform?: CallZomeTransform,
     defaultTimeout?: number
   ) {
@@ -118,6 +125,7 @@ export class AppWebsocket implements AppClient {
     this.installedAppId = appInfo.installed_app_id;
     this.defaultTimeout = defaultTimeout ?? DEFAULT_TIMEOUT;
     this.callZomeTransform = callZomeTransform ?? defaultCallZomeTransform;
+    this.appAuthenticationToken = token;
     this.emitter = new Emittery<AppEvents>();
     this.cachedAppInfo = appInfo;
 
@@ -204,18 +212,15 @@ export class AppWebsocket implements AppClient {
 
     const client = await WsClient.connect(options.url, options.wsClientOptions);
 
-    if (env?.APP_INTERFACE_TOKEN) {
-      // Note: This will only work for multiple connections if a single_use = false token is provided
-      await client.authenticate({ token: env.APP_INTERFACE_TOKEN });
-    } else {
-      if (!options.token) {
-        throw new HolochainError(
-          "AppAuthenticationTokenMissing",
-          `unable to connect to Conductor API - no app authentication token provided.`
-        );
-      }
-      await client.authenticate({ token: options.token });
-    }
+    const token = options.token ?? env?.APP_INTERFACE_TOKEN;
+
+    if (!token)
+      throw new HolochainError(
+        "AppAuthenticationTokenMissing",
+        `unable to connect to Conductor API - no app authentication token provided.`
+      );
+
+    await client.authenticate({ token });
 
     const appInfo = await (
       AppWebsocket.requester(client, "app_info", DEFAULT_TIMEOUT) as Requester<
@@ -233,6 +238,7 @@ export class AppWebsocket implements AppClient {
     return new AppWebsocket(
       client,
       appInfo,
+      token,
       options.callZomeTransform,
       options.defaultTimeout
     );

src/api/client.ts

@@ -40,6 +40,7 @@ export class WsClient extends Emittery {
   options: WsClientOptions;
   private pendingRequests: Record<number, HolochainRequest>;
   private index: number;
+  private authenticationToken: AppAuthenticationToken | undefined;
 
   constructor(socket: IsoWebSocket, url?: URL, options?: WsClientOptions) {
     super();
@@ -178,6 +179,7 @@ export class WsClient extends Emittery {
    * @param request - The authentication request, containing an app authentication token.
    */
   async authenticate(request: AppAuthenticationRequest): Promise<void> {
+    this.authenticationToken = request.token;
     return this.exchange(request, (request, resolve) => {
       const encodedMsg = encode({
         type: "authenticate",
@@ -212,6 +214,33 @@ export class WsClient extends Emittery {
         sendHandler(request, resolve, reject);
       });
       return promise as Promise<Response>;
+    } else if (this.url && this.authenticationToken) {
+      const response = new Promise<unknown>((resolve, reject) => {
+        // typescript forgets in this promise scope that `this.url` is not undefined
+        const socket = new IsoWebSocket(this.url as URL, this.options);
+        this.socket = socket;
+        socket.onerror = (errorEvent) => {
+          reject(
+            new HolochainError(
+              "ConnectionError",
+              `could not connect to Holochain Conductor API at ${this.url} - ${errorEvent.error}`
+            )
+          );
+        };
+        socket.onopen = () => {
+          // Send authentication token
+          const encodedMsg = encode({
+            type: "authenticate",
+            data: encode({
+              token: this.authenticationToken as AppAuthenticationToken,
+            }),
+          });
+          this.socket.send(encodedMsg);
+          sendHandler(request, resolve, reject);
+        };
+        this.setupSocket();
+      });
+      return response as Promise<Response>;
     } else {
       return Promise.reject(new Error("Socket is not open"));
     }

test/e2e/common.ts

@@ -97,7 +97,8 @@ export const withConductor =
   };
 
 export const installAppAndDna = async (
-  adminPort: number
+  adminPort: number,
+  nonExpiringToken?: boolean
 ): Promise<{
   installed_app_id: InstalledAppId;
   cell_id: CellId;
@@ -127,6 +128,8 @@ export const installAppAndDna = async (
   });
   const issued = await admin.issueAppAuthenticationToken({
     installed_app_id,
+    single_use: !nonExpiringToken,
+    expiry_seconds: nonExpiringToken ? 0 : 30,
   });
   const client = await AppWebsocket.connect({
     url: new URL(`ws://localhost:${appPort}`),

test/e2e/index.ts

@@ -1441,6 +1441,52 @@ test(
   })
 );
 
+test(
+  "client reconnects websocket if closed before making a zome call",
+  withConductor(ADMIN_PORT, async (t) => {
+    const { cell_id, client, admin } = await installAppAndDna(ADMIN_PORT, true);
+    await admin.authorizeSigningCredentials(cell_id);
+    await client.client.close();
+    const call = client.callZome({
+      cell_id,
+      zome_name: TEST_ZOME_NAME,
+      fn_name: "bar",
+      provenance: cell_id[1],
+      payload: null,
+    });
+    try {
+      await call;
+      t.pass("websocket was reconnected successfully");
+    } catch (error) {
+      t.fail("websocket was not reconnected");
+    }
+  })
+);
+
+test(
+  "client fails to reconnect to websocket if closed before making a zome call and does not end up in a loop",
+  withConductor(ADMIN_PORT, async (t) => {
+    const { cell_id, client, admin } = await installAppAndDna(ADMIN_PORT);
+    await admin.authorizeSigningCredentials(cell_id);
+    await client.client.close();
+    const call = client.callZome({
+      cell_id,
+      zome_name: TEST_ZOME_NAME,
+      fn_name: "bar",
+      provenance: cell_id[1],
+      payload: null,
+    });
+    try {
+      await call;
+      t.fail(
+        "reconnecting to websocket should have failed due to an invalid token."
+      );
+    } catch (error) {
+      t.pass("reconnecting to websocket failed");
+    }
+  })
+);
+
 test(
   "Rust enums are serialized correctly",
   withConductor(ADMIN_PORT, async (t) => {