@webex/plugin-meetings 3.0.0-beta.256 → 3.0.0-beta.258

package/src/reachability/index.ts

@@ -4,7 +4,7 @@
 
 /* eslint-disable class-methods-use-this */
 /* globals window */
-import _ from 'lodash';
+import {uniq, mapValues, pick} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import MeetingUtil from '../meeting/util';
@@ -16,7 +16,39 @@ import ReachabilityRequest from './request';
 const DEFAULT_TIMEOUT = 3000;
 const VIDEO_MESH_TIMEOUT = 1000;
 
-export type ICECandidateResult = {clusterId: string; elapsed?: string | null; publicIPs?: string[]};
+// result for a specific transport protocol (like udp or tcp)
+export type TransportResult = {
+  reachable: 'true' | 'false';
+  latencyInMilliseconds?: string;
+  clientMediaIPs?: string[];
+  untested?: 'true';
+};
+
+// reachability result for a specifc media cluster
+type ReachabilityResult = {
+  udp: TransportResult;
+  tcp: TransportResult;
+  xtls: {
+    untested: 'true';
+  };
+};
+// this is the type that is required by the backend when we send them reachability results
+export type ReachabilityResults = Record<string, ReachabilityResult>;
+
+// this is the type used by Reachability class internally and stored in local storage
+type InternalReachabilityResults = Record<
+  string,
+  ReachabilityResult & {
+    isVideoMesh?: boolean;
+  }
+>;
+
+export type ICECandidateResult = {
+  clusterId: string;
+  isVideoMesh: boolean;
+  elapsed?: string | null;
+  publicIPs?: string[];
+};
 /**
  * @class Reachability
  * @export
@@ -61,7 +93,7 @@ export default class Reachability {
    * @async
    * @memberof Reachability
    */
