@webex/plugin-meetings 2.24.1 → 2.26.0

package/src/roap/turnDiscovery.ts

@@ -0,0 +1,238 @@
+import {Defer} from '@webex/common';
+
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {ROAP} from '../constants';
+
+import RoapRequest from './request';
+
+const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
+
+/**
+ * Handles the process of finding out TURN server information from Linus.
+ * This is achieved by sending a TURN_DISCOVERY_REQUEST.
+ */
+export default class TurnDiscovery {
+  private roapRequest: RoapRequest;
+
+  private defer?: Defer; // used for waiting for the response
+
+  private turnInfo: {
+    url: string;
+    username: string;
+    password: string;
+  };
+
+  private responseTimer?: ReturnType<typeof setTimeout>;
+
+  /**
+   * Constructor
+   *
+   * @param {RoapRequest} roapRequest
+   */
+  constructor(roapRequest: RoapRequest) {
+    this.roapRequest = roapRequest;
+    this.turnInfo = {
+      url: '',
+      username: '',
+      password: '',
+    };
+  }
+
+
+  /**
+   * waits for TURN_DISCOVERY_RESPONSE message to arrive
+   *
+   * @returns {Promise}
+   * @private
+   * @memberof Roap
+   */
+  waitForTurnDiscoveryResponse() {
+    if (!this.defer) {
+      LoggerProxy.logger.warn('Roap:turnDiscovery#waitForTurnDiscoveryResponse --> TURN discovery is not in progress');
+
+      return Promise.reject(new Error('waitForTurnDiscoveryResponse() called before sendRoapTurnDiscoveryRequest()'));
+    }
+
+    const {defer} = this;
+
+    this.responseTimer = setTimeout(() => {
+      LoggerProxy.logger.warn(`Roap:turnDiscovery#waitForTurnDiscoveryResponse --> timeout! no response arrived within ${TURN_DISCOVERY_TIMEOUT} seconds`);
+
+      defer.reject(new Error('Timed out waiting for TURN_DISCOVERY_RESPONSE'));
+    }, TURN_DISCOVERY_TIMEOUT * 1000);
+
+    LoggerProxy.logger.info('Roap:turnDiscovery#waitForTurnDiscoveryResponse --> waiting for TURN_DISCOVERY_RESPONSE...');
+
+    return defer.promise;
+  }
+
+  /**
+   * handles TURN_DISCOVERY_RESPONSE roap message
+   *
+   * @param {Object} roapMessage
+   * @returns {void}
+   * @public
+   * @memberof Roap
+   */
+  handleTurnDiscoveryResponse(roapMessage) {
+    const {headers} = roapMessage;
+
+    if (!this.defer) {
+      LoggerProxy.logger.warn('Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response');
+
+      return;
+    }
+
+    const expectedHeaders = [
+      {headerName: 'x-cisco-turn-url', field: 'url'},
+      {headerName: 'x-cisco-turn-username', field: 'username'},
+      {headerName: 'x-cisco-turn-password', field: 'password'},
+    ];
+
+    let foundHeaders = 0;
+
+    headers?.forEach((receivedHeader) => {
+      // check if it matches any of our expected headers
+      expectedHeaders.forEach((expectedHeader) => {
+        if (receivedHeader.startsWith(`${expectedHeader.headerName}=`)) {
+          this.turnInfo[expectedHeader.field] = receivedHeader.substring(expectedHeader.headerName.length + 1);
+          foundHeaders += 1;
+        }
+      });
+    });
+
+    clearTimeout(this.responseTimer);
+    this.responseTimer = undefined;
+
+    if (foundHeaders !== expectedHeaders.length) {
+      LoggerProxy.logger.warn(`Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received: ${JSON.stringify(headers)}`);
+      this.defer.reject(new Error(`TURN_DISCOVERY_RESPONSE missing some headers: ${JSON.stringify(headers)}`));
+    }
+    else {
+      LoggerProxy.logger.info(`Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response, url=${this.turnInfo.url}`);
+      this.defer.resolve();
+    }
+  }
+
+  /**
+   * sends the TURN_DISCOVERY_REQUEST roap request
+   *
+   * @param {Meeting} meeting
+   * @param {Boolean} isReconnecting
+   * @returns {Promise}
+   * @private
+   * @memberof Roap
+   */
+  sendRoapTurnDiscoveryRequest(meeting, isReconnecting) {
+    const seq = meeting.roapSeq + 1;
+
+    if (this.defer) {
+      LoggerProxy.logger.warn('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress');
+
+      return Promise.resolve();
+    }
+
+    this.defer = new Defer();
+
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
+      version: ROAP.ROAP_VERSION,
+      seq,
+    };
+
+    LoggerProxy.logger.info('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> sending TURN_DISCOVERY_REQUEST');
+
+    return this.roapRequest
+      .sendRoap({
+        roapMessage,
+        correlationId: meeting.correlationId,
+        locusSelfUrl: meeting.selfUrl,
+        mediaId: isReconnecting ? '' : meeting.mediaId,
+        audioMuted: meeting.isAudioMuted(),
+        videoMuted: meeting.isVideoMuted(),
+        meetingId: meeting.id
+      })
+      .then(({mediaConnections}) => {
+        meeting.setRoapSeq(seq);
+
+        if (mediaConnections) {
+          meeting.updateMediaConnections(mediaConnections);
+        }
+      });
+  }
+
+  /**
+   * Sends the OK message that server expects to receive
+   * after it sends us TURN_DISCOVERY_RESPONSE
+   *
+   * @param {Meeting} meeting
+   * @returns {Promise}
+   */
+  sendRoapOK(meeting) {
+    LoggerProxy.logger.info('Roap:turnDiscovery#sendRoapOK --> sending OK');
+
+    return this.roapRequest.sendRoap({
+      roapMessage: {
+        messageType: ROAP.ROAP_TYPES.OK,
+        version: ROAP.ROAP_VERSION,
+        seq: meeting.roapSeq
+      },
+      locusSelfUrl: meeting.selfUrl,
+      mediaId: meeting.mediaId,
+      correlationId: meeting.correlationId,
+      audioMuted: meeting.isAudioMuted(),
+      videoMuted: meeting.isVideoMuted(),
+      meetingId: meeting.id
+    });
+  }
+
+  /**
+   * Retrieves TURN server information from the backend by doing
+   * a roap message exchange:
+   * client                             server
+   *  | -----TURN_DISCOVERY_REQUEST-----> |
+   *  | <----TURN_DISCOVERY_RESPONSE----- |
+   *  | --------------OK----------------> |
+   *
+   * @param {Meeting} meeting
+   * @param {Boolean} isReconnecting should be set to true if this is a new
+   *                                 media connection just after a reconnection
+   * @returns {Promise}
+   */
+  doTurnDiscovery(meeting, isReconnecting) {
+    if (!meeting.config.experimental.enableTurnDiscovery) {
+      LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it');
+
+      return Promise.resolve(undefined);
+    }
+
+    return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
+      .then(() => this.waitForTurnDiscoveryResponse())
+      .then(() => this.sendRoapOK(meeting))
+      .then(() => {
+        this.defer = undefined;
+
+        LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+
+        return this.turnInfo;
+      })
+      .catch((e) => {
+        // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
+        LoggerProxy.logger.info(`Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`);
+
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE,
+          {
+            correlation_id: meeting.correlationId,
+            locus_id: meeting.locusUrl.split('/').pop(),
+            reason: e.message,
+            stack: e.stack
+          }
+        );
+
+        return Promise.resolve(undefined);
+      });
+  }
+}

