@ibm-aspera/sdk 0.2.12 → 0.2.29

package/src/helpers/helpers.ts

@@ -0,0 +1,253 @@
+import {baseInstallerUrl, installerUrl} from '../constants/constants';
+import {ErrorResponse, InstallerUrlInfo, PromiseObject, TransferSpec} from '../models/models';
+
+/**
+ * Generates promise object that can be resolved or rejected via functions
+ *
+ * @returns an object containing the promise, the resolver and rejecter
+ */
+export const generatePromiseObjects = (): PromiseObject => {
+  let resolver: (response: any) => void;
+  let rejecter: (response: any) => void;
+  const promise = new Promise((resolve, reject) => {
+    resolver = resolve;
+    rejecter = reject;
+  });
+  return {
+    promise,
+    resolver,
+    rejecter
+  };
+};
+
+/**
+ * Log errors from Aspera SDK
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ */
+export const errorLog = (message: string, debugData?: any): void => {
+  if (debugData && debugData.code && debugData.message) {
+    debugData = {
+      code: debugData.code,
+      message: debugData.message,
+      data: debugData.data
+    };
+  }
+
+  if (typeof (<any>window) === 'object') {
+    if (!Array.isArray((<any>window).asperaSdkLogs)) {
+      (<any>window).asperaSdkLogs = [];
+    }
+    (<any>window).asperaSdkLogs.push({message, debugData});
+  }
+
+  console.warn(`Aspera SDK: ${message}`, debugData);
+};
+
+/**
+ * Generate error object for rejecter responses
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ *
+ * @returns object containing standardized error response
+ */
+export const generateErrorBody = (message: string, debugData?: any): ErrorResponse => {
+  const errorResponse: ErrorResponse = {
+    error: true,
+    message
+  };
+
+  if (debugData && debugData.code && debugData.message) {
+    errorResponse.debugData = {
+      code: debugData.code,
+      message: debugData.message,
+      data: debugData.data
+    };
+  }
+
+  return errorResponse;
+};
+
+/**
+ * Validate if transferSpec is valid for server communication
+ *
+ * @param transferSpec the transferSpec to test
+ *
+ * @returns boolean indicating whether supplied transferSpec is valid
+ */
+export const isValidTransferSpec = (transferSpec: TransferSpec): boolean => {
+  if (
+    transferSpec &&
+    typeof transferSpec === 'object' &&
+    typeof transferSpec.direction === 'string' &&
+    typeof transferSpec.remote_host === 'string' &&
+    Array.isArray(transferSpec.paths)
+  ) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+ * Returns a string indicating the websocket URL to use for talking to the server
+ *
+ * @returns a string of the full Websocket URL
+ */
+export const getWebsocketUrl = (serverUrl: string): string => {
+  let wsProtocol;
+  if (serverUrl.indexOf('http:') === 0) {
+    wsProtocol = 'ws';
+  } else if (serverUrl.indexOf('https:') === 0) {
+    wsProtocol = 'wss';
+  }
+  const url = serverUrl.replace('http://', '//').replace('https://', '//');
+
+  return `${wsProtocol}:${url}`;
+};
+
+/**
+ * Simple function to get the current platform.
+ *
+ * @returns a string indicating the current platform
+ */
+export const getCurrentPlatform = (): 'macos'|'windows'|'linux'|'unknown' => {
+  const ua = navigator.userAgent;
+
+  if (/Mac/.test(ua)) {
+    return 'macos';
+  } else if (/Win/.test(ua)) {
+    return 'windows';
+  } else if (/Linux/.test(ua)) {
+    return 'linux';
+  } else {
+    return 'unknown';
+  }
+};
+
+/**
+ * Function used to create a random UUID
+ *
+ * @returns string
+ */
+export const randomUUID = (): string => {
+  const fallback = (): string => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      let r = Number(((new Date().getTime() + 16) * Math.random()).toFixed()) % 16;
+      if (c !== 'x') {
+        // eslint-disable-next-line no-bitwise
+        r = r & 0x3 | 0x8;
+      }
+      return r.toString(16);
+    });
+  };
+
+  return window.crypto?.randomUUID ? window.crypto.randomUUID() : fallback();
+};
+
+/**
+ * Return a rejected promise
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ *
+ * @returns a rejected promise
+ */
+export const throwError = (message: string, debugData?: any): Promise<any> => {
+  errorLog(message, debugData);
+  return new Promise((resolve, reject) => {
+    reject(generateErrorBody(message, debugData));
+  });
+};
+
+/**
+ * Check if the given string is a valid URL
+ *
+ * @param url string to check if valid URL
+ *
+ * @returns boolean
+ */
+export const isValidURL = (url: string): boolean => {
+  try {
+    new URL(url);
+    return true;
+  } catch(error) {
+    return false;
+  }
+};
+
+/**
+ * Checks if the current browser is Safari.
+ * @returns {boolean} Whether the browser is Safari.
+ */
+export const isSafari = (): boolean => {
+  return /^((?!chrome|android).)*safari/i.test(navigator.userAgent) && !(window as any).MSStream;
+};
+
+/**
+ * Get the URLs for installer management.
+ *
+ * @returns Info on URLs where installers live
+ */
+export const getInstallerUrls = (): InstallerUrlInfo => {
+  return {
+    base: baseInstallerUrl,
+    latest: installerUrl,
+  };
+};
+
+/**
+ * Try to stringify a JSON string and log failures
+ *
+ * @param json - Object to make into a string
+ *
+ * @returns string representing JSON or empty string on error
+ */
+export const safeJsonString = (json: unknown): string => {
+  try {
+    return JSON.stringify(json);
+  } catch (error) {
+    errorLog('safeJsonString: unable to stringify JSON', {error, json});
+
+    return '';
+  }
+};
+
+/**
+ * Try to parse a JSON string and log failures
+ *
+ * @param json - String to make into an object
+ *
+ * @returns object or array from the JSON string. Or undefined
+ */
+export const safeJsonParse = (json: string): any|undefined => {
+  if (json && typeof json === 'object') {
+    return json;
+  }
+
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    errorLog('safeJsonParse: unable to parse JSON', {error, json});
+
+    return undefined;
+  }
+};
+
+export default {
+  errorLog,
+  generateErrorBody,
+  generatePromiseObjects,
+  getCurrentPlatform,
+  getWebsocketUrl,
+  isSafari,
+  isValidURL,
+  isValidTransferSpec,
+  randomUUID,
+  throwError,
+  getInstallerUrls,
+  safeJsonString,
+  safeJsonParse,
+};

