@webex/plugin-meetings 3.8.0-next.3 → 3.8.0-next.30

package/src/reachability/clusterReachability.ts

@@ -6,7 +6,7 @@ import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 import EventsScope from '../common/events/events-scope';
 
 import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
-import {ClusterReachabilityResult} from './reachability.types';
+import {ClusterReachabilityResult, NatType} from './reachability.types';
 
 // data for the Events.resultReady event
 export type ResultEventData = {
@@ -22,9 +22,14 @@ export type ClientMediaIpsUpdatedEventData = {
   clientMediaIPs: string[];
 };
 
+export type NatTypeUpdatedEventData = {
+  natType: NatType;
+};
+
 export const Events = {
   resultReady: 'resultReady', // emitted when a cluster is reached successfully using specific protocol
   clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when more public IPs are found after resultReady was already sent for a given protocol
+  natTypeUpdated: 'natTypeUpdated', // emitted when NAT type is determined
 } as const;
 
 export type Events = Enum<typeof Events>;
@@ -41,6 +46,7 @@ export class ClusterReachability extends EventsScope {
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
   private startTimestamp: number;
+  private srflxIceCandidates: RTCIceCandidate[] = [];
   public readonly isVideoMesh: boolean;
   public readonly name;
 
@@ -290,6 +296,44 @@ export class ClusterReachability extends EventsScope {
     }
   }
 
+  /**
+   * Determines NAT Type.
+   *
+   * @param {RTCIceCandidate} candidate
+   * @returns {void}
+   */
+  private determineNatType(candidate: RTCIceCandidate) {
+    this.srflxIceCandidates.push(candidate);
+
+    if (this.srflxIceCandidates.length > 1) {
+      const portsFound: Record<string, Set<number>> = {};
+
+      this.srflxIceCandidates.forEach((c) => {
+        const key = `${c.address}:${c.relatedPort}`;
+        if (!portsFound[key]) {
+          portsFound[key] = new Set();
+        }
+        portsFound[key].add(c.port);
+      });
+
+      Object.entries(portsFound).forEach(([, ports]) => {
+        if (ports.size > 1) {
+          // Found candidates with the same address and relatedPort, but different ports
+          this.emit(
+            {
+              file: 'clusterReachability',
+              function: 'determineNatType',
+            },
+            Events.natTypeUpdated,
+            {
+              natType: NatType.SymmetricNat,
+            }
+          );
+        }
+      });
+    }
+  }
+
   /**
    * Registers a listener for the icecandidate event
    *
@@ -308,6 +352,8 @@ export class ClusterReachability extends EventsScope {
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
           this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
+
+          this.determineNatType(e.candidate);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {

package/src/reachability/index.ts

@@ -23,11 +23,13 @@ import {
   ReachabilityResultsForBackend,
   TransportResultForBackend,
   GetClustersTrigger,
+  NatType,
 } from './reachability.types';
 import {
   ClientMediaIpsUpdatedEventData,
   ClusterReachability,
   Events,
+  NatTypeUpdatedEventData,
   ResultEventData,
 } from './clusterReachability';
 import EventsScope from '../common/events/events-scope';
@@ -64,6 +66,7 @@ export default class Reachability extends EventsScope {
   resultsCount = {videoMesh: {udp: 0}, public: {udp: 0, tcp: 0, xtls: 0}};
   startTime = undefined;
   totalDuration = undefined;
+  natType = NatType.Unknown;
 
   protected lastTrigger?: string;
 
@@ -143,6 +146,10 @@ export default class Reachability extends EventsScope {
    * @memberof Reachability
    */
   public async gatherReachability(trigger: string): Promise<ReachabilityResults> {
+    // @ts-ignore
+    if (!this.webex.config.meetings.enableReachabilityChecks) {
+      throw new Error('enableReachabilityChecks is disabled in config');
+    }
     // Fetch clusters and measure latency
     try {
       this.lastTrigger = trigger;
@@ -305,6 +312,7 @@ export default class Reachability extends EventsScope {
       reachability_vmn_tcp_failed: 0,
       reachability_vmn_xtls_success: 0,
       reachability_vmn_xtls_failed: 0,
+      natType: this.natType,
     };
 
     const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
@@ -963,6 +971,13 @@ export default class Reachability extends EventsScope {
         }
       );
 
+      this.clusterReachability[key].on(
+        Events.natTypeUpdated,
+        async (data: NatTypeUpdatedEventData) => {
+          this.natType = data.natType;
+        }
+      );
+
       this.clusterReachability[key].start(); // not awaiting on purpose
     });
   }