package/src/roap/util.js

@@ -80,8 +80,6 @@ RoapUtil.setRemoteDescription = (meeting, session) => {
 
     return {
       seq: session.ANSWER.seq,
-      locusId: meeting.locusId,
-      locusSelfId: meeting.locusInfo.self.id,
       mediaId: meeting.mediaId,
       correlationId: meeting.correlationId
     };

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

@@ -893,6 +893,7 @@ describe('plugin-meetings', () => {
             meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
             resolve();
           }));
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves();
           PeerConnectionManager.setContentSlides = sinon.stub().returns(true);
         });
 
@@ -1008,22 +1009,56 @@ describe('plugin-meetings', () => {
 
         it('should attach the media and return promise', async () => {
           meeting.meetingState = 'ACTIVE';
+          MediaUtil.createPeerConnection.resetHistory();
           const media = meeting.addMedia({
             mediaSettings: {}
           });
 
           assert.exists(media);
           await media;
+          assert.calledOnce(meeting.roap.doTurnDiscovery);
+          assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
           assert.calledOnce(meeting.mediaProperties.setMediaDirection);
           assert.calledOnce(Media.attachMedia);
           assert.calledOnce(meeting.setMercuryListener);
           assert.calledOnce(meeting.setRemoteStream);
           assert.calledOnce(meeting.roap.sendRoapMediaRequest);
+          assert.calledOnce(MediaUtil.createPeerConnection);
+          assert.calledWith(MediaUtil.createPeerConnection, undefined);
           /* statsAnalyzer is initiated inside of addMedia so there isn't
           * a good way to mock it without mocking the constructor
           */
         });
 
+        it('should pass the turn server info to the peer connection', async () => {
+          const FAKE_TURN_URL = 'turns:webex.com:3478';
+          const FAKE_TURN_USER = 'some-turn-username';
+          const FAKE_TURN_PASSWORD = 'some-password';
+
+          meeting.meetingState = 'ACTIVE';
+          MediaUtil.createPeerConnection.resetHistory();
+
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({
+            url: FAKE_TURN_URL,
+            username: FAKE_TURN_USER,
+            password: FAKE_TURN_PASSWORD
+          });
+          const media = meeting.addMedia({
+            mediaSettings: {}
+          });
+
+          assert.exists(media);
+          await media;
+          assert.calledOnce(meeting.roap.doTurnDiscovery);
+          assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
+          assert.calledOnce(MediaUtil.createPeerConnection);
+          assert.calledWith(MediaUtil.createPeerConnection, {
+            url: FAKE_TURN_URL,
+            username: FAKE_TURN_USER,
+            password: FAKE_TURN_PASSWORD
+          });
+        });
+
         it('should attach the media and return promise', async () => {
           meeting.meetingState = 'ACTIVE';
           meeting.mediaProperties.peerConnection.connectionState = 'DISCONNECTED';
@@ -1948,6 +1983,18 @@ describe('plugin-meetings', () => {
             assert.isRejected(meeting.changeVideoLayout(layoutType));
           });
 
+          it('should send no layoutType when layoutType is not provided', async () => {
+            await meeting.changeVideoLayout(undefined, {main: {width: 100, height: 200}});
+
+            assert.calledWith(meeting.meetingRequest.changeVideoLayoutDebounced, {
+              locusUrl: meeting.locusInfo.self.url,
+              deviceUrl: meeting.deviceUrl,
+              layoutType: undefined,
+              main: {width: 100, height: 200},
+              content: undefined
+            });
+          });
+
           it('throws if trying to send renderInfo for content when not receiving content', async () => {
             assert.isRejected(meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1280, height: 720}}));
           });

package/test/unit/spec/peerconnection-manager/index.js

@@ -1,9 +1,10 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+
 import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager/index';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
-import {IceGatheringFailed, InvalidSdpError} from '@webex/plugin-meetings/src/common/errors/webex-errors';
+import {InvalidSdpError} from '@webex/plugin-meetings/src/common/errors/webex-errors';
 
 describe('Peerconnection Manager', () => {
   describe('Methods', () => {
@@ -85,6 +86,45 @@ describe('Peerconnection Manager', () => {
 
         assert.equal(result.sdp, remoteSdp);
       });
+
+      it('removes xTLS candidates from the remote sdp', async () => {
+        StaticConfig.set({bandwidth: {}});
+
+        const remoteSdpWithXtlsCandidates = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:1 1 UDP 2130706175 18.206.82.54 9000 typ host\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=candidate:3 1 TCP 1962934015 18.206.82.54 9000 typ host tcptype passive\r\n' +
+        'a=candidate:4 1 xTLS 1795162111 external-media2.aintm-a-6.int.infra.webex.com 443 typ host tcptype passive fingerprint sha-1;55:B8:1D:94:BC:9D:B2:A5:5E:82:E7:84:C6:C8:10:AC:D3:FD:96:26\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\n' +
+        'm=video 9000 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:1 1 xTLS 1795162111 external-media2.aintm-a-6.int.infra.webex.com 443 typ host tcptype passive fingerprint sha-1;55:B8:1D:94:BC:9D:B2:A5:5E:82:E7:84:C6:C8:10:AC:D3:FD:96:26\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n';
+
+        // same as remoteSdpWithXtlsCandidates but without the xtls candidates
+        const resultSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:1 1 UDP 2130706175 18.206.82.54 9000 typ host\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=candidate:3 1 TCP 1962934015 18.206.82.54 9000 typ host tcptype passive\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\n' +
+        'm=video 9000 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=candidate:2 1 TCP 1962934271 18.206.82.54 5004 typ host tcptype passive\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n';
+
+        const peerConnection = {
+          signalingState: 'have-local-offer',
+          setRemoteDescription: sinon.stub().resolves(),
+          enableExtmap: true
+        };
+
+        await PeerConnectionManager.setRemoteSessionDetails(peerConnection, 'answer', remoteSdpWithXtlsCandidates, '');
+
+        assert.calledWith(peerConnection.setRemoteDescription, new global.window.RTCSessionDescription({sdp: resultSdp, type: 'answer'}));
+      });
     });
 
     describe('iceCandidate', () => {
@@ -123,13 +163,16 @@ describe('Peerconnection Manager', () => {
           });
       });
 
-      it('should not generate sdp if onicecandidateerror errors out ', async () => {
+      it('should still generate sdp even if onicecandidateerror is called ', async () => {
         peerConnection.iceGatheringState = 'none';
         setTimeout(() => {
           peerConnection.onicecandidateerror();
+          peerConnection.onicecandidate({candidate: null});
         }, 1000);
-        await assert.isRejected(PeerConnectionManager.iceCandidate(peerConnection, {remoteQualityLevel: 'HIGH'}), IceGatheringFailed);
-        assert.equal(peerConnection.sdp, null);
+        await PeerConnectionManager.iceCandidate(peerConnection, {remoteQualityLevel: 'HIGH'})
+          .then(() => {
+            assert(peerConnection.sdp.search('max-fs:8192'), true);
+          });
       });
 
       it('should throw generated SDP does not have candidates ', async () => {

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

@@ -0,0 +1,113 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
+import {ROAP} from '@webex/plugin-meetings/src/constants';
+
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import RoapHandler from '@webex/plugin-meetings/src/roap/handler';
+import Roap from '@webex/plugin-meetings/src/roap/';
+
+describe('Roap', () => {
+  describe('doTurnDiscovery', () => {
+    it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
+      const RESULT = {something: 'some value'};
+      const meeting = {id: 'some meeting id'};
+
+      const doTurnDiscoveryStub = sinon.stub(TurnDiscovery.prototype, 'doTurnDiscovery').resolves(RESULT);
+
+      const roap = new Roap({}, {parent: 'fake'});
+
+      // call with isReconnecting: true
+      const result = await roap.doTurnDiscovery(meeting, true);
+
+      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
+      assert.deepEqual(result, RESULT);
+
+      doTurnDiscoveryStub.resetHistory();
+
+      // and with isReconnecting: false
+      const result2 = await roap.doTurnDiscovery(meeting, false);
+
+      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, false);
+      assert.deepEqual(result2, RESULT);
+
+      sinon.restore();
+    });
+  });
+
+  describe('sendRoapMediaRequest', () => {
+    let sendRoapStub;
+    let roapHandlerSubmitStub;
+
+    const meeting = {
+      id: 'some meeting id',
+      correlationId: 'correlation id',
+      selfUrl: 'self url',
+      mediaId: 'media id',
+      isAudioMuted: () => true,
+      isVideoMuted: () => false,
+      setRoapSeq: sinon.stub(),
+      config: {experimental: {enableTurnDiscovery: false}},
+    };
+
+    beforeEach(() => {
+      sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
+      roapHandlerSubmitStub = sinon.stub(RoapHandler.prototype, 'submit');
+      meeting.setRoapSeq.resetHistory();
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    [
+      {reconnect: true, enableTurnDiscovery: true, expectEmptyMediaId: false},
+      {reconnect: true, enableTurnDiscovery: false, expectEmptyMediaId: true},
+      {reconnect: false, enableTurnDiscovery: true, expectEmptyMediaId: false},
+      {reconnect: false, enableTurnDiscovery: false, expectEmptyMediaId: false},
+    ].forEach(({reconnect, enableTurnDiscovery, expectEmptyMediaId}) =>
+      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${reconnect ? '' : 'not '}reconnecting and TURN discovery is ${enableTurnDiscovery ? 'enabled' : 'disabled'}`, async () => {
+        meeting.config.experimental.enableTurnDiscovery = enableTurnDiscovery;
+
+        const roap = new Roap({}, {parent: 'fake'});
+
+        await roap.sendRoapMediaRequest({
+          meeting, sdp: 'sdp', reconnect, roapSeq: 1
+        });
+
+        const expectedRoapMessage = {
+          messageType: 'OFFER',
+          sdps: ['sdp'],
+          version: '2',
+          seq: 2,
+          tieBreaker: 4294967294
+        };
+
+        assert.calledOnce(sendRoapStub);
+        assert.calledWith(sendRoapStub, {
+          roapMessage: expectedRoapMessage,
+          correlationId: meeting.correlationId,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
+          audioMuted: meeting.isAudioMuted(),
+          videoMuted: meeting.isVideoMuted(),
+          meetingId: meeting.id
+        });
+
+        assert.calledTwice(roapHandlerSubmitStub);
+        assert.calledWith(roapHandlerSubmitStub, {
+          type: ROAP.SEND_ROAP_MSG,
+          msg: expectedRoapMessage,
+          correlationId: meeting.correlationId
+        });
+        assert.calledWith(roapHandlerSubmitStub, {
+          type: ROAP.SEND_ROAP_MSG_SUCCESS,
+          seq: 2,
+          correlationId: meeting.correlationId
+        });
+
+        assert.calledOnce(meeting.setRoapSeq);
+        assert.calledWith(meeting.setRoapSeq, 2);
+      }));
+  });
+});