package/src/helpers/http.ts

@@ -0,0 +1,39 @@
+import {generatePromiseObjects} from './helpers';
+
+/**
+ * Check HTTP promise response for server error response (non 2XX status) and reject promise is error
+ *
+ * @param promise the HTTP promise to check for HTTP status code of 2XX for success
+ *
+ * @returns promise for the HTTP connection with catch supporting error
+ */
+export const handlePromiseErrors = (promise: Promise<any>): Promise<any> => {
+  const promiseInfo = generatePromiseObjects();
+  promise.then(response => {
+    if (response.ok) {
+      promiseInfo.resolver(response);
+    } else {
+      promiseInfo.rejecter(response);
+    }
+    return response;
+  }).catch(error => {
+    promiseInfo.rejecter(error);
+  });
+  return promiseInfo.promise;
+};
+
+
+/**
+ * Make a GET for retrieving data from a server
+ *
+ * @param url the url string of the resource on the server
+ *
+ * @returns a promise that will resolve with the response from the server or reject if network/server error
+ */
+export const apiGet = (url: string): Promise<any> => {
+  return handlePromiseErrors(fetch(url, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  }));
+};

package/src/helpers/ws.ts

@@ -0,0 +1,191 @@
+import {errorLog, generatePromiseObjects, getWebsocketUrl, safeJsonParse, safeJsonString} from './helpers';
+import {messages} from '../constants/messages';
+import {asperaSdk} from '../index';
+import {TransferResponse} from '../models/aspera-sdk.model';
+import {WebsocketEvent, WebsocketMessage, WebsocketTopics} from '../models/models';
+
+export class WebsocketService {
+  /** The main websocket connection to Aspera App*/
+  private globalSocket: WebSocket;
+  /** A map of requested subscription names and the callback for them */
+  private sockets: Map<WebsocketTopics, Function> = new Map();
+  /** The callback for websocket events */
+  private eventListener: Function;
+  /** Indicator if the websocket is already connected */
+  private isConnected = false;
+  /** Global promise object that resolves when init completes */
+  private initPromise = generatePromiseObjects();
+
+  /** Log call for not being ready */
+  private handleNotReady(): void {
+    errorLog(messages.websocketNotReady);
+  }
+
+  /**
+   * This function handles when a connection is opened
+   */
+  private handleOpen = (): void => {
+    if (this.isConnected || !this.joinChannel()) {
+      return;
+    }
+
+    this.isConnected = true;
+    this.updateRpcPort();
+    this.notifyEvent('RECONNECT');
+  };
+
+  /**
+   * This function handles completed subscription
+   */
+  private handleClose = (): void => {
+    if (this.isConnected) {
+      this.isConnected = false;
+      this.notifyEvent('CLOSED');
+    }
+
+    if (!this.globalSocket) {
+      this.handleNotReady();
+      return;
+    }
+
+    this.reconnect();
+  };
+
+  /**
+   * This function handles errors received from the websocket
+   */
+  private handleError = (): void => {
+    errorLog(messages.websocketClosedError);
+  };
+
+  /**
+   * This function handles messages received from the websocket
+   */
+  private handleMessage = (message: MessageEvent<string>): void => {
+    const data: WebsocketMessage|undefined = safeJsonParse(message.data);
+
+    // Message we get on subscription
+    if (data && data.id === 1) {
+      this.initPromise.resolver(data);
+
+      return;
+    }
+
+    const socket = this.sockets.get(data.method);
+
+    if (typeof socket === 'function' && data.params) {
+      socket(data.params);
+    }
+  };
+
+  /**
+   * This function joins the channel to be able to subscribe to events
+   */
+  private joinChannel(): boolean {
+    if (!this.globalSocket) {
+      this.handleNotReady();
+      return false;
+    }
+
+    this.globalSocket.send(safeJsonString({jsonrpc: '2.0', method: 'subscribe_transfer_activity', params: [asperaSdk.globals.appId], id: 1}));
+
+    return true;
+  }
+
+  /**
+   * This function registers clients to listen to a certain message name. Returns any to allow functions to declare proper type
+   *
+   * @param messageName - the name of messages to listen to (one message name per subscription)
+   * @param callback - the callback function
+   */
+  registerMessage(messageName: WebsocketTopics, callback: Function): void {
+    if (!this.sockets.get(messageName)) {
+      this.sockets.set(messageName, (data: {result: TransferResponse}) => {
+        callback(data.result);
+      });
+    }
+  }
+
+  /**
+   *
+   * @param callback This function registers clients to a certain WebSocket event.
+   *
+   * @param callback - the callback function to call with the event name.
+   */
+  registerEvent(callback: Function): void {
+    this.eventListener = callback;
+    this.eventListener(this.isConnected ? 'RECONNECT': 'CLOSED');
+  }
+
+  /**
+   * This function starts the websocket subscription with the websocket provider
+   *
+   * @returns a promise that resolves when the websocket connection is established
+   */
+  init(): Promise<unknown> {
+    this.connect();
+
+    return this.initPromise.promise;
+  }
+
+  private connect() {
+    this.getWebSocketConnection(asperaSdk.globals.rpcPort)
+      .then((webSocket) => {
+        this.globalSocket = webSocket;
+        this.globalSocket.onerror = this.handleError;
+        this.globalSocket.onclose = this.handleClose;
+        this.globalSocket.onopen = this.handleOpen;
+        this.globalSocket.onmessage = this.handleMessage;
+
+        this.handleOpen();
+      }).catch(() => {
+        this.reconnect();
+      });
+  }
+
+  private reconnect() {
+    if (this.globalSocket) {
+      this.globalSocket.close();
+    }
+
+    setTimeout(() => {
+      this.connect();
+    }, 1000);
+  }
+
+  private getWebSocketConnection(port: number): Promise<WebSocket> {
+    const webSocketUrl = getWebsocketUrl(asperaSdk.globals.asperaAppUrl);
+
+    return new Promise((resolve, reject) => {
+      const webSocket = new WebSocket(`${webSocketUrl}:${port}`);
+
+      webSocket.onopen = () => {
+        resolve(webSocket);
+      };
+
+      webSocket.onerror = () => {
+        reject(`Connection failed on port ${port}`);
+      };
+    });
+  }
+
+  private notifyEvent(event: WebsocketEvent) {
+    if (typeof this.eventListener === 'function') {
+      this.eventListener(event);
+    }
+  }
+
+  private updateRpcPort() {
+    if (!this.globalSocket) {
+      return;
+    }
+
+    const url = new URL(this.globalSocket.url);
+
+    asperaSdk.globals.rpcPort = Number(url.port);
+  }
+}
+
+export const websocketService = new WebsocketService();
+
+export default WebsocketService;