hypha-rpc 0.1.3 → 0.1.5

package/dist/hypha-rpc-websocket.js

@@ -172,7 +172,6 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     connection,
     {
       client_id = null,
-      manager_id = null,
       default_context = null,
       name = null,
       codecs = null,
@@ -192,7 +191,6 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     this._name = name;
     this._app_id = app_id || "*";
     this._local_workspace = workspace;
-    this.manager_id = manager_id;
     this._silent = silent;
     this.default_context = default_context || {};
     this._method_annotations = new WeakMap();
@@ -226,20 +224,28 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       this.on("error", console.error);
 
       (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(connection.emit_message && connection.on_message);
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        connection.manager_id !== undefined,
+        "Connection must have manager_id",
+      );
       this._emit_message = connection.emit_message.bind(connection);
       connection.on_message(this._on_message.bind(this));
       this._connection = connection;
       const updateServices = async () => {
-        if (!this._silent && this.manager_id) {
+        if (!this._silent && this._connection.manager_id) {
           console.log("Connection established, reporting services...");
           for (let service of Object.values(this._services)) {
             const serviceInfo = this._extract_service_info(service);
             await this.emit({
               type: "service-added",
-              to: "*/" + this.manager_id,
+              to: "*/" + this._connection.manager_id,
               service: serviceInfo,
             });
           }
+        } else {
+          console.log(
+            "Connection established, no manager id to report services",
+          );
         }
       };
       connection.on_connect(updateServices);
@@ -366,11 +372,10 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   _on_message(message) {
-    if(typeof message === "string"){
+    if (typeof message === "string") {
       const main = JSON.parse(message);
       this._fire(main["type"], main);
-    }
-    else if (message instanceof ArrayBuffer) {
+    } else if (message instanceof ArrayBuffer) {
       let unpacker = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_1__.decodeMulti)(message);
       const { done, value } = unpacker.next();
       const main = value;
@@ -382,8 +387,7 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         Object.assign(main, extra.value);
       }
       this._fire(main["type"], main);
-    }
-    else{
+    } else {
       throw new Error("Invalid message format");
     }
   }
@@ -399,9 +403,9 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   async get_manager_service(timeout) {
-    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(this.manager_id, "Manager id is not set");
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(this._connection.manager_id, "Manager id is not set");
     const svc = await this.get_remote_service(
-      `*/${this.manager_id}:default`,
+      `*/${this._connection.manager_id}:default`,
       timeout,
     );
     return svc;
@@ -440,8 +444,8 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
   async get_remote_service(service_uri, timeout) {
     timeout = timeout === undefined ? this._method_timeout : timeout;
-    if (!service_uri && this.manager_id) {
-      service_uri = "*/" + this.manager_id;
+    if (!service_uri && this._connection.manager_id) {
+      service_uri = "*/" + this._connection.manager_id;
     } else if (!service_uri.includes(":")) {
       service_uri = this._client_id + ":" + service_uri;
     }
@@ -616,10 +620,10 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     const service = this.add_service(api, overwrite);
     const serviceInfo = this._extract_service_info(service);
     if (notify) {
-      if (this.manager_id) {
+      if (this._connection.manager_id) {
         await this.emit({
           type: "service-added",
-          to: "*/" + this.manager_id,
+          to: "*/" + this._connection.manager_id,
           service: serviceInfo,
         });
       } else {
@@ -643,10 +647,10 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     delete this._services[service];
     if (notify) {
       const serviceInfo = this._extract_service_info(api);
-      if (this.manager_id) {
+      if (this._connection.manager_id) {
         this.emit({
           type: "service-removed",
-          to: "*/" + this.manager_id,
+          to: "*/" + this._connection.manager_id,
           service: serviceInfo,
         });
       } else {
@@ -1045,7 +1049,8 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         if (this._method_annotations.get(method).visibility === "protected") {
           if (
             local_workspace !== remote_workspace &&
-            (remote_workspace !== "*" || remote_client_id !== this.manager_id)
+            (remote_workspace !== "*" ||
+              remote_client_id !== this._connection.manager_id)
           ) {
             throw new Error(
               "Permission denied for invoking protected method " +
@@ -1973,9 +1978,10 @@ class WebRTCConnection {
     this._reconnection_token = null;
     this._disconnect_handler = null;
     this._handle_connect = () => {};
-    this._data_channel.onopen = async ()=>{
+    this.manager_id = null;
+    this._data_channel.onopen = async () => {
       this._handle_connect && this._handle_connect();
-    }
+    };
     this._data_channel.onmessage = async (event) => {
       let data = event.data;
       if (data instanceof Blob) {
@@ -1985,8 +1991,7 @@ class WebRTCConnection {
     };
     const self = this;
     this._data_channel.onclose = function () {
-      if(this._disconnect_handler)
-      this._disconnect_handler("closed");
+      if (this._disconnect_handler) this._disconnect_handler("closed");
       console.log("websocket closed");
       self._data_channel = null;
     };
@@ -2032,7 +2037,6 @@ async function _setupRPC(config) {
   config.context.connection_type = "webrtc";
   const rpc = new _rpc_js__WEBPACK_IMPORTED_MODULE_0__.RPC(connection, {
     client_id: clientId,
-    manager_id: null,
     default_context: config.context,
     name: config.name,
     method_timeout: config.method_timeout || 10.0,
@@ -2059,7 +2063,7 @@ async function _createOffer(params, server, config, onInit, context) {
     pc.addEventListener("datachannel", async (event) => {
       const channel = event.channel;
       let ctx = null;
-      if (context && context.user) ctx = { user: context.user, ws: context.ws};
+      if (context && context.user) ctx = { user: context.user, ws: context.ws };
       const rpc = await _setupRPC({
         channel: channel,
         client_id: channel.label,
@@ -2106,11 +2110,9 @@ async function getRTCService(server, service_id, config) {
           if (pc.connectionState === "failed") {
             pc.close();
             reject(new Error("WebRTC Connection failed"));
-          }
-          else if (pc.connectionState === "closed") {
+          } else if (pc.connectionState === "closed") {
             reject(new Error("WebRTC Connection closed"));
-          }
-          else{
+          } else {
             console.log("WebRTC Connection state: ", pc.connectionState);
           }
         },
@@ -4189,12 +4191,13 @@ class WebsocketRPCConnection {
     this._handle_message = null;
     this._handle_connect = null; // Connection open event handler
     this._disconnect_handler = null; // Disconnection event handler
-    this._timeout = timeout * 1000; // Convert seconds to milliseconds
+    this._timeout = timeout;
     this._WebSocketClass = WebSocketClass || WebSocket; // Allow overriding the WebSocket class
     this._closed = false;
     this._legacy_auth = null;
     this.connection_info = null;
     this._enable_reconnect = false;
+    this.manager_id = null;
   }
 
   on_message(handler) {
@@ -4223,7 +4226,7 @@ class WebsocketRPCConnection {
 
       websocket.onerror = (event) => {
         console.error("WebSocket connection error:", event);
-        reject(event);
+        reject(new Error(`ConnectionAbortedError: ${event}`));
       };
 
       websocket.onclose = (event) => {
@@ -4274,61 +4277,61 @@ class WebsocketRPCConnection {
         const data = event.data;
         const first_message = JSON.parse(data);
         if (first_message.type == "connection_info") {
-          console.log(
-            "Successfully connected: " + JSON.stringify(first_message),
-          );
           this.connection_info = first_message;
+          if (this._workspace) {
+            (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
+              this.connection_info.workspace === this._workspace,
+              `Connected to the wrong workspace: ${this.connection_info.workspace}, expected: ${this._workspace}`,
+            );
+          }
           if (this.connection_info.reconnection_token) {
-            this._reconnection_token =
-              this.connection_info.reconnection_token;
+            this._reconnection_token = this.connection_info.reconnection_token;
           }
+          this.manager_id = this.connection_info.manager_id || null;
+          console.log(
+            `Successfully connected to the server, workspace: ${this.connection_info.workspace}, manager_id: ${this.manager_id}`,
+          );
           resolve(this.connection_info);
-        }
-        else if (first_message.type == "error") {
+        } else if (first_message.type == "error") {
           const error = first_message.error || "Unknown error";
           console.error("Failed to connect, " + error);
-          this.connection_info = null;
           reject(new Error(error));
           return;
         } else {
-          console.error(
-            "Unexpected message received from the server:",
-            data,
-          );
+          console.error("Unexpected message received from the server:", data);
           reject(new Error("Unexpected message received from the server"));
           return;
         }
-        
       };
-    })
+    });
   }
 
   async open() {
-    if (this._closed){
-      throw new Error("Connection is closing");
-    }
-    console.log("Creating a new websocket connection to", this._server_url.split("?")[0]);
+    console.log(
+      "Creating a new websocket connection to",
+      this._server_url.split("?")[0],
+    );
     try {
       this._websocket = await this._attempt_connection(this._server_url);
-      if (!this._legacy_auth) {
-        // Send authentication info as the first message if connected without query params
-        const authInfo = JSON.stringify({
-          client_id: this._client_id,
-          workspace: this._workspace,
-          token: this._token,
-          reconnection_token: this._reconnection_token,
-        });
-        this._websocket.send(authInfo);
-        // Wait for the first message from the server
-        await (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.waitFor)(
-          this._establish_connection(),
-          this._timeout / 1000.0,
-          "Failed to receive the first message from the server",
+      if (this._legacy_auth) {
+        throw new Error(
+          "NotImplementedError: Legacy authentication is not supported",
         );
       }
-      else{
-        throw new Error("Legacy authentication is not supported");
-      }
+      // Send authentication info as the first message if connected without query params
+      const authInfo = JSON.stringify({
+        client_id: this._client_id,
+        workspace: this._workspace,
+        token: this._token,
+        reconnection_token: this._reconnection_token,
+      });
+      this._websocket.send(authInfo);
+      // Wait for the first message from the server
+      await (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.waitFor)(
+        this._establish_connection(),
+        this._timeout,
+        "Failed to receive the first message from the server",
+      );
       // Listen to messages from the server
       this._enable_reconnect = true;
       this._closed = false;
@@ -4343,30 +4346,58 @@ class WebsocketRPCConnection {
       }
       return this.connection_info;
     } catch (error) {
-      console.error("Failed to connect to", this._server_url.split("?")[0], error);
+      console.error(
+        "Failed to connect to",
+        this._server_url.split("?")[0],
+        error,
+      );
       throw error;
     }
   }
 
   _handle_close(event) {
-    if (!this._closed && this._websocket && this._websocket.readyState === WebSocket.CLOSED) {
+    if (
+      !this._closed &&
+      this._websocket &&
+      this._websocket.readyState === WebSocket.CLOSED
+    ) {
       if ([1000].includes(event.code)) {
-        console.info("Websocket connection closed (code: %s): %s", event.code, event.reason);
+        console.info(
+          "Websocket connection closed (code: %s): %s",
+          event.code,
+          event.reason,
+        );
         if (this._disconnect_handler) {
           this._disconnect_handler(event.reason);
         }
         this._closed = true;
       } else if (this._enable_reconnect) {
-        console.warn("Websocket connection closed unexpectedly (code: %s): %s", event.code, event.reason);
+        console.warn(
+          "Websocket connection closed unexpectedly (code: %s): %s",
+          event.code,
+          event.reason,
+        );
         let retry = 0;
         const reconnect = async () => {
           try {
-            console.info("Reconnecting to", this._server_url.split("?")[0]);
+            console.info(
+              `Reconnecting to ${this._server_url.split("?")[0]} (attempt #${retry})`,
+            );
             await this.open();
           } catch (e) {
+            if (`${e}`.includes("ConnectionAbortedError")) {
+              console.warn("Failed to reconnect, connection aborted:", e);
+              return;
+            } else if (`${e}`.includes("NotImplementedError")) {
+              console.warn("Failed to reconnect, connection aborted:", e);
+              return;
+            }
             console.warn("Failed to reconnect:", e);
             await new Promise((resolve) => setTimeout(resolve, 1000));
-            if(this._websocket && this._websocket.readyState === WebSocket.CONNECTED){
+            if (
+              this._websocket &&
+              this._websocket.readyState === WebSocket.CONNECTED
+            ) {
               return;
             }
             retry += 1;
@@ -4405,7 +4436,6 @@ class WebsocketRPCConnection {
     this._closed = true;
     if (this._websocket && this._websocket.readyState === WebSocket.OPEN) {
       this._websocket.close(1000, reason);
-      
     }
     console.info(`WebSocket connection disconnected (${reason})`);
   }
@@ -4471,21 +4501,19 @@ async function connectToServer(config) {
     config.WebSocketClass,
   );
   const connection_info = await connection.open();
-  (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(connection_info, "Failed to connect to the server, no connection info obtained. This issue is most likely due to an outdated Hypha server version. Please use `imjoy-rpc` for compatibility, or upgrade the Hypha server to the latest version.");
-  if (
-    config.workspace &&
-    connection_info.workspace !== config.workspace
-  ) {
+  (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
+    connection_info,
+    "Failed to connect to the server, no connection info obtained. This issue is most likely due to an outdated Hypha server version. Please use `imjoy-rpc` for compatibility, or upgrade the Hypha server to the latest version.",
+  );
+  if (config.workspace && connection_info.workspace !== config.workspace) {
     throw new Error(
       `Connected to the wrong workspace: ${connection_info.workspace}, expected: ${config.workspace}`,
     );
   }
   const workspace = connection_info.workspace;
-  const manager_id = connection_info.manager_id;
   const rpc = new _rpc_js__WEBPACK_IMPORTED_MODULE_0__.RPC(connection, {
     client_id: clientId,
     workspace,
-    manager_id,
     default_context: { connection_type: "websocket" },
     name: config.name,
     method_timeout: config.method_timeout,
@@ -4519,9 +4547,9 @@ async function connectToServer(config) {
   wm.registerCodec = rpc.register_codec.bind(rpc);
   wm.emit = rpc.emit;
   wm.on = rpc.on;
-  if (rpc.manager_id) {
+  if (connection.manager_id) {
     rpc.on("force-exit", async (message) => {
-      if (message.from === "*/" + rpc.manager_id) {
+      if (message.from === "*/" + connection.manager_id) {
         console.log("Disconnecting from server, reason:", message.reason);
         await disconnect();
       }