hypha-rpc 0.1.2 → 0.1.4

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();
@@ -223,22 +221,31 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         },
       });
       this.on("method", this._handle_method.bind(this));
+      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);
@@ -365,8 +372,10 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   _on_message(message) {
-    try {
-      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(message instanceof ArrayBuffer);
+    if (typeof message === "string") {
+      const main = JSON.parse(message);
+      this._fire(main["type"], main);
+    } else if (message instanceof ArrayBuffer) {
       let unpacker = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_1__.decodeMulti)(message);
       const { done, value } = unpacker.next();
       const main = value;
@@ -378,8 +387,8 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         Object.assign(main, extra.value);
       }
       this._fire(main["type"], main);
-    } catch (error) {
-      console.error("Failed to process message", error);
+    } else {
+      throw new Error("Invalid message format");
     }
   }
 
@@ -394,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;
@@ -418,7 +427,7 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       throw new Error("Service not found: " + service_id);
     }
 
-    service.config["workspace"] = ws;
+    service.config["workspace"] = context["ws"];
     // allow access for the same workspace
     if (service.config.visibility == "public") {
       return service;
@@ -435,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;
     }
@@ -611,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 {
@@ -638,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 {
@@ -1040,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 " +
@@ -1968,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) {
@@ -1980,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;
     };
@@ -2027,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,
@@ -2054,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 };
+      if (context && context.user) ctx = { user: context.user, ws: context.ws };
       const rpc = await _setupRPC({
         channel: channel,
         client_id: channel.label,
@@ -2101,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);
           }
         },
@@ -4163,7 +4170,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-const MAX_RETRY = 10000;
+const MAX_RETRY = 1000000;
 
 class WebsocketRPCConnection {
   constructor(
@@ -4184,11 +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._closing = false;
+    this._closed = false;
     this._legacy_auth = null;
     this.connection_info = null;
+    this._enable_reconnect = false;
+    this.manager_id = null;
   }
 
   on_message(handler) {
@@ -4217,7 +4226,7 @@ class WebsocketRPCConnection {
 
       websocket.onerror = (event) => {
         console.error("WebSocket connection error:", event);
-        reject(event);
+        reject(new Error(`ConnectionAbortedError: ${event}`));
       };
 
       websocket.onclose = (event) => {
@@ -4225,6 +4234,7 @@ class WebsocketRPCConnection {
           console.info(
             "Received 1003 error, attempting connection with query parameters.",
           );
+          this._legacy_auth = true;
           this._attempt_connection_with_query_params(server_url)
             .then(resolve)
             .catch(reject);
@@ -4258,69 +4268,158 @@ class WebsocketRPCConnection {
     // Construct the full URL by appending the query string if it exists
     const full_url = server_url + queryString;
 
-    this._legacy_auth = true; // Assuming this flag is needed for some other logic
     return await this._attempt_connection(full_url, false);
   }
 
+  _establish_connection() {
+    return new Promise((resolve, reject) => {
+      this._websocket.onmessage = (event) => {
+        const data = event.data;
+        const first_message = JSON.parse(data);
+        if (first_message.type == "connection_info") {
+          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.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") {
+          const error = first_message.error || "Unknown error";
+          console.error("Failed to connect, " + error);
+          reject(new Error(error));
+          return;
+        } else {
+          console.error("Unexpected message received from the server:", data);
+          reject(new Error("Unexpected message received from the server"));
+          return;
+        }
+      };
+    });
+  }
+
   async open() {
-    if (this._closing || this._websocket) {
-      return; // Avoid opening a new connection if closing or already open
-    }
+    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)(
-          new Promise((resolve, reject) => {
-            this._websocket.onmessage = (event) => {
-              const data = event.data;
-              const first_message = JSON.parse(data);
-              if (!first_message.success) {
-                const error = first_message.error || "Unknown error";
-                console.error("Failed to connect, " + error);
-                this.connection_info = null;
-                reject(new Error(error));
-              } else if (first_message) {
-                console.log(
-                  "Successfully connected: " + JSON.stringify(first_message),
-                );
-                this.connection_info = first_message;
-                if (this.connection_info.reconnection_token) {
-                  this._reconnection_token =
-                    this.connection_info.reconnection_token;
-                }
-              }
-              resolve();
-            };
-          }),
-          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",
         );
       }
-
+      // 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;
       this._websocket.onmessage = (event) => {
         this._handle_message(event.data);
       };
 
+      this._websocket.onclose = this._handle_close.bind(this);
+
       if (this._handle_connect) {
-        await this._handle_connect(this);
+        this._handle_connect(this);
       }
+      return this.connection_info;
     } catch (error) {
-      console.error("Failed to connect to", this._server_url, 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 ([1000].includes(event.code)) {
+        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,
+        );
+        let retry = 0;
+        const reconnect = async () => {
+          try {
+            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
+            ) {
+              return;
+            }
+            retry += 1;
+            if (retry < MAX_RETRY) {
+              await reconnect();
+            } else {
+              console.error("Failed to reconnect after", MAX_RETRY, "attempts");
+            }
+          }
+        };
+        reconnect();
+      }
+    } else {
+      if (this._disconnect_handler) {
+        this._disconnect_handler(event.reason);
+      }
     }
   }
 
   async emit_message(data) {
-    if (this._closing) {
-      throw new Error("Connection is closing");
+    if (this._closed) {
+      throw new Error("Connection is closed");
     }
     if (!this._websocket || this._websocket.readyState !== WebSocket.OPEN) {
       await this.open();
@@ -4334,11 +4433,11 @@ class WebsocketRPCConnection {
   }
 
   disconnect(reason) {
-    this._closing = true;
+    this._closed = true;
     if (this._websocket && this._websocket.readyState === WebSocket.OPEN) {
       this._websocket.close(1000, reason);
-      console.info(`WebSocket connection disconnected (${reason})`);
     }
+    console.info(`WebSocket connection disconnected (${reason})`);
   }
 }
 
@@ -4401,22 +4500,20 @@ async function connectToServer(config) {
     config.method_timeout || 60,
     config.WebSocketClass,
   );
-  await connection.open();
-  (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(connection.connection_info, "Failed to connect to the server, no connection info obtained");
-  if (
-    config.workspace &&
-    connection.connection_info.workspace !== config.workspace
-  ) {
+  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) {
     throw new Error(
-      `Connected to the wrong workspace: ${connection.connection_info.workspace}, expected: ${config.workspace}`,
+      `Connected to the wrong workspace: ${connection_info.workspace}, expected: ${config.workspace}`,
     );
   }
-  const workspace = connection.connection_info.workspace;
-  const manager_id = connection.connection_info.manager_id;
+  const workspace = connection_info.workspace;
   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,
@@ -4440,8 +4537,8 @@ async function connectToServer(config) {
     await rpc.disconnect();
     await connection.disconnect();
   }
-  if (connection.connection_info) {
-    wm.config = Object.assign(wm.config, connection.connection_info);
+  if (connection_info) {
+    wm.config = Object.assign(wm.config, connection_info);
   }
   wm.export = _export;
   wm.getPlugin = getPlugin;
@@ -4450,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();
       }