@webex/plugin-meetings 3.8.0-next.14 → 3.8.0-next.16

package/dist/types/reachability/clusterReachability.d.ts

@@ -1,7 +1,7 @@
 import { ClusterNode } from './request';
 import EventsScope from '../common/events/events-scope';
 import { Enum } from '../constants';
-import { ClusterReachabilityResult } from './reachability.types';
+import { ClusterReachabilityResult, NatType } from './reachability.types';
 export type ResultEventData = {
     protocol: 'udp' | 'tcp' | 'xtls';
     result: 'reachable' | 'unreachable' | 'untested';
@@ -12,9 +12,13 @@ export type ClientMediaIpsUpdatedEventData = {
     protocol: 'udp' | 'tcp' | 'xtls';
     clientMediaIPs: string[];
 };
+export type NatTypeUpdatedEventData = {
+    natType: NatType;
+};
 export declare const Events: {
     readonly resultReady: "resultReady";
     readonly clientMediaIpsUpdated: "clientMediaIpsUpdated";
+    readonly natTypeUpdated: "natTypeUpdated";
 };
 export type Events = Enum<typeof Events>;
 /**
@@ -29,6 +33,7 @@ export declare class ClusterReachability extends EventsScope {
     private pc?;
     private defer;
     private startTimestamp;
+    private srflxIceCandidates;
     readonly isVideoMesh: boolean;
     readonly name: any;
     /**
@@ -107,6 +112,13 @@ export declare class ClusterReachability extends EventsScope {
      * @returns {void}
      */
     private saveResult;
+    /**
+     * Determines NAT Type.
+     *
+     * @param {RTCIceCandidate} candidate
+     * @returns {void}
+     */
+    private determineNatType;
     /**
      * Registers a listener for the icecandidate event
      *

package/dist/types/reachability/index.d.ts

@@ -4,7 +4,7 @@
 import { Defer } from '@webex/common';
 import { IP_VERSION } from '../constants';
 import ReachabilityRequest, { ClusterList } from './request';
-import { ClusterReachabilityResult, ClientMediaPreferences, ReachabilityMetrics, ReachabilityReportV0, ReachabilityReportV1, ReachabilityResults, ReachabilityResultsForBackend, GetClustersTrigger } from './reachability.types';
+import { ClusterReachabilityResult, ClientMediaPreferences, ReachabilityMetrics, ReachabilityReportV0, ReachabilityReportV1, ReachabilityResults, ReachabilityResultsForBackend, GetClustersTrigger, NatType } from './reachability.types';
 import { ClusterReachability } from './clusterReachability';
 import EventsScope from '../common/events/events-scope';
 /**
@@ -46,6 +46,7 @@ export default class Reachability extends EventsScope {
     };
     startTime: any;
     totalDuration: any;
+    natType: NatType;
     protected lastTrigger?: string;
     /**
      * Creates an instance of Reachability.

package/dist/types/reachability/reachability.types.d.ts

@@ -4,6 +4,10 @@ export type TransportResult = {
     latencyInMilliseconds?: number;
     clientMediaIPs?: string[];
 };
+export declare enum NatType {
+    Unknown = "unknown",
+    SymmetricNat = "symmetric-nat"
+}
 export type ClusterReachabilityResult = {
     udp: TransportResult;
     tcp: TransportResult;
@@ -22,6 +26,7 @@ export type ReachabilityMetrics = {
     reachability_vmn_tcp_failed: number;
     reachability_vmn_xtls_success: number;
     reachability_vmn_xtls_failed: number;
+    natType: NatType;
 };
 /**
  * This is the type that matches what backend expects us to send to them. It is a bit weird, because

package/dist/webinar/index.js

@@ -458,7 +458,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee7);
     }))();
   },
-  version: "3.8.0-next.14"
+  version: "3.8.0-next.16"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,13 +43,13 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.8.0-next.14",
-    "@webex/plugin-rooms": "3.8.0-next.8",
-    "@webex/test-helper-chai": "3.8.0-next.7",
-    "@webex/test-helper-mocha": "3.8.0-next.7",
-    "@webex/test-helper-mock-webex": "3.8.0-next.7",
-    "@webex/test-helper-retry": "3.8.0-next.7",
-    "@webex/test-helper-test-users": "3.8.0-next.7",
+    "@webex/plugin-meetings": "3.8.0-next.16",
+    "@webex/plugin-rooms": "3.8.0-next.9",
+    "@webex/test-helper-chai": "3.8.0-next.8",
+    "@webex/test-helper-mocha": "3.8.0-next.8",
+    "@webex/test-helper-mock-webex": "3.8.0-next.8",
+    "@webex/test-helper-retry": "3.8.0-next.8",
+    "@webex/test-helper-test-users": "3.8.0-next.8",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -61,22 +61,22 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.8.0-next.7",
+    "@webex/common": "3.8.0-next.8",
     "@webex/event-dictionary-ts": "^1.0.1688",
     "@webex/internal-media-core": "2.14.4",
-    "@webex/internal-plugin-conversation": "3.8.0-next.8",
-    "@webex/internal-plugin-device": "3.8.0-next.7",
-    "@webex/internal-plugin-llm": "3.8.0-next.9",
-    "@webex/internal-plugin-mercury": "3.8.0-next.8",
-    "@webex/internal-plugin-metrics": "3.8.0-next.7",
-    "@webex/internal-plugin-support": "3.8.0-next.8",
-    "@webex/internal-plugin-user": "3.8.0-next.7",
-    "@webex/internal-plugin-voicea": "3.8.0-next.14",
-    "@webex/media-helpers": "3.8.0-next.7",
-    "@webex/plugin-people": "3.8.0-next.8",
-    "@webex/plugin-rooms": "3.8.0-next.8",
+    "@webex/internal-plugin-conversation": "3.8.0-next.9",
+    "@webex/internal-plugin-device": "3.8.0-next.8",
+    "@webex/internal-plugin-llm": "3.8.0-next.10",
+    "@webex/internal-plugin-mercury": "3.8.0-next.9",
+    "@webex/internal-plugin-metrics": "3.8.0-next.8",
+    "@webex/internal-plugin-support": "3.8.0-next.9",
+    "@webex/internal-plugin-user": "3.8.0-next.8",
+    "@webex/internal-plugin-voicea": "3.8.0-next.16",
+    "@webex/media-helpers": "3.8.0-next.8",
+    "@webex/plugin-people": "3.8.0-next.9",
+    "@webex/plugin-rooms": "3.8.0-next.9",
     "@webex/web-capabilities": "^1.4.0",
-    "@webex/webex-core": "3.8.0-next.7",
+    "@webex/webex-core": "3.8.0-next.8",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -92,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.8.0-next.14"
+  "version": "3.8.0-next.16"
 }

package/src/meeting/index.ts

@@ -1686,6 +1686,19 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.#isoLocalClientMeetingJoinTime;
   }
 
+  /**
+   * Setter - sets isoLocalClientMeetingJoinTime
+   * This will be set once on meeting join, and not updated again
+   * @param {string | undefined} time in ISO format
+   */
+  set isoLocalClientMeetingJoinTime(time: string | undefined) {
+    if (!time) {
+      this.#isoLocalClientMeetingJoinTime = new Date().toISOString();
+    } else {
+      this.#isoLocalClientMeetingJoinTime = time;
+    }
+  }
+
   /**
    * Set meeting info and trigger `MEETING_INFO_AVAILABLE` event
    * @param {any} info
@@ -5718,8 +5731,6 @@ export default class Meeting extends StatelessWebexPlugin {
         // @ts-ignore
         this.webex.internal.device.meetingStarted();
 
-        this.#isoLocalClientMeetingJoinTime = new Date().toISOString();
-
         LoggerProxy.logger.log('Meeting:index#join --> Success');
 
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.JOIN_SUCCESS, {

package/src/meeting/util.ts

@@ -180,7 +180,7 @@ const MeetingUtil = {
       .then((res) => {
         const parsed = MeetingUtil.parseLocusJoin(res);
         meeting.setLocus(parsed);
-
+        meeting.isoLocalClientMeetingJoinTime = res?.headers?.date; // read from header if exist, else fall back to system clock : https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-555657
         webex.internal.newMetrics.submitClientEvent({
           name: 'client.locus.join.response',
           payload: {

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;
 
@@ -309,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) => {
@@ -967,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/test/unit/spec/meeting/index.js

@@ -210,6 +210,7 @@ describe('plugin-meetings', () => {
   let membersSpy;
   let meetingRequestSpy;
   let correlationId;
+  let isoLocalClientMeetingJoinTime;
   let uploadEvent;
 
   beforeEach(() => {
@@ -1692,10 +1693,6 @@ describe('plugin-meetings', () => {
             sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
           });
 
-          afterEach(() => {
-            assert.exists(meeting.isoLocalClientMeetingJoinTime);
-          });
-
           it('should join the meeting and return promise', async () => {
             const join = meeting.join({pstnAudioType: 'dial-in'});
             meeting.config.enableAutomaticLLM = true;
@@ -7530,6 +7527,25 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#setIsoLocalClientMeetingJoinTime', () => {
+        it('should set the isoLocalClientMeetingJoinTime when passed in', () => {
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, isoLocalClientMeetingJoinTime);
+          meeting.isoLocalClientMeetingJoinTime = 'test';
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, 'test');
+          meeting.isoLocalClientMeetingJoinTime = 'test2';
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, 'test2');
+        });
+
+        it('should set the isoLocalClientMeetingJoin time once and only once when not passed in', () => {
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, isoLocalClientMeetingJoinTime);
+          meeting.isoLocalClientMeetingJoinTime = undefined;
+          const time = meeting.isoLocalClientMeetingJoinTime;
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, time);
+          meeting.isoLocalClientMeetingJoinTime = 'test2';
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, 'test2');
+        });
+      });
+
       describe('#updateCallStateForMetrics', () => {
         it('should update the callState, overriding existing values', () => {
           assert.deepEqual(meeting.callStateForMetrics, {correlationId, sessionCorrelationId: ''});

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

@@ -460,6 +460,50 @@ describe('plugin-meetings', () => {
         });
       });
 
+
+      it('#Should call `meetingRequest.joinMeeting and handle a date header in the response : isoLocalClientMeetingJoinedTime', async () => {
+        meeting.isMultistream = true;
+
+        const FAKE_REACHABILITY_REPORT = {
+          id: 'fake reachability report',
+        };
+        const FAKE_CLIENT_MEDIA_PREFERENCES = {
+          id: 'fake client media preferences',
+        };
+
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
+        webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
+
+        sinon
+          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+          .get(() => true);
+        sinon
+          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+          .get(() => true);
+
+        meeting.meetingRequest.joinMeeting.resolves({
+          headers: {
+            date: 'test'
+          },
+          body: {
+            mediaConnections: [{mediaId: 'test'}],
+            locus: {
+              url: 'test',
+              self: {
+                id: 'test'
+              }
+            }
+          }
+        })
+
+        await MeetingUtil.joinMeeting(meeting, {
+          reachability: 'reachability',
+          roapMessage: 'roapMessage',
+        });
+
+        assert.equal(meeting.isoLocalClientMeetingJoinTime, 'test');
+      });
+
       it('should handle failed reachability report retrieval', async () => {
         webex.meetings.reachability.getReachabilityReportToAttachToRoap.rejects(
           new Error('fake error')

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

@@ -9,7 +9,9 @@ import {
   ResultEventData,
   Events,
   ClientMediaIpsUpdatedEventData,
+  NatTypeUpdatedEventData,
 } from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+import { NatType } from 'packages/@webex/plugin-meetings/dist/reachability/reachability.types';
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -17,15 +19,17 @@ describe('ClusterReachability', () => {
   let fakePeerConnection;
   let gatherIceCandidatesSpy;
 
-  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
+  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData | NatTypeUpdatedEventData)[]> = {
     [Events.resultReady]: [],
     [Events.clientMediaIpsUpdated]: [],
+    [Events.natTypeUpdated]: [],
   };
   const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
 
   const resetEmittedEvents = () => {
     emittedEvents[Events.resultReady].length = 0;
     emittedEvents[Events.clientMediaIpsUpdated].length = 0;
+    emittedEvents[Events.natTypeUpdated].length = 0;
   };
   beforeEach(() => {
     fakePeerConnection = {
@@ -56,6 +60,10 @@ describe('ClusterReachability', () => {
     clusterReachability.on(Events.clientMediaIpsUpdated, (data: ClientMediaIpsUpdatedEventData) => {
       emittedEvents[Events.clientMediaIpsUpdated].push(data);
     });
+
+    clusterReachability.on(Events.natTypeUpdated, (data: NatTypeUpdatedEventData) => {
+      emittedEvents[Events.natTypeUpdated].push(data);
+    });
   });
 
   afterEach(() => {
@@ -440,5 +448,43 @@ describe('ClusterReachability', () => {
         xtls: {result: 'reachable', latencyInMilliseconds: 40},
       });
     });
+
+    it('determines correctly if symmetric-nat is detected', async () => {
+      const promise = clusterReachability.start();
+
+      // generate candidates with duplicate addresses
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', relatedPort: 3478, port: 1000}});
+
+      // check events emitted: there shouldn't be any natTypeUpdated emitted
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 0);
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', relatedPort: 3478, port: 2000}});
+
+      // should emit natTypeUpdated event
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.natTypeUpdated][0], {
+        natType: 'symmetric-nat',
+      });
+
+      // send also a relay candidate so that the reachability check finishes
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
+
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1'],
+        },
+        tcp: {result: 'reachable', latencyInMilliseconds: 20},
+        xtls: {result: 'reachable', latencyInMilliseconds: 20},
+      });
+    });
   });
 });

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

@@ -2156,6 +2156,7 @@ describe('getReachabilityMetrics', () => {
       reachability_vmn_tcp_failed: 0,
       reachability_vmn_xtls_success: 0,
       reachability_vmn_xtls_failed: 0,
+      natType: 'unknown'
     });
   });
 
@@ -2223,6 +2224,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 1,
         reachability_vmn_xtls_success: 0,
         reachability_vmn_xtls_failed: 0,
+        natType: 'unknown'
       }
     );
   });
@@ -2284,6 +2286,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 0,
         reachability_vmn_xtls_success: 0,
         reachability_vmn_xtls_failed: 0,
+        natType: 'unknown'
       }
     );
   });
@@ -2345,6 +2348,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 3,
         reachability_vmn_xtls_success: 1,
         reachability_vmn_xtls_failed: 1,
+        natType: 'unknown'
       }
     );
   });