@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

package/src/reachability/{index.js → index.ts}

@@ -7,28 +7,30 @@
 import _ from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  ICE_GATHERING_STATE,
-  CONNECTION_STATE,
-  REACHABILITY
-} from '../constants';
+import {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY} from '../constants';
 
 import ReachabilityRequest from './request';
 
 const DEFAULT_TIMEOUT = 3000;
 const VIDEO_MESH_TIMEOUT = 1000;
 
+export type ICECandidateResult = {clusterId: string; elapsed?: string | null; publicIPs?: string[]};
 /**
  * @class Reachability
  * @export
  */
 export default class Reachability {
+  namespace = REACHABILITY.namespace;
+  webex: object;
+  reachabilityRequest: any;
+  clusterLatencyResults: any;
+
   /**
    * Creates an instance of Reachability.
    * @param {object} webex
    * @memberof Reachability
    */
-  constructor(webex) {
+  constructor(webex: object) {
     this.webex = webex;
 
     /**
@@ -50,7 +52,6 @@ export default class Reachability {
     this.clusterLatencyResults = {};
   }
 
-
   /**
    * fetches reachability data
    * @returns {Object} reachability data
@@ -58,34 +59,44 @@ export default class Reachability {
    * @async
    * @memberof Reachability
    */
-  async gatherReachability() {
+  public async gatherReachability() {
     this.setup();
 
     // 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();
 
       // Perform Reachability Check
       const results = await this.performReachabilityCheck(clusters);
 
-      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
-
-      LoggerProxy.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
+      // @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 (getClusterError) {
+      LoggerProxy.logger.error(
+        `Reachability:index#gatherReachability --> Error in calling getClusters(): ${getClusterError}`
+      );
 
       return {};
     }
@@ -97,25 +108,30 @@ export default class Reachability {
    * @public
    * @memberof Reachability
    */
-  isAnyClusterReachable() {
+  async isAnyClusterReachable() {
     let reachable = false;
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
 
     if (reachabilityData) {
       try {
         const reachabilityResults = JSON.parse(reachabilityData);
 
-        reachable = Object.values(reachabilityResults).some((result) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true');
-      }
-      catch (e) {
-        LoggerProxy.logger.error(`Roap:request#attachReachabilityData --> Error in 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 reachable;
   }
 
-
   /**
    * Generate peerConnection config settings
    * @param {object} cluster
@@ -123,26 +139,20 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  buildPeerConnectionConfig(cluster) {
-    const iceServers = _.uniq([
-      ...cluster.udp,
-      ...cluster.tcp
-    ]).map((url) => ({
+  private buildPeerConnectionConfig(cluster: any) {
+    const iceServers = _.uniq([...cluster.udp, ...cluster.tcp]).map((url) => ({
       username: '',
       credential: '',
-      urls: [url]
+      urls: [url],
     }));
 
     return {
-      iceServers: [
-        ...iceServers
-      ],
+      iceServers: [...iceServers],
       iceCandidatePoolSize: '0',
-      iceTransportPolicy: 'all'
+      iceTransportPolicy: 'all',
     };
   }
 
-
   /**
    * Creates an RTCPeerConnection
    * @param {object} cluster
@@ -150,24 +160,25 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  createPeerConnection(cluster) {
+  private createPeerConnection(cluster: any) {
     const {key, config} = cluster;
 
     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}`);
+    } catch (peerConnectionError) {
+      LoggerProxy.logger.log(
+        `Reachability:index#createPeerConnection --> Error creating peerConnection: ${peerConnectionError}`
+      );
 
       return null;
     }
   }
 
-
   /**
    * Gets total elapsed time
    * @param {RTCPeerConnection} peerConnection
@@ -175,7 +186,7 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  getElapsedTime(peerConnection) {
+  private getElapsedTime(peerConnection: any) {
     const startTime = peerConnection.begin;
 
     delete peerConnection.begin;
@@ -183,7 +194,6 @@ export default class Reachability {
     return Date.now() - startTime;
   }
 
-
   /**
    * creates offer and generates localSDP
    * @param {object} clusterList cluster List
@@ -191,8 +201,8 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  getLocalSDPForClusters(clusterList) {
-    let clusters = [...Object.keys(clusterList)];
+  private getLocalSDPForClusters(clusterList: object) {
+    let clusters: any[] = [...Object.keys(clusterList)];
 
     clusters = clusters.map(async (key) => {
       const cluster = clusterList[key];
@@ -200,13 +210,18 @@ export default class Reachability {
       const peerConnection = this.createPeerConnection({key, config});
       const description = await peerConnection.createOffer({offerToReceiveAudio: true});
 
+      // @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 this.iceGatheringState(
+        peerConnection,
+        cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT
+      ).catch((iceGatheringStateError) => {
+        LoggerProxy.logger.log(
+          `Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ${iceGatheringStateError}`
+        );
+      });
     });
 
     return Promise.all(clusters)
@@ -219,14 +234,13 @@ export default class Reachability {
       });
   }
 
-
   /**
    * Get list of all unreachable clusters
    * @returns {array} Unreachable clusters
    * @private
    * @memberof Reachability
    */
-  getUnreachablClusters() {
+  private getUnreachablClusters() {
     const unreachableList = [];
     const clusters = this.clusterLatencyResults;
 
@@ -241,7 +255,6 @@ export default class Reachability {
     return unreachableList;
   }
 
-
   /**
    * Attach an event handler for the icegatheringstatechange
    * event and measure latency.
@@ -250,20 +263,24 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  handleIceGatheringStateChange(peerConnection) {
+  private handleIceGatheringStateChange(peerConnection: RTCPeerConnection) {
     peerConnection.onicegatheringstatechange = () => {
       const {COMPLETE} = ICE_GATHERING_STATE;
 
       if (peerConnection.iceConnectionState === COMPLETE) {
         const elapsed = this.getElapsedTime(peerConnection);
 
-        LoggerProxy.logger.log(`Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`, elapsed);
+        // @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.
@@ -272,14 +289,20 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  handleOnIceCandidate(peerConnection) {
+  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(`Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`, elapsed);
+        LoggerProxy.logger.log(
+          // @ts-ignore
+          `Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`,
+          elapsed
+        );
+        // order is important
+        this.addPublicIP(peerConnection, e.candidate.address);
         this.setLatencyAndClose(peerConnection, elapsed);
       }
     };
@@ -294,15 +317,16 @@ export default class Reachability {
    * @param {number} timeout
    * @returns {Promise}
    */
-  iceGatheringState(peerConnection, timeout) {
+  private iceGatheringState(peerConnection: RTCPeerConnection, timeout: number) {
     const ELAPSED = 'elapsed';
 
-    return new Promise((resolve) => {
+    return new Promise<ICECandidateResult>((resolve) => {
       const peerConnectionProxy = new window.Proxy(peerConnection, {
+        // eslint-disable-next-line require-jsdoc
         get(target, property) {
           const targetMember = target[property];
 
-          if (typeof (targetMember) === 'function') {
+          if (typeof targetMember === 'function') {
             return targetMember.bind(target);
           }
 
@@ -311,14 +335,15 @@ export default class Reachability {
         set: (target, property, value) => {
           // only intercept elapsed property
           if (property === ELAPSED) {
-            resolve({clusterId: peerConnection.key, elapsed: value});
+            // @ts-ignore
+            resolve({clusterId: peerConnection.key, publicIPs: target.publicIPs, elapsed: value});
 
             return true;
           }
 
           // pass thru
           return window.Reflect.set(target, property, value);
-        }
+        },
       });
 
       // Using peerConnection proxy so handle functions below
@@ -332,61 +357,67 @@ export default class Reachability {
 
         // Close any open peerConnections
         if (peerConnectionProxy.connectionState !== CLOSED) {
+          // order is important
+          this.addPublicIP(peerConnectionProxy, null);
           this.setLatencyAndClose(peerConnectionProxy, null);
         }
       }, timeout);
     });
   }
 
-
   /**
    * Make a log of unreachable clusters.
    * @returns {undefined}
    * @private
    * @memberof Reachability
    */
-  logUnreachableClusters() {
+  private logUnreachableClusters() {
     const list = this.getUnreachablClusters();
 
     list.forEach((cluster) => {
-      LoggerProxy.logger.log(`Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`);
+      LoggerProxy.logger.log(
+        `Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`
+      );
     });
   }
 
-
   /**
    * Calculates time to establish connection
-   * @param {array} iceResults iceResults
+   * @param {Array<ICECandidateResult>} iceResults iceResults
    * @returns {object} reachabilityMap
-   * @private
+   * @protected
    * @memberof Reachability
    */
-  parseIceResultsToReachabilityResults(iceResults) {
+  protected parseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
     const reachabilityMap = {};
 
-    iceResults.forEach(({clusterId, elapsed}) => {
-      let latencyResult;
+    iceResults.forEach(({clusterId, elapsed, publicIPs}) => {
+      const latencyResult = {};
 
-      if (elapsed === null) {
-        latencyResult = {reachable: 'false'};
-      }
-      else {
-        latencyResult = {
+      if (!elapsed) {
+        Object.assign(latencyResult, {reachable: 'false'});
+      } else {
+        Object.assign(latencyResult, {
           reachable: 'true',
-          latencyInMilliseconds: (elapsed).toString()
-        };
+          latencyInMilliseconds: elapsed.toString(),
+        });
+      }
+
+      if (publicIPs) {
+        Object.assign(latencyResult, {
+          clientMediaIPs: publicIPs,
+        });
       }
 
       reachabilityMap[clusterId] = {
         udp: latencyResult,
-        tcp: latencyResult
+        tcp: latencyResult,
       };
     });
 
     return reachabilityMap;
   }
 
-
   /**
    * fetches reachability data
    * @param {object} clusterList
@@ -394,7 +425,7 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  performReachabilityCheck(clusterList) {
+  private performReachabilityCheck(clusterList: object) {
     if (!clusterList || !Object.keys(clusterList).length) {
       return Promise.resolve({});
     }
@@ -404,20 +435,49 @@ export default class Reachability {
         .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');
+            LoggerProxy.logger.log(
+              'Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning'
+            );
             resolve({});
-          }
-          else {
+          } else {
             resolve(localSDPData);
           }
         })
         .catch((error) => {
-          LoggerProxy.logger.error(`Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ${error}`);
+          LoggerProxy.logger.error(
+            `Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ${error}`
+          );
           resolve({});
         });
     });
   }
 
+  /**
+   * Adds public IP (client media IPs)
+   * @param {RTCPeerConnection} peerConnection
+   * @param {string} publicIP
+   * @returns {void}
+   */
+  protected addPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
+    const modifiedPeerConnection: RTCPeerConnection & {publicIPs?: string[]} = peerConnection;
+    const {CLOSED} = CONNECTION_STATE;
+
+    if (modifiedPeerConnection.connectionState === CLOSED) {
+      LoggerProxy.logger.log(
+        `Reachability:index#addPublicIP --> Attempting to set publicIP of ${publicIP} on closed peerConnection.`
+      );
+    }
+
+    if (publicIP) {
+      if (modifiedPeerConnection.publicIPs) {
+        modifiedPeerConnection.publicIPs.push(publicIP);
+      } else {
+        modifiedPeerConnection.publicIPs = [publicIP];
+      }
+    } else {
+      modifiedPeerConnection.publicIPs = null;
+    }
+  }
 
   /**
    * Records latency and closes the peerConnection
@@ -427,16 +487,19 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  setLatencyAndClose(peerConnection, elapsed) {
+  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};
 
     if (peerConnection.connectionState === CLOSED) {
-      LoggerProxy.logger.log(`Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`);
+      LoggerProxy.logger.log(
+        `Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`
+      );
 
       return;
     }
@@ -448,17 +511,17 @@ export default class Reachability {
     // an event other than onIceCandidate
     peerConnection.onicecandidate = null;
     peerConnection.close();
+    // @ts-ignore
     peerConnection.elapsed = elapsed;
   }
 
-
   /**
    * utility function
    * @returns {undefined}
    * @private
    * @memberof Reachability
    */
-  setup() {
+  private setup() {
     this.clusterLatencyResults = {};
   }
 }

package/src/reachability/request.ts

@@ -1,9 +1,5 @@
 import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  HTTP_VERBS,
-  RESOURCE,
-  API
-} from '../constants';
+import {HTTP_VERBS, RESOURCE, API} from '../constants';
 
 export interface ClusterNode {
   isVideoMesh: boolean;
@@ -13,63 +9,78 @@ export interface ClusterNode {
 }
 
 export type ClusterList = {
-  [key:string]: ClusterNode;
-}
+  [key: string]: ClusterNode;
+};
 
 /**
  * @class ReachabilityRequest
  */
 class ReachabilityRequest {
+  webex: any;
+
   /**
    * Creates an instance of ReachabilityRequest.
    * @param {object} webex
    * @memberof ReachabilityRequest
    */
-  constructor(webex) {
+  constructor(webex: object) {
     this.webex = webex;
   }
 
   /**
-   * gets the cluster information
+   * Gets the cluster information
    *
-   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
    * @returns {Promise}
    */
-  getClusters = (): Promise<ClusterList> => this.webex.request({
-    method: HTTP_VERBS.GET,
-    shouldRefreshAccessToken: false,
-    api: API.CALLIOPEDISCOVERY,
-    resource: RESOURCE.CLUSTERS
-  })
-    .then((res) => {
-      const {clusters} = res.body;
+  getClusters = (): Promise<{clusters: ClusterList; joinCookie: any}> =>
+    this.webex
+      .request({
+        method: HTTP_VERBS.GET,
+        shouldRefreshAccessToken: false,
+        api: API.CALLIOPEDISCOVERY,
+        resource: RESOURCE.CLUSTERS,
+        qs: {
+          JCSupport: 1,
+        },
+      })
+      .then((res) => {
+        const {clusters, joinCookie} = res.body;
 
-      Object.keys(clusters).forEach((key) => {
-        clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
-      });
+        Object.keys(clusters).forEach((key) => {
+          clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
+        });
 
-      LoggerProxy.logger.log(`Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`);
+        LoggerProxy.logger.log(
+          `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
+        );
 
-      return clusters;
-    });
+        return {
+          clusters,
+          joinCookie,
+        };
+      });
 
   /**
    * gets remote SDP For Clusters
    * @param {Object} localSDPList localSDPs for the cluster
    * @returns {Object}
    */
-  remoteSDPForClusters = (localSDPList) => this.webex.request({
-    method: HTTP_VERBS.POST,
-    shouldRefreshAccessToken: false,
-    api: API.CALLIOPEDISCOVERY,
-    resource: RESOURCE.REACHABILITY,
-    body: {offers: localSDPList}
-  })
-    .then((res) => {
-      LoggerProxy.logger.log('Reachability:request#remoteSDPForClusters --> Remote SDPs got succcessfully');
+  remoteSDPForClusters = (localSDPList: object) =>
+    this.webex
+      .request({
+        method: HTTP_VERBS.POST,
+        shouldRefreshAccessToken: false,
+        api: API.CALLIOPEDISCOVERY,
+        resource: RESOURCE.REACHABILITY,
+        body: {offers: localSDPList},
+      })
+      .then((res) => {
+        LoggerProxy.logger.log(
+          'Reachability:request#remoteSDPForClusters --> Remote SDPs got succcessfully'
+        );
 
-      return res.body;
-    });
+        return res.body;
+      });
 }
 
 export default ReachabilityRequest;

package/src/reactions/constants.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/prefer-default-export
+export const REACTION_RELAY_TYPES = {
+  REACTION: 'react',
+} as const;