-  public async gatherReachability() {
+  public async gatherReachability(): Promise<InternalReachabilityResults> {
     this.setup();
 
     // Remove stored reachability results to ensure no stale data
@@ -106,13 +138,45 @@ export default class Reachability {
     }
   }
 
+  /**
+   * Reachability results as an object in the format that backend expects
+   *
+   * @returns {any} reachability results that need to be sent to the backend
+   */
+  async getReachabilityResults(): Promise<ReachabilityResults | undefined> {
+    let results: ReachabilityResults;
+
+    // these are the only props that backend needs in the reachability results:
+    const reachabilityResultsProps: Array<keyof ReachabilityResult> = ['udp', 'tcp', 'xtls'];
+
+    try {
+      // @ts-ignore
+      const resultsJson = await this.webex.boundedStorage.get(
+        REACHABILITY.namespace,
+        REACHABILITY.localStorageResult
+      );
+
+      const internalResults: InternalReachabilityResults = JSON.parse(resultsJson);
+
+      results = mapValues(internalResults, (result) => pick(result, reachabilityResultsProps));
+    } catch (e) {
+      // empty storage, that's ok
+      LoggerProxy.logger.warn(
+        'Roap:request#attachReachabilityData --> Error parsing reachability data: ',
+        e
+      );
+    }
+
+    return results;
+  }
+
   /**
    * fetches reachability data and checks for cluster reachability
    * @returns {boolean}
    * @public
    * @memberof Reachability
    */
-  async isAnyClusterReachable() {
+  async isAnyPublicClusterReachable() {
     let reachable = false;
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
@@ -121,10 +185,12 @@ export default class Reachability {
 
     if (reachabilityData) {
       try {
-        const reachabilityResults = JSON.parse(reachabilityData);
+        const reachabilityResults: InternalReachabilityResults = JSON.parse(reachabilityData);
 
         reachable = Object.values(reachabilityResults).some(
-          (result: any) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true'
+          (result) =>
+            !result.isVideoMesh &&
+            (result.udp?.reachable === 'true' || result.tcp?.reachable === 'true')
         );
       } catch (e) {
         LoggerProxy.logger.error(
@@ -144,7 +210,7 @@ export default class Reachability {
    * @memberof Reachability
    */
   private buildPeerConnectionConfig(cluster: any) {
-    const iceServers = _.uniq(cluster.udp).map((url) => ({
+    const iceServers = uniq(cluster.udp).map((url) => ({
       username: '',
       credential: '',
       urls: [url],
@@ -205,7 +271,7 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  private getLocalSDPForClusters(clusterList: object) {
+  private getLocalSDPForClusters(clusterList: object): Promise<InternalReachabilityResults> {
     let clusters: any[] = [...Object.keys(clusterList)];
 
     clusters = clusters.map(async (key) => {
@@ -218,18 +284,17 @@ export default class Reachability {
       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).catch(
+        (iceGatheringStateError) => {
+          LoggerProxy.logger.log(
+            `Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ${iceGatheringStateError}`
+          );
+        }
+      );
     });
 
     return Promise.all(clusters)
-      .then(this.parseIceResultsToReachabilityResults)
+      .then(this.parseIceResultsToInternalReachabilityResults)
       .then((reachabilityLatencyResults) => {
         this.logUnreachableClusters();
 
@@ -318,12 +383,14 @@ export default class Reachability {
    * speed.
    * @private
    * @param {RTCPeerConnection} peerConnection
-   * @param {number} timeout
+   * @param {boolean} isVideoMesh
    * @returns {Promise}
    */
-  private iceGatheringState(peerConnection: RTCPeerConnection, timeout: number) {
+  private iceGatheringState(peerConnection: RTCPeerConnection, isVideoMesh: boolean) {
     const ELAPSED = 'elapsed';
 
+    const timeout = isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT;
+
     return new Promise<ICECandidateResult>((resolve) => {
       const peerConnectionProxy = new window.Proxy(peerConnection, {
         // eslint-disable-next-line require-jsdoc
@@ -339,8 +406,14 @@ export default class Reachability {
         set: (target, property, value) => {
           // only intercept elapsed property
           if (property === ELAPSED) {
-            // @ts-ignore
-            resolve({clusterId: peerConnection.key, publicIPs: target.publicIPs, elapsed: value});
+            resolve({
+              // @ts-ignore
+              clusterId: peerConnection.key,
+              isVideoMesh,
+              // @ts-ignore
+              publicIPs: target.publicIPs,
+              elapsed: value,
+            });
 
             return true;
           }
@@ -392,10 +465,12 @@ export default class Reachability {
    * @protected
    * @memberof Reachability
    */
-  protected parseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
+  protected parseIceResultsToInternalReachabilityResults(
+    iceResults: Array<ICECandidateResult>
+  ): InternalReachabilityResults {
     const reachabilityMap = {};
 
-    iceResults.forEach(({clusterId, elapsed, publicIPs}) => {
+    iceResults.forEach(({clusterId, isVideoMesh, elapsed, publicIPs}) => {
       const latencyResult = {};
 
       if (!elapsed) {
@@ -417,6 +492,7 @@ export default class Reachability {
         udp: latencyResult,
         tcp: {untested: 'true'},
         xtls: {untested: 'true'},
+        isVideoMesh,
       };
     });
 
@@ -426,11 +502,11 @@ export default class Reachability {
   /**
    * fetches reachability data
    * @param {object} clusterList
-   * @returns {Promise<localSDPData>} reachability check results
+   * @returns {Promise<InternalReachabilityResults>} reachability check results
    * @private
    * @memberof Reachability
    */
-  private performReachabilityCheck(clusterList: object) {
+  private performReachabilityCheck(clusterList: object): Promise<InternalReachabilityResults> {
     if (!clusterList || !Object.keys(clusterList).length) {
       return Promise.resolve({});
     }

package/src/reachability/request.ts

@@ -49,7 +49,7 @@ class ReachabilityRequest {
         const {clusters, joinCookie} = res.body;
 
         Object.keys(clusters).forEach((key) => {
-          clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
+          clusters[key].isVideoMesh = !!res.body.clusterClasses?.hybridMedia?.includes(key);
         });
 
         LoggerProxy.logger.log(

package/src/roap/request.ts

@@ -18,23 +18,10 @@ export default class RoapRequest extends StatelessWebexPlugin {
     let joinCookie;
 
     // @ts-ignore
-    const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
-      .catch(() => {});
-
-    if (reachabilityData) {
-      try {
-        const reachabilityResult = JSON.parse(reachabilityData);
+    const reachabilityResult = await this.webex.meetings.reachability.getReachabilityResults();
 
-        /* istanbul ignore else */
-        if (reachabilityResult && Object.keys(reachabilityResult).length) {
-          localSdp.reachability = reachabilityResult;
-        }
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
-        );
-      }
+    if (reachabilityResult && Object.keys(reachabilityResult).length) {
+      localSdp.reachability = reachabilityResult;
     }
 
     // @ts-ignore

package/src/roap/turnDiscovery.ts

@@ -225,10 +225,11 @@ export default class TurnDiscovery {
    * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
    */
   private async getSkipReason(meeting: Meeting): Promise<string> {
-    // @ts-ignore - fix type
-    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+    const isAnyPublicClusterReachable =
+      // @ts-ignore - fix type
+      await meeting.webex.meetings.reachability.isAnyPublicClusterReachable();
 
-    if (isAnyClusterReachable) {
+    if (isAnyPublicClusterReachable) {
       LoggerProxy.logger.info(
         'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
       );

package/test/unit/spec/meeting/index.js

@@ -1722,7 +1722,8 @@ describe('plugin-meetings', () => {
           meeting.locusInfo.onFullLocus = sinon.stub();
           meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
           meeting.webex.meetings.reachability = {
-            isAnyClusterReachable: sinon.stub().resolves(true),
+            isAnyPublicClusterReachable: sinon.stub().resolves(true),
+            getReachabilityResults: sinon.stub().resolves(undefined),
           };
           meeting.roap.doTurnDiscovery = sinon
             .stub()

package/test/unit/spec/reachability/index.ts

@@ -1,12 +1,12 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
-import Reachability, {ICECandidateResult} from '@webex/plugin-meetings/src/reachability/';
+import Reachability, {ICECandidateResult, ReachabilityResults} from '@webex/plugin-meetings/src/reachability/';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 
 import { IP_VERSION } from '@webex/plugin-meetings/src/constants';
 
-describe('isAnyClusterReachable', () => {
+describe('isAnyPublicClusterReachable', () => {
   let webex;
 
   beforeEach(() => {
@@ -29,7 +29,7 @@ describe('isAnyClusterReachable', () => {
     }
     const reachability = new Reachability(webex);
 
-    const result = await reachability.isAnyClusterReachable();
+    const result = await reachability.isAnyPublicClusterReachable();
 
     assert.equal(result, expectedValue);
   };
@@ -57,6 +57,63 @@ describe('isAnyClusterReachable', () => {
   it('returns false when reachability.result item is not there', async () => {
     await checkIsClusterReachable(undefined, false);
   });
+
+  describe('ignores video mesh reachability', () => {
+    it('returns false if there are no public cluster results, only video mesh', async () => {
+      await checkIsClusterReachable({
+        x: {
+          udp: {reachable: 'true'},
+          tcp: {reachable: 'true'},
+          isVideoMesh: true,
+        },
+        y: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true'},
+          isVideoMesh: true,
+        }
+      }, false);
+    });
+
+    it('returns false if there public cluster reachability failed, only video mesh succeeded', async () => {
+      await checkIsClusterReachable({
+        x: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true'},
+          isVideoMesh: true,
+        },
+        y: {
+          udp: {reachable: 'true'},
+          tcp: {reachable: 'false'},
+          isVideoMesh: true,
+        },
+        publicOne: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'false'},
+          isVideoMesh: false,
+        }
+      }, false);
+    });
+
+    it('returns true if there is at least 1 public cluster result, while video mesh is not reachable', async () => {
+      await checkIsClusterReachable({
+        x: {
+          udp: {reachable: 'true'},
+          tcp: {reachable: 'true'},
+          isVideoMesh: true,
+        },
+        y: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true'},
+          isVideoMesh: true,
+        },
+        publicOne: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true'},
+          isVideoMesh: false,
+        }
+      }, true);
+    });
+  })
 });
 
 describe('gatherReachability', () => {
@@ -160,8 +217,8 @@ describe('gatherReachability', () => {
     let testingClass: TestReachability;
 
     class TestReachability extends Reachability {
-      public testParseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
-        return this.parseIceResultsToReachabilityResults(iceResults);
+      public testParseIceResultsToInternalReachabilityResults(iceResults: Array<ICECandidateResult>) {
+        return this.parseIceResultsToInternalReachabilityResults(iceResults);
       }
       public testAddPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
         return this.addPublicIP(peerConnection, publicIP);
@@ -171,22 +228,25 @@ describe('gatherReachability', () => {
       testingClass = new TestReachability({webex});
     });
 
-    it('calls parseIceResultsToReachabilityResults correctly', () => {
-      const res = testingClass.testParseIceResultsToReachabilityResults([
+    it('calls parseIceResultsToInternalReachabilityResults correctly', () => {
+      const res = testingClass.testParseIceResultsToInternalReachabilityResults([
         {
           clusterId: 'id1',
           elapsed: '12312',
           publicIPs: ['1.1.1.1'],
+          isVideoMesh: true,
         },
         {
           clusterId: 'id2',
           elapsed: null,
           publicIPs: ['1.1.1.1'],
+          isVideoMesh: false,
         },
         {
           clusterId: 'id2',
           elapsed: '14123',
           publicIPs: undefined,
+          isVideoMesh: false,
         },
       ]);
 
@@ -203,6 +263,7 @@ describe('gatherReachability', () => {
             latencyInMilliseconds: '12312',
             reachable: 'true',
           },
+          isVideoMesh: true,
         },
         id2: {
           xtls: {
@@ -215,6 +276,7 @@ describe('gatherReachability', () => {
             latencyInMilliseconds: '14123',
             reachable: 'true',
           },
+          isVideoMesh: false,
         },
       });
     });
@@ -260,3 +322,97 @@ describe('gatherReachability', () => {
     });
   });
 });
+
+describe('getReachabilityResults', () => {
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+
+    // sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const runCheck = async (mockStorage: any, expectedResult: ReachabilityResults) => {
+    if (mockStorage) {
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
+    }
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.getReachabilityResults();
+
+    assert.deepEqual(result, expectedResult);
+  };
+
+  it('returns undefined if reading from local storage fails', async () => {
+    sinon.stub(webex.boundedStorage, 'get').rejects(new Error('fake error'));
+
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.getReachabilityResults();
+
+    assert.isUndefined(result);
+  });
+
+  it('returns results from local storage, stripping any internal data', async () => {
+    await runCheck(
+      // mock storage:
+      {
+        cluster1: {
+          udp: {reachable: 'true', latencyInMilliseconds: '100'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+        },
+        cluster2: {
+          udp: {reachable: 'true', latencyInMilliseconds: '200'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+        },
+        cluster3: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+          someOtherField: 'any value',
+        },
+        cluster4: {
+          udp: {reachable: 'false', latencyInMilliseconds: '300'},
+          tcp: {reachable: 'false', untested: 'true'},
+          xtls: {untested: 'true'},
+          someOtherField: 'any value',
+        },
+      },
+      // expected result (same as above, but with isVideoMesh and someOtherField stripped out):
+      {
+        cluster1: {
+          udp: {reachable: 'true', latencyInMilliseconds: '100'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+        },
+        cluster2: {
+          udp: {reachable: 'true', latencyInMilliseconds: '200'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+        },
+        cluster3: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
+          xtls: {untested: 'true'},
+        },
+        cluster4: {
+          udp: {reachable: 'false', latencyInMilliseconds: '300'},
+          tcp: {reachable: 'false', untested: 'true'},
+          xtls: {untested: 'true'},
+        },
+      }
+    );
+  });
+});

package/test/unit/spec/roap/index.ts

@@ -64,7 +64,7 @@ describe('Roap', () => {
         setRoapSeq: sinon.stub(),
         config: {experimental: {enableTurnDiscovery: false}},
         locusMediaRequest: {fake: true},
-        webex: { meetings: { reachability: { isAnyClusterReachable: () => true}}},
+        webex: { meetings: { reachability: { isAnyPublicClusterReachable: () => true}}},
       };
 
       sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);

package/test/unit/spec/roap/request.ts

@@ -66,6 +66,7 @@ describe('plugin-meetings/roap', () => {
       JSON.stringify({
         clusterId: {
           udp: 'test',
+          isVideoMesh: false,
         },
       })
     );

package/test/unit/spec/roap/turnDiscovery.ts

@@ -54,7 +54,7 @@ describe('TurnDiscovery', () => {
       }),
       updateMediaConnections: sinon.stub(),
       webex: {meetings: {reachability: {
-        isAnyClusterReachable: () => Promise.resolve(false),
+        isAnyPublicClusterReachable: () => Promise.resolve(false),
       }}},
       isMultistream: false,
       locusMediaRequest: { fake: true },
@@ -257,8 +257,8 @@ describe('TurnDiscovery', () => {
     });
 
     it('resolves with undefined when cluster is reachable', async () => {
-      const prev = testMeeting.webex.meetings.reachability.isAnyClusterReachable;
-      testMeeting.webex.meetings.reachability.isAnyClusterReachable = () => Promise.resolve(true);
+      const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = () => Promise.resolve(true);
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = result;
@@ -267,7 +267,7 @@ describe('TurnDiscovery', () => {
       assert.equal(turnDiscoverySkippedReason, 'reachability');
       assert.notCalled(mockRoapRequest.sendRoap);
       assert.notCalled(Metrics.sendBehavioralMetric);
-      testMeeting.webex.meetings.reachability.isAnyClusterReachable = prev;
+      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
     });
 
     it("resolves with undefined if we don't get a response within 10s", async () => {
@@ -379,15 +379,15 @@ describe('TurnDiscovery', () => {
 
   describe('isSkipped', () => {
     [
-      {enabledInConfig: true, isAnyClusterReachable: true, expectedIsSkipped: true},
-      {enabledInConfig: true, isAnyClusterReachable: false, expectedIsSkipped: false},
-      {enabledInConfig: false, isAnyClusterReachable: true, expectedIsSkipped: true},
-      {enabledInConfig: false, isAnyClusterReachable: false, expectedIsSkipped: true},
-    ].forEach(({enabledInConfig, isAnyClusterReachable, expectedIsSkipped}) => {
-      it(`returns ${expectedIsSkipped} when TURN discovery is ${enabledInConfig ? '' : 'not '} enabled in config and isAnyClusterReachable() returns ${isAnyClusterReachable ? 'true' : 'false'}`, async () => {
+      {enabledInConfig: true, isAnyPublicClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: true, isAnyPublicClusterReachable: false, expectedIsSkipped: false},
+      {enabledInConfig: false, isAnyPublicClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: false, isAnyPublicClusterReachable: false, expectedIsSkipped: true},
+    ].forEach(({enabledInConfig, isAnyPublicClusterReachable, expectedIsSkipped}) => {
+      it(`returns ${expectedIsSkipped} when TURN discovery is ${enabledInConfig ? '' : 'not '} enabled in config and isAnyPublicClusterReachable() returns ${isAnyPublicClusterReachable ? 'true' : 'false'}`, async () => {
         testMeeting.config.experimental.enableTurnDiscovery = enabledInConfig;
 
-        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyClusterReachable').resolves(isAnyClusterReachable);
+        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyPublicClusterReachable').resolves(isAnyPublicClusterReachable);
 
         const td = new TurnDiscovery(mockRoapRequest);