@webex/plugin-meetings 2.60.0 → 2.60.1-next.1

package/src/reachability/index.ts

@@ -3,25 +3,70 @@
  */
 
 /* eslint-disable class-methods-use-this */
-/* globals window */
-import _ from 'lodash';
+import {mapValues} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY} from '../constants';
+import MeetingUtil from '../meeting/util';
+
+import {REACHABILITY} from '../constants';
+
+import ReachabilityRequest, {ClusterList} from './request';
+import {
+  ClusterReachability,
+  ClusterReachabilityResult,
+  TransportResult,
+} from './clusterReachability';
+
+export type ReachabilityMetrics = {
+  reachability_public_udp_success: number;
+  reachability_public_udp_failed: number;
+  reachability_public_tcp_success: number;
+  reachability_public_tcp_failed: number;
+  reachability_vmn_udp_success: number;
+  reachability_vmn_udp_failed: number;
+  reachability_vmn_tcp_success: number;
+  reachability_vmn_tcp_failed: number;
+};
 
-import ReachabilityRequest from './request';
-
-const DEFAULT_TIMEOUT = 3000;
-const VIDEO_MESH_TIMEOUT = 1000;
+/**
+ * This is the type that matches what backend expects us to send to them. It is a bit weird, because
+ * it uses strings instead of booleans and numbers, but that's what they require.
+ */
+export type TransportResultForBackend = {
+  reachable?: 'true' | 'false';
+  latencyInMilliseconds?: string;
+  clientMediaIPs?: string[];
+  untested?: 'true';
+};
+
+export type ReachabilityResultForBackend = {
+  udp: TransportResultForBackend;
+  tcp: TransportResultForBackend;
+  xtls: TransportResultForBackend;
+};
+
+// this is the type that is required by the backend when we send them reachability results
+export type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;
+
+// this is the type used by Reachability class internally and stored in local storage
+export type ReachabilityResults = Record<
+  string,
+  ClusterReachabilityResult & {
+    isVideoMesh?: boolean;
+  }
+>;
 
 /**
  * @class Reachability
  * @export
  */
 export default class Reachability {
+  namespace = REACHABILITY.namespace;
   webex: object;
-  reachabilityRequest: any;
-  clusterLatencyResults: any;
+  reachabilityRequest: ReachabilityRequest;
+  clusterReachability: {
+    [key: string]: ClusterReachability;
+  };
 
   /**
    * Creates an instance of Reachability.
@@ -40,187 +85,209 @@ export default class Reachability {
      */
     this.reachabilityRequest = new ReachabilityRequest(this.webex);
 
-    /**
-     * internal object of clusters latency results
-     * @instance
-     * @type {object}
-     * @private
-     * @memberof Reachability
-     */
-    this.clusterLatencyResults = {};
+    this.clusterReachability = {};
   }
 
   /**
-   * fetches reachability data
-   * @returns {Object} reachability data
+   * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
+   * @returns {Promise<ReachabilityResults>} reachability results
    * @public
-   * @async
    * @memberof Reachability
    */
