@kitware/wslink 2.5.0

package/src/SmartConnect/index.js

@@ -0,0 +1,179 @@
+/* global window */
+import CompositeClosureHelper from "../CompositeClosureHelper";
+
+import ProcessLauncher from "../ProcessLauncher";
+import WebsocketConnection from "../WebsocketConnection";
+
+function DEFAULT_CONFIG_DECORATOR(config) {
+  if (config.sessionURL) {
+    config.sessionURL = config.sessionURL.replaceAll(
+      "USE_HOSTNAME",
+      window.location.hostname
+    );
+    config.sessionURL = config.sessionURL.replaceAll(
+      "USE_HOST",
+      window.location.host
+    );
+  }
+  return config;
+}
+
+function extractPathName(addOn, pathName = window.location.pathname) {
+  if (pathName.endsWith(".html") || pathName.endsWith(".htm")) {
+    const tokens = pathName.split("/");
+    tokens.pop();
+    pathName = tokens.join("/");
+  }
+  while (pathName.length > 0 && pathName[pathName.length - 1] === "/") {
+    pathName = pathName.substring(0, pathName.length - 1);
+  }
+  if (pathName.length === 0) {
+    return addOn;
+  }
+  return `${pathName}${addOn}`;
+}
+
+export const DEFAULT_SESSION_MANAGER_URL = `${document.baseURI}paraview/`;
+
+export const DEFAULT_SESSION_URL = `${
+  window.location.protocol === "https:" ? "wss:" : "ws:"
+}//${window.location.hostname}:${window.location.port}${extractPathName(
+  "/ws"
+)}`;
+
+function wsConnect(publicAPI, model) {
+  const wsConnection = WebsocketConnection.newInstance({
+    urls: model.config.sessionURL,
+    secret: model.config.secret,
+    retry: model.config.retry,
+    wsProxy: model.config.iframe || model.config.wsProxy,
+  });
+  model.subscriptions.push(
+    wsConnection.onConnectionReady(publicAPI.readyForwarder)
+  );
+  model.subscriptions.push(
+    wsConnection.onConnectionError(publicAPI.errorForwarder)
+  );
+  model.subscriptions.push(
+    wsConnection.onConnectionClose(publicAPI.closeForwarder)
+  );
+
+  // Add to the garbage collector
+  model.gc.push(wsConnection);
+
+  return wsConnection.connect();
+}
+
+function smartConnect(publicAPI, model) {
+  let session = null;
+  model.gc = [];
+
+  // Event forwarders
+  publicAPI.readyForwarder = (data) => {
+    session = data.getSession();
+    publicAPI.fireConnectionReady(data);
+  };
+  publicAPI.errorForwarder = (data, err) => {
+    publicAPI.fireConnectionError(data, err);
+  };
+  publicAPI.closeForwarder = (data, err) => {
+    publicAPI.fireConnectionClose(data, err);
+  };
+
+  publicAPI.connect = () => {
+    if (model.configDecorator) {
+      model.config = model.configDecorator(model.config);
+    }
+    model.config = DEFAULT_CONFIG_DECORATOR(model.config);
+
+    if (model.config.sessionURL) {
+      // We have a direct connection URL
+      session = wsConnect(publicAPI, model);
+    } else if (model.config.wsProxy) {
+      // Provide fake url if missing since we rely on a proxy
+      model.config.sessionURL = model.config.sessionURL || "wss://proxy/";
+      session = wsConnect(publicAPI, model);
+    } else {
+      // We need to use the Launcher
+      const launcher = ProcessLauncher.newInstance({
+        endPoint: model.config.sessionManagerURL || DEFAULT_SESSION_MANAGER_URL,
+      });
+
+      model.subscriptions.push(
+        launcher.onProcessReady((data) => {
+          if (model.configDecorator) {
+            model.config = model.configDecorator(
+              Object.assign({}, model.config, data)
+            );
+          } else {
+            model.config = Object.assign({}, model.config, data);
+          }
+          model.config = DEFAULT_CONFIG_DECORATOR(model.config);
+
+          session = wsConnect(publicAPI, model);
+        })
+      );
+      model.subscriptions.push(
+        launcher.onError((data) => {
+          if (data && data.response && data.response.error) {
+            publicAPI.errorForwarder(data, data.response.error);
+          } else {
+            // Try to use standard connection URL
+            model.config.sessionURL = DEFAULT_SESSION_URL;
+            model.config = DEFAULT_CONFIG_DECORATOR(model.config);
+            session = wsConnect(publicAPI, model);
+          }
+        })
+      );
+
+      launcher.start(model.config);
+
+      // Add to the garbage collector
+      model.gc.push(launcher);
+    }
+  };
+
+  publicAPI.getSession = () => {
+    return session;
+  };
+
+  function cleanUp(timeout) {
+    if (session) {
+      if (timeout > 0) {
+        session.call("application.exit.later", [timeout]);
+      }
+      session.close();
+    }
+    session = null;
+
+    while (model.gc.length) {
+      model.gc.pop().destroy();
+    }
+  }
+
+  publicAPI.destroy = CompositeClosureHelper.chain(cleanUp, publicAPI.destroy);
+}
+
+const DEFAULT_VALUES = {
+  config: {},
+  // configDecorator: null,
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  CompositeClosureHelper.destroy(publicAPI, model);
+  CompositeClosureHelper.event(publicAPI, model, "ConnectionReady");
+  CompositeClosureHelper.event(publicAPI, model, "ConnectionClose");
+  CompositeClosureHelper.event(publicAPI, model, "ConnectionError");
+  CompositeClosureHelper.isA(publicAPI, model, "SmartConnect");
+  CompositeClosureHelper.get(publicAPI, model, ["config", "configDecorator"]);
+  CompositeClosureHelper.set(publicAPI, model, ["configDecorator"]);
+
+  smartConnect(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+export const newInstance = CompositeClosureHelper.newInstance(extend);
+
+export default { newInstance, extend };

package/src/WebsocketConnection/api.md

@@ -0,0 +1,37 @@
+# WebsocketConnection
+
+## WebsocketConnection.newInstance({ urls })
+
+Create an instance of a websocket connection. The urls should be a single url
+(string).
+
+Usually with a ProcessLauncher we will set the **urls** to
+**connection.sessionURL**.
+
+The input can optionally include a string to authenticate the connection during
+the handshake: `{ urls, secret:"wslink-secret" }`
+
+## connect()
+
+Trigger the actual connection request with the server.
+
+## onConnectionReady(callback) : subscription
+
+Register callback for when the connection became ready.
+
+## onConnectionClose(callback) : subscription
+
+Register callback for when the connection close.
+
+## getSession() : object
+
+Return null if the connection is not yet established or the session for making
+RPC calls.
+
+## destroy(timeout=10)
+
+Close the connection and ask the server to automatically shutdown after the
+given timeout while removing any listener.
+
+If the provided timeout is negative, we will close the connection without asking
+the server to shutdown.

package/src/WebsocketConnection/chunking.js

@@ -0,0 +1,211 @@
+// Project not setup for typescript, manually compiling this file to chunker.js
+// npx tsc chunking.ts --target esnext
+const UINT32_LENGTH = 4;
+const ID_LOCATION = 0;
+const ID_LENGTH = UINT32_LENGTH;
+const MESSAGE_OFFSET_LOCATION = ID_LOCATION + ID_LENGTH;
+const MESSAGE_OFFSET_LENGTH = UINT32_LENGTH;
+const MESSAGE_SIZE_LOCATION = MESSAGE_OFFSET_LOCATION + MESSAGE_OFFSET_LENGTH;
+const MESSAGE_SIZE_LENGTH = UINT32_LENGTH;
+const HEADER_LENGTH = ID_LENGTH + MESSAGE_OFFSET_LENGTH + MESSAGE_SIZE_LENGTH;
+function encodeHeader(id, offset, size) {
+  const buffer = new ArrayBuffer(HEADER_LENGTH);
+  const header = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  view.setUint32(ID_LOCATION, id, true);
+  view.setUint32(MESSAGE_OFFSET_LOCATION, offset, true);
+  view.setUint32(MESSAGE_SIZE_LOCATION, size, true);
+  return header;
+}
+function decodeHeader(header) {
+  const view = new DataView(header.buffer);
+  const id = view.getUint32(ID_LOCATION, true);
+  const offset = view.getUint32(MESSAGE_OFFSET_LOCATION, true);
+  const size = view.getUint32(MESSAGE_SIZE_LOCATION, true);
+  return { id, offset, size };
+}
+function* generateChunks(message, maxSize) {
+  const totalSize = message.byteLength;
+  let maxContentSize;
+  if (maxSize === 0) {
+    maxContentSize = totalSize;
+  } else {
+    maxContentSize = Math.max(maxSize - HEADER_LENGTH, 1);
+  }
+  const id = new Uint32Array(1);
+  crypto.getRandomValues(id);
+  let offset = 0;
+  while (offset < totalSize) {
+    const contentSize = Math.min(maxContentSize, totalSize - offset);
+    const chunk = new Uint8Array(new ArrayBuffer(HEADER_LENGTH + contentSize));
+    const header = encodeHeader(id[0], offset, totalSize);
+    chunk.set(new Uint8Array(header.buffer), 0);
+    chunk.set(message.subarray(offset, offset + contentSize), HEADER_LENGTH);
+    yield chunk;
+    offset += contentSize;
+  }
+  return;
+}
+/*
+  This un-chunker is vulnerable to DOS.
+  If it receives a message with a header claiming a large incoming message
+  it will allocate the memory blindly even without actually receiving the content
+  Chunks for a given message can come in any order
+  Chunks across messages can be interleaved.
+*/
+class UnChunker {
+  pendingMessages;
+  constructor() {
+    this.pendingMessages = {};
+  }
+  releasePendingMessages() {
+    this.pendingMessages = {};
+  }
+  async processChunk(chunk, decoderFactory) {
+    const headerBlob = chunk.slice(0, HEADER_LENGTH);
+    const contentBlob = chunk.slice(HEADER_LENGTH);
+    const header = new Uint8Array(await headerBlob.arrayBuffer());
+    const { id, offset, size: totalSize } = decodeHeader(header);
+    let pendingMessage = this.pendingMessages[id];
+    if (!pendingMessage) {
+      pendingMessage = {
+        receivedSize: 0,
+        content: new Uint8Array(totalSize),
+        decoder: decoderFactory(),
+      };
+      this.pendingMessages[id] = pendingMessage;
+    }
+    // This should never happen, but still check it
+    if (totalSize !== pendingMessage.content.byteLength) {
+      delete this.pendingMessages[id];
+      throw new Error(
+        `Total size in chunk header for message ${id} does not match total size declared by previous chunk.`
+      );
+    }
+    const chunkContent = new Uint8Array(await contentBlob.arrayBuffer());
+    const content = pendingMessage.content;
+    content.set(chunkContent, offset);
+    pendingMessage.receivedSize += chunkContent.byteLength;
+    if (pendingMessage.receivedSize >= totalSize) {
+      delete this.pendingMessages[id];
+      try {
+        return pendingMessage["decoder"].decode(content);
+      } catch (e) {
+        console.error("Malformed message: ", content.slice(0, 100));
+        // debugger;
+      }
+    }
+    return undefined;
+  }
+}
+// Makes sure messages are processed in order of arrival,
+export class SequentialTaskQueue {
+  taskId;
+  pendingTaskId;
+  tasks;
+  constructor() {
+    this.taskId = 0;
+    this.pendingTaskId = -1;
+    this.tasks = {};
+  }
+  enqueue(fn, ...args) {
+    return new Promise((resolve, reject) => {
+      const taskId = this.taskId++;
+      this.tasks[taskId] = { fn, args, resolve, reject };
+      this._maybeExecuteNext();
+    });
+  }
+  _maybeExecuteNext() {
+    let pendingTask = this.tasks[this.pendingTaskId];
+    if (pendingTask) {
+      return;
+    }
+    const nextPendingTaskId = this.pendingTaskId + 1;
+    pendingTask = this.tasks[nextPendingTaskId];
+    if (!pendingTask) {
+      return;
+    }
+    this.pendingTaskId = nextPendingTaskId;
+    const { fn, args, resolve, reject } = pendingTask;
+    fn(...args)
+      .then((result) => {
+        resolve(result);
+        delete this.tasks[nextPendingTaskId];
+        this._maybeExecuteNext();
+      })
+      .catch((err) => {
+        reject(err);
+        delete this.tasks[nextPendingTaskId];
+        this._maybeExecuteNext();
+      });
+  }
+}
+/*
+  This un-chunker is more memory efficient
+  (each chunk is passed immediately to msgpack)
+  and it will only allocate memory when it receives content.
+  Chunks for a given message are expected to come sequentially
+  Chunks across messages can be interleaved.
+*/
+class StreamUnChunker {
+  pendingMessages;
+  constructor() {
+    this.pendingMessages = {};
+  }
+  processChunk = async (chunk, decoderFactory) => {
+    const headerBlob = chunk.slice(0, HEADER_LENGTH);
+    const header = new Uint8Array(await headerBlob.arrayBuffer());
+    const { id, offset, size: totalSize } = decodeHeader(header);
+    const contentBlob = chunk.slice(HEADER_LENGTH);
+    let pendingMessage = this.pendingMessages[id];
+    if (!pendingMessage) {
+      pendingMessage = {
+        receivedSize: 0,
+        totalSize: totalSize,
+        decoder: decoderFactory(),
+      };
+      this.pendingMessages[id] = pendingMessage;
+    }
+    // This should never happen, but still check it
+    if (totalSize !== pendingMessage.totalSize) {
+      delete this.pendingMessages[id];
+      throw new Error(
+        `Total size in chunk header for message ${id} does not match total size declared by previous chunk.`
+      );
+    }
+    // This should never happen, but still check it
+    if (offset !== pendingMessage.receivedSize) {
+      delete this.pendingMessages[id];
+      throw new Error(`Received an unexpected chunk for message ${id}.
+           Expected offset = ${pendingMessage.receivedSize},
+           Received offset = ${offset}.`);
+    }
+    let result;
+    try {
+      result = await pendingMessage.decoder.decodeAsync(contentBlob.stream());
+    } catch (e) {
+      if (e instanceof RangeError) {
+        // More data is needed, it should come in the next chunk
+        result = undefined;
+      }
+    }
+    pendingMessage.receivedSize += contentBlob.size;
+    /*
+          In principle feeding a stream to the unpacker could yield multiple outputs
+          for example unpacker.feed(b'0123') would yield b'0', b'1', etc
+          or concatenated packed payloads would yield two or more unpacked objects
+          but in our use case we expect a full message to be mapped to a single object
+        */
+    if (result && pendingMessage.receivedSize < totalSize) {
+      delete this.pendingMessages[id];
+      throw new Error(`Received a parsable payload shorter than expected for message ${id}.
+           Expected size = ${totalSize},
+           Received size = ${pendingMessage.receivedSize}.`);
+    }
+    if (pendingMessage.receivedSize >= totalSize) {
+      delete this.pendingMessages[id];
+    }
+    return result;
+  };
+}
+export { UnChunker, StreamUnChunker, generateChunks };