package/src/reachability/reachability.types.ts

@@ -7,6 +7,11 @@ export type TransportResult = {
   clientMediaIPs?: string[];
 };
 
+export enum NatType {
+  Unknown = 'unknown',
+  SymmetricNat = 'symmetric-nat',
+}
+
 // reachability result for a specific media cluster
 export type ClusterReachabilityResult = {
   udp: TransportResult;
@@ -27,6 +32,7 @@ export type ReachabilityMetrics = {
   reachability_vmn_tcp_failed: number;
   reachability_vmn_xtls_success: number;
   reachability_vmn_xtls_failed: number;
+  natType: NatType;
 };
 
 /**

package/src/reachability/request.ts

@@ -45,6 +45,9 @@ class ReachabilityRequest {
     joinCookie: any;
     discoveryOptions?: Record<string, any>;
   }> => {
+    const appType = this.webex?.config?.support?.appType;
+    const appVersion = this.webex?.config?.support?.appVersion;
+
     // we only measure latency for the initial startup call, not for other triggers
     const callWrapper =
       trigger === 'startup'
@@ -67,6 +70,10 @@ class ReachabilityRequest {
               'early-call-min-clusters': true,
             },
             'previous-report': previousReport,
+            ...(appType &&
+              appVersion && {
+                'client-environment': {components: {[appType]: appVersion}},
+              }),
             trigger,
           },
           timeout: this.webex.config.meetings.reachabilityGetClusterTimeout,

package/src/recording-controller/util.ts

@@ -6,33 +6,37 @@ const canUserStart = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const canUserPause = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const canUserResume = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const canUserStop = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) ||
-    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies)) ||
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) &&
+    MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies));
 
 const isPremiseRecordingEnabled = (
   displayHints: Array<string>,
@@ -42,7 +46,7 @@ const isPremiseRecordingEnabled = (
     displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) ||
     displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) ||
     displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
-  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_PREMISE_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
   return url?.split('/').pop();

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

@@ -22,16 +22,54 @@ describe('plugin-meetings', () => {
     });
 
     describe('#initialize', () => {
+      beforeEach(() => {
+        interpretation.querySupportLanguages = sinon.stub();
+        interpretation.set({
+          canManageInterpreters: undefined,
+          hostSIEnabled: undefined,
+          locusUrl: undefined
+        });
+      });
+
+      afterEach(() => {
+        interpretation.querySupportLanguages.reset();
+      });
+
       it('creates SimultaneousInterpretation as expected', () => {
         assert.equal(interpretation.namespace, 'Meetings');
       });
       it('call querySupportLanguages correctly when meet the conditions', () => {
-        interpretation.querySupportLanguages = sinon.stub();
         interpretation.set({
           canManageInterpreters: true,
+          hostSIEnabled: true,
+          locusUrl: "MOCK_LOCUS_URL"
         });
         assert.called(interpretation.querySupportLanguages);
       });
+
+      it('does not call querySupportLanguages when canManageInterpreters is not set', () => {
+        interpretation.set({
+          hostSIEnabled: true,
+          locusUrl: "MOCK_LOCUS_URL"
+        });
+        assert.notCalled(interpretation.querySupportLanguages);
+      });
+
+      it('does not call querySupportLanguages when hostSIEnabled is not set', () => {
+        interpretation.set({
+          canManageInterpreters: true,
+          locusUrl: "MOCK_LOCUS_URL"
+        });
+        assert.notCalled(interpretation.querySupportLanguages);
+      });
+
+      it('does not call querySupportLanguages when locusUrl is not set', () => {
+        interpretation.set({
+          canManageInterpreters: true,
+          hostSIEnabled: true,
+        });
+        assert.notCalled(interpretation.querySupportLanguages);
+      });
     });
 
     describe('#cleanUp', () => {

package/test/unit/spec/locus-info/controlsUtils.js

@@ -269,6 +269,14 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasPracticeSessionEnabledChanged, true);
       });
 
+      it('returns hasPracticeSessionEnabledChanged = false when enabled is false and previous state is false', () => {
+        const newControls = {practiceSession: {enabled: false}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasPracticeSessionEnabledChanged, false);
+      });
+
       it('returns hasEntryExitToneChanged = true when mode changed', () => {
         const newControls = {
           entryExitTone: {