-  public async gatherReachability() {
-    this.setup();
-
+  public async gatherReachability(): Promise<ReachabilityResults> {
     // Remove stored reachability results to ensure no stale data
-    if (window?.localStorage?.removeItem) {
-      window.localStorage.removeItem(REACHABILITY.localStorage);
-    } else {
-      LoggerProxy.logger.error(
-        'Reachability:index#gatherReachability --> Error in accessing LocalStorage.'
-      );
-
-      return {};
-    }
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
 
     // Fetch clusters and measure latency
     try {
-      const clusters = await this.reachabilityRequest.getClusters();
+      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters(
+        MeetingUtil.getIpVersion(this.webex)
+      );
 
       // Perform Reachability Check
-      const results = await this.performReachabilityCheck(clusters);
+      const results = await this.performReachabilityChecks(clusters);
 
-      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
+      // @ts-ignore
+      await this.webex.boundedStorage.put(
+        this.namespace,
+        REACHABILITY.localStorageResult,
+        JSON.stringify(results)
+      );
+      // @ts-ignore
+      await this.webex.boundedStorage.put(
+        this.namespace,
+        REACHABILITY.localStorageJoinCookie,
+        JSON.stringify(joinCookie)
+      );
 
       LoggerProxy.logger.log(
         'Reachability:index#gatherReachability --> Reachability checks completed'
       );
 
       return results;
-    } catch (getClusterError) {
-      LoggerProxy.logger.error(
-        `Reachability:index#gatherReachability --> Error in calling getClusters(): ${getClusterError}`
-      );
+    } catch (error) {
+      LoggerProxy.logger.error(`Reachability:index#gatherReachability --> Error:`, error);
 
       return {};
     }
   }
 
   /**
-   * fetches reachability data and checks for cluster reachability
-   * @returns {boolean}
-   * @public
-   * @memberof Reachability
+   * Returns statistics about last reachability results. The returned value is an object
+   * with a flat list of properties so that it can be easily sent with metrics
+   *
+   * @returns {Promise} Promise with metrics values, it never rejects/throws.
    */
-  isAnyClusterReachable() {
-    let reachable = false;
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
-
-    if (reachabilityData) {
-      try {
-        const reachabilityResults = JSON.parse(reachabilityData);
+  async getReachabilityMetrics(): Promise<ReachabilityMetrics> {
+    const stats: ReachabilityMetrics = {
+      reachability_public_udp_success: 0,
+      reachability_public_udp_failed: 0,
+      reachability_public_tcp_success: 0,
+      reachability_public_tcp_failed: 0,
+      reachability_vmn_udp_success: 0,
+      reachability_vmn_udp_failed: 0,
+      reachability_vmn_tcp_success: 0,
+      reachability_vmn_tcp_failed: 0,
+    };
 
-        reachable = Object.values(reachabilityResults).some(
-          (result: any) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true'
-        );
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
-        );
+    const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
+      if (result.udp && result.udp.result !== 'untested') {
+        const outcome = result.udp.result === 'reachable' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_udp_${outcome}`] += 1;
       }
+      if (result.tcp && result.tcp.result !== 'untested') {
+        const outcome = result.tcp.result === 'reachable' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_tcp_${outcome}`] += 1;
+      }
+    };
+
+    try {
+      // @ts-ignore
+      const resultsJson = await this.webex.boundedStorage.get(
+        REACHABILITY.namespace,
+        REACHABILITY.localStorageResult
+      );
+
+      const results: ReachabilityResults = JSON.parse(resultsJson);
+
+      Object.values(results).forEach((result) => {
+        updateStats(result.isVideoMesh ? 'vmn' : 'public', result);
+      });
+    } catch (e) {
+      // empty storage, that's ok
+      LoggerProxy.logger.warn(
+        'Roap:request#getReachabilityMetrics --> Error parsing reachability data: ',
+        e
+      );
     }
 
-    return reachable;
+    return stats;
   }
 
   /**
-   * Generate peerConnection config settings
-   * @param {object} cluster
-   * @returns {object} peerConnectionConfig
-   * @private
-   * @memberof Reachability
+   * Maps our internal transport result to the format that backend expects
+   * @param {TransportResult} transportResult
+   * @returns {TransportResultForBackend}
    */
-  private buildPeerConnectionConfig(cluster: any) {
-    const iceServers = _.uniq([...cluster.udp, ...cluster.tcp]).map((url) => ({
-      username: '',
-      credential: '',
-      urls: [url],
-    }));
-
-    return {
-      iceServers: [...iceServers],
-      iceCandidatePoolSize: '0',
-      iceTransportPolicy: 'all',
-    };
+  private mapTransportResultToBackendDataFormat(
+    transportResult: TransportResult
+  ): TransportResultForBackend {
+    const output: TransportResultForBackend = {};
+
+    for (const [key, value] of Object.entries(transportResult)) {
+      switch (key) {
+        case 'result':
+          switch (value) {
+            case 'reachable':
+              output.reachable = 'true';
+              break;
+            case 'unreachable':
+              output.reachable = 'false';
+              break;
+            case 'untested':
+              output.untested = 'true';
+              break;
+          }
+          break;
+        case 'latencyInMilliseconds':
+          output.latencyInMilliseconds = value.toString();
+          break;
+        default:
+          output[key] = value;
+      }
+    }
+
+    return output;
   }
 
   /**
-   * Creates an RTCPeerConnection
-   * @param {object} cluster
-   * @returns {RTCPeerConnection} peerConnection
-   * @private
-   * @memberof Reachability
+   * Reachability results as an object in the format that backend expects
+   *
+   * @returns {any} reachability results that need to be sent to the backend
    */
-  private createPeerConnection(cluster: any) {
-    const {key, config} = cluster;
+  async getReachabilityResults(): Promise<ReachabilityResultsForBackend | undefined> {
+    let results: ReachabilityResultsForBackend;
 
     try {
-      const peerConnection = new window.RTCPeerConnection(config);
-
       // @ts-ignore
-      peerConnection.key = key;
-
-      return peerConnection;
-    } catch (peerConnectionError) {
-      LoggerProxy.logger.log(
-        `Reachability:index#createPeerConnection --> Error creating peerConnection: ${peerConnectionError}`
+      const resultsJson = await this.webex.boundedStorage.get(
+        REACHABILITY.namespace,
+        REACHABILITY.localStorageResult
       );
 
-      return null;
+      const allClusterResults: ReachabilityResults = JSON.parse(resultsJson);
+
+      results = mapValues(allClusterResults, (clusterResult) => ({
+        udp: this.mapTransportResultToBackendDataFormat(clusterResult.udp || {result: 'untested'}),
+        tcp: this.mapTransportResultToBackendDataFormat(clusterResult.tcp || {result: 'untested'}),
+        xtls: this.mapTransportResultToBackendDataFormat(
+          clusterResult.xtls || {result: 'untested'}
+        ),
+      }));
+    } catch (e) {
+      // empty storage, that's ok
+      LoggerProxy.logger.warn(
+        'Roap:request#attachReachabilityData --> Error parsing reachability data: ',
+        e
+      );
     }
-  }
-
-  /**
-   * Gets total elapsed time
-   * @param {RTCPeerConnection} peerConnection
-   * @returns {Number} Milliseconds
-   * @private
-   * @memberof Reachability
-   */
-  private getElapsedTime(peerConnection: any) {
-    const startTime = peerConnection.begin;
-
-    delete peerConnection.begin;
 
-    return Date.now() - startTime;
+    return results;
   }
 
   /**
-   * creates offer and generates localSDP
-   * @param {object} clusterList cluster List
-   * @returns {Promise} Reachability latency results
-   * @private
+   * fetches reachability data and checks for cluster reachability
+   * @returns {boolean}
+   * @public
    * @memberof Reachability
    */
-  private getLocalSDPForClusters(clusterList: object) {
-    let clusters: any[] = [...Object.keys(clusterList)];
+  async isAnyPublicClusterReachable() {
+    let reachable = false;
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
 
-    clusters = clusters.map(async (key) => {
-      const cluster = clusterList[key];
-      const config = this.buildPeerConnectionConfig(cluster);
-      const peerConnection = this.createPeerConnection({key, config});
-      const description = await peerConnection.createOffer({offerToReceiveAudio: true});
+    if (reachabilityData) {
+      try {
+        const reachabilityResults: ReachabilityResults = JSON.parse(reachabilityData);
 
-      // @ts-ignore
-      peerConnection.begin = Date.now();
-      peerConnection.setLocalDescription(description);
-
-      return this.iceGatheringState(
-        peerConnection,
-        cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT
-      ).catch((iceGatheringStateError) => {
-        LoggerProxy.logger.log(
-          `Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ${iceGatheringStateError}`
+        reachable = Object.values(reachabilityResults).some(
+          (result) =>
+            !result.isVideoMesh &&
+            (result.udp?.result === 'reachable' || result.tcp?.result === 'reachable')
         );
-      });
-    });
-
-    return Promise.all(clusters)
-      .then(this.parseIceResultsToReachabilityResults)
-      .then((reachabilityLatencyResults) => {
-        this.logUnreachableClusters();
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+        );
+      }
+    }
 
-        // return results
-        return reachabilityLatencyResults;
-      });
+    return reachable;
   }
 
   /**
@@ -229,126 +296,23 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  private getUnreachablClusters() {
+  private getUnreachableClusters(): Array<{name: string; protocol: string}> {
     const unreachableList = [];
-    const clusters = this.clusterLatencyResults;
 
-    Object.keys(clusters).forEach((key) => {
-      const cluster = clusters[key];
+    Object.entries(this.clusterReachability).forEach(([key, clusterReachability]) => {
+      const result = clusterReachability.getResult();
 
-      if (cluster.unreachable && !cluster.reachable) {
-        unreachableList.push(key);
+      if (result.udp.result === 'unreachable') {
+        unreachableList.push({name: key, protocol: 'udp'});
+      }
+      if (result.tcp.result === 'unreachable') {
+        unreachableList.push({name: key, protocol: 'tcp'});
       }
     });
 
     return unreachableList;
   }
 
-  /**
-   * Attach an event handler for the icegatheringstatechange
-   * event and measure latency.
-   * @param {RTCPeerConnection} peerConnection
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  private handleIceGatheringStateChange(peerConnection: RTCPeerConnection) {
-    peerConnection.onicegatheringstatechange = () => {
-      const {COMPLETE} = ICE_GATHERING_STATE;
-
-      if (peerConnection.iceConnectionState === COMPLETE) {
-        const elapsed = this.getElapsedTime(peerConnection);
-
-        // @ts-ignore
-        LoggerProxy.logger.log(
-          // @ts-ignore
-          `Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`,
-          elapsed
-        );
-        this.setLatencyAndClose(peerConnection, elapsed);
-      }
-    };
-  }
-
-  /**
-   * Attach an event handler for the icecandidate
-   * event and measure latency.
-   * @param {RTCPeerConnection} peerConnection
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  private handleOnIceCandidate(peerConnection: RTCPeerConnection) {
-    peerConnection.onicecandidate = (e) => {
-      const SERVER_REFLEXIVE = 'srflx';
-
-      if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
-        const elapsed = this.getElapsedTime(peerConnection);
-
-        LoggerProxy.logger.log(
-          // @ts-ignore
-          `Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`,
-          elapsed
-        );
-        this.setLatencyAndClose(peerConnection, elapsed);
-      }
-    };
-  }
-
-  /**
-   * An event handler on an RTCPeerConnection when the state of the ICE
-   * candidate gathering process changes. Used to measure connection
-   * speed.
-   * @private
-   * @param {RTCPeerConnection} peerConnection
-   * @param {number} timeout
-   * @returns {Promise}
-   */
-  private iceGatheringState(peerConnection: RTCPeerConnection, timeout: number) {
-    const ELAPSED = 'elapsed';
-
-    return new Promise((resolve) => {
-      const peerConnectionProxy = new window.Proxy(peerConnection, {
-        get(target, property) {
-          const targetMember = target[property];
-
-          if (typeof targetMember === 'function') {
-            return targetMember.bind(target);
-          }
-
-          return targetMember;
-        },
-        set: (target, property, value) => {
-          // only intercept elapsed property
-          if (property === ELAPSED) {
-            // @ts-ignore
-            resolve({clusterId: peerConnection.key, elapsed: value});
-
-            return true;
-          }
-
-          // pass thru
-          return window.Reflect.set(target, property, value);
-        },
-      });
-
-      // Using peerConnection proxy so handle functions below
-      // won't be coupled to our promise implementation
-      this.handleIceGatheringStateChange(peerConnectionProxy);
-      this.handleOnIceCandidate(peerConnectionProxy);
-
-      // Set maximum timeout
-      window.setTimeout(() => {
-        const {CLOSED} = CONNECTION_STATE;
-
-        // Close any open peerConnections
-        if (peerConnectionProxy.connectionState !== CLOSED) {
-          this.setLatencyAndClose(peerConnectionProxy, null);
-        }
-      }, timeout);
-    });
-  }
-
   /**
    * Make a log of unreachable clusters.
    * @returns {undefined}
@@ -356,123 +320,55 @@ export default class Reachability {
    * @memberof Reachability
    */
   private logUnreachableClusters() {
-    const list = this.getUnreachablClusters();
+    const list = this.getUnreachableClusters();
 
-    list.forEach((cluster) => {
+    list.forEach(({name, protocol}) => {
       LoggerProxy.logger.log(
-        `Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`
+        `Reachability:index#logUnreachableClusters --> failed to reach ${name} over ${protocol}`
       );
     });
   }
 
   /**
-   * Calculates time to establish connection
-   * @param {array} iceResults iceResults
-   * @returns {object} reachabilityMap
-   * @private
-   * @memberof Reachability
+   * Performs reachability checks for all clusters
+   * @param {ClusterList} clusterList
+   * @returns {Promise<ReachabilityResults>} reachability check results
    */
-  private parseIceResultsToReachabilityResults(iceResults: Array<any>) {
-    const reachabilityMap = {};
-
-    iceResults.forEach(({clusterId, elapsed}) => {
-      let latencyResult;
-
-      if (elapsed === null) {
-        latencyResult = {reachable: 'false'};
-      } else {
-        latencyResult = {
-          reachable: 'true',
-          latencyInMilliseconds: elapsed.toString(),
-        };
-      }
-
-      reachabilityMap[clusterId] = {
-        udp: latencyResult,
-        tcp: latencyResult,
-      };
-    });
-
-    return reachabilityMap;
-  }
+  private async performReachabilityChecks(clusterList: ClusterList): Promise<ReachabilityResults> {
+    const results: ReachabilityResults = {};
 
-  /**
-   * fetches reachability data
-   * @param {object} clusterList
-   * @returns {Promise<localSDPData>} reachability check results
-   * @private
-   * @memberof Reachability
-   */
-  private performReachabilityCheck(clusterList: object) {
     if (!clusterList || !Object.keys(clusterList).length) {
-      return Promise.resolve({});
+      return Promise.resolve(results);
     }
 
-    return new Promise((resolve) => {
-      this.getLocalSDPForClusters(clusterList)
-        .then((localSDPData) => {
-          if (!localSDPData || !Object.keys(localSDPData).length) {
-            // TODO: handle the error condition properly and try retry
-            LoggerProxy.logger.log(
-              'Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning'
-            );
-            resolve({});
-          } else {
-            resolve(localSDPData);
-          }
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error(
-            `Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ${error}`
-          );
-          resolve({});
-        });
-    });
-  }
-
-  /**
-   * Records latency and closes the peerConnection
-   * @param {RTCPeerConnection} peerConnection
-   * @param {number} elapsed Latency in milliseconds
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  private setLatencyAndClose(peerConnection: RTCPeerConnection, elapsed: number) {
-    const REACHABLE = 'reachable';
-    const UNREACHABLE = 'unreachable';
-    const {CLOSED} = CONNECTION_STATE;
     // @ts-ignore
-    const {key} = peerConnection;
-    const resultKey = elapsed === null ? UNREACHABLE : REACHABLE;
-    const intialState = {[REACHABLE]: 0, [UNREACHABLE]: 0};
+    const includeTcpReachability = this.webex.config.meetings.experimental.enableTcpReachability;
 
-    if (peerConnection.connectionState === CLOSED) {
-      LoggerProxy.logger.log(
-        `Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`
-      );
+    LoggerProxy.logger.log(
+      `Reachability:index#performReachabilityChecks --> doing UDP${
+        includeTcpReachability ? ' and TCP' : ''
+      } reachability checks`
+    );
 
-      return;
-    }
+    const clusterReachabilityChecks = Object.keys(clusterList).map((key) => {
+      const cluster = clusterList[key];
 
-    this.clusterLatencyResults[key] = this.clusterLatencyResults[key] || intialState;
-    this.clusterLatencyResults[key][resultKey] += 1;
+      if (!includeTcpReachability) {
+        cluster.tcp = [];
+      }
 
-    // Set to null in case this fired from
-    // an event other than onIceCandidate
-    peerConnection.onicecandidate = null;
-    peerConnection.close();
-    // @ts-ignore
-    peerConnection.elapsed = elapsed;
-  }
+      this.clusterReachability[key] = new ClusterReachability(key, cluster);
 
-  /**
-   * utility function
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  private setup() {
-    this.clusterLatencyResults = {};
+      return this.clusterReachability[key].start().then((result) => {
+        results[key] = result;
+        results[key].isVideoMesh = cluster.isVideoMesh;
+      });
+    });
+
+    await Promise.all(clusterReachabilityChecks);
+
+    this.logUnreachableClusters();
+
+    return results;
   }
 }