@webex/plugin-meetings 3.0.0-next.23 → 3.0.0-next.25

package/src/reachability/clusterReachability.ts

@@ -2,7 +2,7 @@ import {Defer} from '@webex/common';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClusterNode} from './request';
-import {convertStunUrlToTurn} from './util';
+import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 
 import {ICE_GATHERING_STATE, CONNECTION_STATE} from '../constants';
 
@@ -29,6 +29,7 @@ export type ClusterReachabilityResult = {
 export class ClusterReachability {
   private numUdpUrls: number;
   private numTcpUrls: number;
+  private numXTlsUrls: number;
   private result: ClusterReachabilityResult;
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
@@ -46,6 +47,7 @@ export class ClusterReachability {
     this.isVideoMesh = clusterInfo.isVideoMesh;
     this.numUdpUrls = clusterInfo.udp.length;
     this.numTcpUrls = clusterInfo.tcp.length;
+    this.numXTlsUrls = clusterInfo.xtls.length;
 
     this.pc = this.createPeerConnection(clusterInfo);
 
@@ -94,8 +96,16 @@ export class ClusterReachability {
       };
     });
 
+    const turnTlsIceServers = cluster.xtls.map((urlString: string) => {
+      return {
+        username: 'webexturnreachuser',
+        credential: 'webexturnreachpwd',
+        urls: [convertStunUrlToTurnTls(urlString)],
+      };
+    });
+
     return {
-      iceServers: [...udpIceServers, ...tcpIceServers],
+      iceServers: [...udpIceServers, ...tcpIceServers, ...turnTlsIceServers],
       iceCandidatePoolSize: 0,
       iceTransportPolicy: 'all',
     };
@@ -194,7 +204,7 @@ export class ClusterReachability {
    * @returns {boolean} true if we have all results, false otherwise
    */
   private haveWeGotAllResults(): boolean {
-    return ['udp', 'tcp'].every(
+    return ['udp', 'tcp', 'xtls'].every(
       (protocol) =>
         this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
     );
@@ -207,7 +217,7 @@ export class ClusterReachability {
    * @param {number} latency
    * @returns {void}
    */
-  private storeLatencyResult(protocol: 'udp' | 'tcp', latency: number) {
+  private storeLatencyResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -227,6 +237,7 @@ export class ClusterReachability {
    */
   private registerIceCandidateListener() {
     this.pc.onicecandidate = (e) => {
+      const TURN_TLS_PORT = 443;
       const CANDIDATE_TYPES = {
         SERVER_REFLEXIVE: 'srflx',
         RELAY: 'relay',
@@ -239,7 +250,8 @@ export class ClusterReachability {
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
-          this.storeLatencyResult('tcp', this.getElapsedTime());
+          const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
+          this.storeLatencyResult(protocol, this.getElapsedTime());
           // we don't add public IP for TCP, because in the case of relay candidates
           // e.candidate.address is the TURN server address, not the client's public IP
         }
@@ -275,6 +287,9 @@ export class ClusterReachability {
     this.result.tcp = {
       result: this.numTcpUrls > 0 ? 'unreachable' : 'untested',
     };
+    this.result.xtls = {
+      result: this.numXTlsUrls > 0 ? 'unreachable' : 'untested',
+    };
 
     try {
       const offer = await this.pc.createOffer({offerToReceiveAudio: true});

package/src/reachability/index.ts

@@ -22,10 +22,14 @@ export type ReachabilityMetrics = {
   reachability_public_udp_failed: number;
   reachability_public_tcp_success: number;
   reachability_public_tcp_failed: number;
+  reachability_public_xtls_success: number;
+  reachability_public_xtls_failed: number;
   reachability_vmn_udp_success: number;
   reachability_vmn_udp_failed: number;
   reachability_vmn_tcp_success: number;
   reachability_vmn_tcp_failed: number;
+  reachability_vmn_xtls_success: number;
+  reachability_vmn_xtls_failed: number;
 };
 
 /**
@@ -141,10 +145,14 @@ export default class Reachability {
       reachability_public_udp_failed: 0,
       reachability_public_tcp_success: 0,
       reachability_public_tcp_failed: 0,
+      reachability_public_xtls_success: 0,
+      reachability_public_xtls_failed: 0,
       reachability_vmn_udp_success: 0,
       reachability_vmn_udp_failed: 0,
       reachability_vmn_tcp_success: 0,
       reachability_vmn_tcp_failed: 0,
+      reachability_vmn_xtls_success: 0,
+      reachability_vmn_xtls_failed: 0,
     };
 
     const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
@@ -156,6 +164,10 @@ export default class Reachability {
         const outcome = result.tcp.result === 'reachable' ? 'success' : 'failed';
         stats[`reachability_${clusterType}_tcp_${outcome}`] += 1;
       }
+      if (result.xtls && result.xtls.result !== 'untested') {
+        const outcome = result.xtls.result === 'reachable' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_xtls_${outcome}`] += 1;
+      }
     };
 
     try {
@@ -338,7 +350,10 @@ export default class Reachability {
     LoggerProxy.logger.log(
       `Reachability:index#performReachabilityChecks --> doing UDP${
         // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability ? ' and TCP' : ''
+        this.webex.config.meetings.experimental.enableTcpReachability ? ',TCP' : ''
+      }${
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTlsReachability ? ',TLS' : ''
       } reachability checks`
     );
 
@@ -354,6 +369,14 @@ export default class Reachability {
         cluster.tcp = [];
       }
 
+      const includeTlsReachability =
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
+
+      if (!includeTlsReachability) {
+        cluster.xtls = [];
+      }
+
       this.clusterReachability[key] = new ClusterReachability(key, cluster);
 
       return this.clusterReachability[key].start().then((result) => {

package/src/reachability/util.ts

@@ -22,3 +22,24 @@ export function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp') {
 
   return url.toString();
 }
+
+/**
+ * Converts a stun url to a turns url
+ *
+ * @param {string} stunUrl url of a stun server
+ * @returns {string} url of a turns server
+ */
+export function convertStunUrlToTurnTls(stunUrl: string) {
+  // stunUrl looks like this: "stun:external-media1.public.wjfkm-a-15.prod.infra.webex.com:443"
+  // and we need it to be like this: "turns:external-media1.public.wjfkm-a-15.prod.infra.webex.com:443?transport=tcp"
+  const url = new URL(stunUrl);
+
+  if (url.protocol !== 'stun:') {
+    throw new Error(`Not a STUN URL: ${stunUrl}`);
+  }
+
+  url.protocol = 'turns:';
+  url.searchParams.append('transport', 'tcp');
+
+  return url.toString();
+}

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

@@ -1011,15 +1011,14 @@ describe('plugin-meetings', () => {
       });
 
       describe('transcription events', () => {
+        beforeEach(() => {
+          meeting.trigger = sinon.stub();
+        });
+
         it('should trigger meeting:caption-received event', () => {
           meeting.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]({});
           assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'setUpVoiceaListeners',
-            },
+            meeting.trigger,
             EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED
           );
         });
@@ -1027,12 +1026,7 @@ describe('plugin-meetings', () => {
         it('should trigger meeting:receiveTranscription:started event', () => {
           meeting.voiceaListenerCallbacks[VOICEAEVENTS.VOICEA_ANNOUNCEMENT]({});
           assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'setUpVoiceaListeners',
-            },
+            meeting.trigger,
             EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION
           );
         });
@@ -1040,12 +1034,7 @@ describe('plugin-meetings', () => {
         it('should trigger meeting:caption-received event', () => {
           meeting.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]({});
           assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'setUpVoiceaListeners',
-            },
+            meeting.trigger,
             EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED
           );
         });

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

@@ -253,6 +253,19 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleTlsReachability', () => {
+      it('should have _toggleTlsReachability', () => {
+        assert.equal(typeof webex.meetings._toggleTlsReachability, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to do TLS reachability', () => {
+          webex.meetings._toggleTlsReachability(true);
+          assert.equal(webex.meetings.config.experimental.enableTlsReachability, true);
+        });
+      });
+    });
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', async () => {

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

@@ -4,7 +4,7 @@ import sinon from 'sinon';
 import testUtils from '../../../utils/testUtils';
 
 // packages/@webex/plugin-meetings/test/unit/spec/reachability/clusterReachability.ts
-import { ClusterReachability } from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+import {ClusterReachability} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -28,9 +28,8 @@ describe('ClusterReachability', () => {
       isVideoMesh: false,
       udp: ['stun:udp1', 'stun:udp2'],
       tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-      xtls: ['xtls1', 'xtls2'],
+      xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
-
   });
 
   afterEach(() => {
@@ -50,8 +49,26 @@ describe('ClusterReachability', () => {
       iceServers: [
         {username: '', credential: '', urls: ['stun:udp1']},
         {username: '', credential: '', urls: ['stun:udp2']},
-        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp1.webex.com?transport=tcp']},
-        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp2.webex.com:5004?transport=tcp']}
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turn:tcp1.webex.com?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turn:tcp2.webex.com:5004?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turns:xtls1.webex.com?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turns:xtls2.webex.com:443?transport=tcp'],
+        },
       ],
       iceCandidatePoolSize: 0,
       iceTransportPolicy: 'all',
@@ -79,7 +96,7 @@ describe('ClusterReachability', () => {
     assert.deepEqual(clusterReachability.getResult(), {
       udp: {result: 'untested'},
       tcp: {result: 'untested'},
-      xtls: {result: 'untested'}
+      xtls: {result: 'untested'},
     });
   });
 
@@ -92,7 +109,7 @@ describe('ClusterReachability', () => {
 
     afterEach(() => {
       clock.restore();
-    })
+    });
 
     it('should initiate the ICE gathering process', async () => {
       const promise = clusterReachability.start();
@@ -107,11 +124,11 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      await clock.tickAsync(3000); // move the clock so that reachability times out
       await promise;
     });
 
-    it('resolves and has correct result as soon as it finds that both udp and tcp is reachable', async () => {
+    it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
       const promise = clusterReachability.start();
 
       await clock.tickAsync(100);
@@ -120,12 +137,17 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
 
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
         tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'untested'}
+        xtls: {result: 'reachable', latencyInMilliseconds: 300},
       });
     });
 
@@ -139,7 +161,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -148,7 +170,7 @@ describe('ClusterReachability', () => {
         isVideoMesh: true,
         udp: ['stun:udp1', 'stun:udp2'],
         tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-        xtls: ['xtls1', 'xtls2'],
+        xtls: ['stun:xtls1.webex.com', 'stun:xtls1.webex.com:443'],
       });
 
       const promise = clusterReachability.start();
@@ -160,7 +182,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -176,7 +198,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -194,7 +216,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -211,15 +233,19 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      await clock.tickAsync(3000); // move the clock so that reachability times out
 
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
       assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3']},
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3'],
+        },
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -236,7 +262,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      await clock.tickAsync(3000); // move the clock so that reachability times out
 
       await promise;
 
@@ -244,7 +270,38 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'reachable', latencyInMilliseconds: 10},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
+      });
+    });
+
+    it('should store latency only for the first tls relay candidate', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp1', port: 443},
+      });
+
+      // generate more candidates
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp2', port: 443},
+      });
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp3', port: 443},
+      });
+
+      await clock.tickAsync(3000); // move the clock so that reachability times out
+
+      await promise;
+
+      // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'reachable', latencyInMilliseconds: 10},
       });
     });
 
@@ -266,13 +323,20 @@ describe('ClusterReachability', () => {
 
       // 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', 'somePublicIp2']},
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1', 'somePublicIp2'],
+        },
         tcp: {result: 'reachable', latencyInMilliseconds: 40},
-        xtls: {result: 'untested'}
+        xtls: {result: 'reachable', latencyInMilliseconds: 40},
       });
     });
   });