@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/reachability/index.ts

@@ -3,70 +3,25 @@
  */
 
 /* eslint-disable class-methods-use-this */
-import {mapValues} from 'lodash';
+/* globals window */
+import _ from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-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 {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY} from '../constants';
 
-/**
- * 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;
-  }
->;
+import ReachabilityRequest from './request';
+
+const DEFAULT_TIMEOUT = 3000;
+const VIDEO_MESH_TIMEOUT = 1000;
 
 /**
  * @class Reachability
  * @export
  */
 export default class Reachability {
-  namespace = REACHABILITY.namespace;
   webex: object;
-  reachabilityRequest: ReachabilityRequest;
-  clusterReachability: {
-    [key: string]: ClusterReachability;
-  };
+  reachabilityRequest: any;
+  clusterLatencyResults: any;
 
   /**
    * Creates an instance of Reachability.
@@ -85,209 +40,187 @@ export default class Reachability {
      */
     this.reachabilityRequest = new ReachabilityRequest(this.webex);
 
-    this.clusterReachability = {};
+    /**
+     * internal object of clusters latency results
+     * @instance
+     * @type {object}
+     * @private
+     * @memberof Reachability
+     */
+    this.clusterLatencyResults = {};
   }
 
   /**
-   * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
-   * @returns {Promise<ReachabilityResults>} reachability results
+   * fetches reachability data
+   * @returns {Object} reachability data
    * @public
+   * @async
    * @memberof Reachability
    */
-  public async gatherReachability(): Promise<ReachabilityResults> {
+  public async gatherReachability() {
+    this.setup();
+
     // Remove stored reachability results to ensure no stale data
-    // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
-    // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
+    if (window?.localStorage?.removeItem) {
+      window.localStorage.removeItem(REACHABILITY.localStorage);
+    } else {
+      LoggerProxy.logger.error(
+        'Reachability:index#gatherReachability --> Error in accessing LocalStorage.'
+      );
+
+      return {};
+    }
 
     // Fetch clusters and measure latency
     try {
-      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters(
-        MeetingUtil.getIpVersion(this.webex)
-      );
+      const clusters = await this.reachabilityRequest.getClusters();
 
       // Perform Reachability Check
-      const results = await this.performReachabilityChecks(clusters);
+      const results = await this.performReachabilityCheck(clusters);
 
-      // @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)
-      );
+      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
 
       LoggerProxy.logger.log(
         'Reachability:index#gatherReachability --> Reachability checks completed'
       );
 
       return results;
-    } catch (error) {
-      LoggerProxy.logger.error(`Reachability:index#gatherReachability --> Error:`, error);
+    } catch (getClusterError) {
+      LoggerProxy.logger.error(
+        `Reachability:index#gatherReachability --> Error in calling getClusters(): ${getClusterError}`
+      );
 
       return {};
     }
   }
 
   /**
-   * 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.
+   * fetches reachability data and checks for cluster reachability
+   * @returns {boolean}
+   * @public
+   * @memberof Reachability
    */
-  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,
-    };
-
-    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
-      );
+  isAnyClusterReachable() {
+    let reachable = false;
+    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
 
-      const results: ReachabilityResults = JSON.parse(resultsJson);
+    if (reachabilityData) {
+      try {
+        const reachabilityResults = JSON.parse(reachabilityData);
 
-      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
-      );
+        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}`
+        );
+      }
     }
 
-    return stats;
+    return reachable;
   }
 
   /**
-   * Maps our internal transport result to the format that backend expects
-   * @param {TransportResult} transportResult
-   * @returns {TransportResultForBackend}
+   * Generate peerConnection config settings
+   * @param {object} cluster
+   * @returns {object} peerConnectionConfig
+   * @private
+   * @memberof Reachability
    */
-  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;
+  private buildPeerConnectionConfig(cluster: any) {
+    const iceServers = _.uniq([...cluster.udp, ...cluster.tcp]).map((url) => ({
+      username: '',
+      credential: '',
+      urls: [url],
+    }));
+
+    return {
+      iceServers: [...iceServers],
+      iceCandidatePoolSize: '0',
+      iceTransportPolicy: 'all',
+    };
   }
 
   /**
-   * Reachability results as an object in the format that backend expects
-   *
-   * @returns {any} reachability results that need to be sent to the backend
+   * Creates an RTCPeerConnection
+   * @param {object} cluster
+   * @returns {RTCPeerConnection} peerConnection
+   * @private
+   * @memberof Reachability
    */
-  async getReachabilityResults(): Promise<ReachabilityResultsForBackend | undefined> {
-    let results: ReachabilityResultsForBackend;
+  private createPeerConnection(cluster: any) {
+    const {key, config} = cluster;
 
     try {
+      const peerConnection = new window.RTCPeerConnection(config);
+
       // @ts-ignore
-      const resultsJson = await this.webex.boundedStorage.get(
-        REACHABILITY.namespace,
-        REACHABILITY.localStorageResult
-      );
+      peerConnection.key = key;
 
-      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
+      return peerConnection;
+    } catch (peerConnectionError) {
+      LoggerProxy.logger.log(
+        `Reachability:index#createPeerConnection --> Error creating peerConnection: ${peerConnectionError}`
       );
+
+      return null;
     }
+  }
 
-    return results;
+  /**
+   * 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;
   }
 
   /**
-   * fetches reachability data and checks for cluster reachability
-   * @returns {boolean}
-   * @public
+   * creates offer and generates localSDP
+   * @param {object} clusterList cluster List
+   * @returns {Promise} Reachability latency results
+   * @private
    * @memberof Reachability
    */
-  async isAnyPublicClusterReachable() {
-    let reachable = false;
-    // @ts-ignore
-    const reachabilityData = await this.webex.boundedStorage
-      .get(this.namespace, REACHABILITY.localStorageResult)
-      .catch(() => {});
+  private getLocalSDPForClusters(clusterList: object) {
+    let clusters: any[] = [...Object.keys(clusterList)];
 
-    if (reachabilityData) {
-      try {
-        const reachabilityResults: ReachabilityResults = JSON.parse(reachabilityData);
+    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});
 
-        reachable = Object.values(reachabilityResults).some(
-          (result) =>
-            !result.isVideoMesh &&
-            (result.udp?.result === 'reachable' || result.tcp?.result === 'reachable')
-        );
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+      // @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}`
         );
-      }
-    }
+      });
+    });
 
-    return reachable;
+    return Promise.all(clusters)
+      .then(this.parseIceResultsToReachabilityResults)
+      .then((reachabilityLatencyResults) => {
+        this.logUnreachableClusters();
+
+        // return results
+        return reachabilityLatencyResults;
+      });
   }
 
   /**
@@ -296,23 +229,126 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  private getUnreachableClusters(): Array<{name: string; protocol: string}> {
+  private getUnreachablClusters() {
     const unreachableList = [];
+    const clusters = this.clusterLatencyResults;
 
-    Object.entries(this.clusterReachability).forEach(([key, clusterReachability]) => {
-      const result = clusterReachability.getResult();
+    Object.keys(clusters).forEach((key) => {
+      const cluster = clusters[key];
 
-      if (result.udp.result === 'unreachable') {
-        unreachableList.push({name: key, protocol: 'udp'});
-      }
-      if (result.tcp.result === 'unreachable') {
-        unreachableList.push({name: key, protocol: 'tcp'});
+      if (cluster.unreachable && !cluster.reachable) {
+        unreachableList.push(key);
       }
     });
 
     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}
@@ -320,58 +356,123 @@ export default class Reachability {
    * @memberof Reachability
    */
   private logUnreachableClusters() {
-    const list = this.getUnreachableClusters();
+    const list = this.getUnreachablClusters();
 
-    list.forEach(({name, protocol}) => {
+    list.forEach((cluster) => {
       LoggerProxy.logger.log(
-        `Reachability:index#logUnreachableClusters --> failed to reach ${name} over ${protocol}`
+        `Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`
       );
     });
   }
 
   /**
-   * Performs reachability checks for all clusters
-   * @param {ClusterList} clusterList
-   * @returns {Promise<ReachabilityResults>} reachability check results
+   * Calculates time to establish connection
+   * @param {array} iceResults iceResults
+   * @returns {object} reachabilityMap
+   * @private
+   * @memberof Reachability
    */
-  private async performReachabilityChecks(clusterList: ClusterList): Promise<ReachabilityResults> {
-    const results: ReachabilityResults = {};
+  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(),
+        };
+      }
 
-    if (!clusterList || !Object.keys(clusterList).length) {
-      return Promise.resolve(results);
-    }
+      reachabilityMap[clusterId] = {
+        udp: latencyResult,
+        tcp: latencyResult,
+      };
+    });
 
-    LoggerProxy.logger.log(
-      `Reachability:index#performReachabilityChecks --> doing UDP${
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability ? ' and TCP' : ''
-      } reachability checks`
-    );
+    return reachabilityMap;
+  }
 
-    const clusterReachabilityChecks = Object.keys(clusterList).map((key) => {
-      const cluster = clusterList[key];
+  /**
+   * 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({});
+    }
 
-      // Linus doesn't support TCP reachability checks on video mesh nodes
-      const includeTcpReachability =
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
+    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({});
+        });
+    });
+  }
 
-      if (!includeTcpReachability) {
-        cluster.tcp = [];
-      }
+  /**
+   * 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};
 
-      this.clusterReachability[key] = new ClusterReachability(key, cluster);
+    if (peerConnection.connectionState === CLOSED) {
+      LoggerProxy.logger.log(
+        `Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`
+      );
 
-      return this.clusterReachability[key].start().then((result) => {
-        results[key] = result;
-        results[key].isVideoMesh = cluster.isVideoMesh;
-      });
-    });
+      return;
+    }
 
-    await Promise.all(clusterReachabilityChecks);
+    this.clusterLatencyResults[key] = this.clusterLatencyResults[key] || intialState;
+    this.clusterLatencyResults[key][resultKey] += 1;
 
-    this.logUnreachableClusters();
+    // Set to null in case this fired from
+    // an event other than onIceCandidate
+    peerConnection.onicecandidate = null;
+    peerConnection.close();
+    // @ts-ignore
+    peerConnection.elapsed = elapsed;
+  }
 
-    return results;
+  /**
+   * utility function
+   * @returns {undefined}
+   * @private
+   * @memberof Reachability
+   */
+  private setup() {
+    this.clusterLatencyResults = {};
   }
 }