@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.2

package/src/reconnection-manager/index.js

@@ -18,11 +18,9 @@ import {
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
-import PeerConnectionManager from '../peer-connection-manager';
 import {eventType, reconnection, errorObjects} from '../metrics/config';
 import Media from '../media';
 import Metrics from '../metrics';
-import RoapCollection from '../roap/collection';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -119,6 +117,21 @@ export default class ReconnectionManager {
     this.reset();
   }
 
+  /**
+   * @public
+   * @memberof ReconnectionManager
+   * @returns {void}
+   */
+  resetReconnectionTimer() {
+    this.iceState.resolve();
+    this.iceState.resolve = () => {};
+
+    if (this.iceState.timer) {
+      clearTimeout(this.iceState.timer);
+      delete this.iceState.timer;
+    }
+  }
+
   /**
    * Sets the iceState to connected and clears any disconnect timeouts and
    * related timeout data within the iceState.
@@ -131,13 +144,7 @@ export default class ReconnectionManager {
     if (this.iceState.disconnected) {
       LoggerProxy.logger.log('ReconnectionManager:index#iceReconnected --> ice has reconnected');
 
-      this.iceState.resolve();
-      this.iceState.resolve = () => {};
-
-      if (this.iceState.timer) {
-        clearTimeout(this.iceState.timer);
-        delete this.iceState.timer;
-      }
+      this.resetReconnectionTimer();
 
       this.iceState.disconnected = false;
     }
@@ -199,6 +206,16 @@ export default class ReconnectionManager {
     this.meeting = null;
   }
 
+
+  /**
+   * @public
+   * @memberof ReconnectionManager
+   * @returns {Boolean} true if reconnection operation is in progress
+   */
+  isReconnectInProgress() {
+    return (this.status === RECONNECTION.STATE.IN_PROGRESS);
+  }
+
   /**
    * @returns {Boolean}
    * @throws {ReconnectionError}
@@ -388,13 +405,10 @@ export default class ReconnectionManager {
   async rejoinMeeting(wasSharing = false) {
     try {
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> attemping meeting rejoin');
-      const previousCorrelationId = this.meeting.correlationId;
 
       await this.meeting.join({rejoin: true});
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> meeting rejoined');
 
-      RoapCollection.deleteSession(previousCorrelationId);
-
       if (wasSharing) {
         // Stop the share streams if user tried to rejoin
         Media.stopTracks(this.meeting.mediaProperties.shareTrack);
@@ -451,28 +465,22 @@ export default class ReconnectionManager {
    * @private
    * @memberof ReconnectionManager
    */
-  reconnectMedia() {
+  async reconnectMedia() {
     LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media');
 
-    return ReconnectionManager.setupPeerConnection(this.meeting)
-      .then(() => Media.attachMedia(this.meeting.mediaProperties, {
-        meetingId: this.meeting.id,
-        remoteQualityLevel: this.meeting.mediaProperties.remoteQualityLevel,
-        enableRtx: this.meeting.config.enableRtx,
-        enableExtmap: this.meeting.config.enableExtmap
-      }))
-      .then((peerConnection) => this.meeting.setRemoteStream(peerConnection))
-      .then(() => {
-        LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> Sending ROAP media request');
-
-        return this.meeting.roap
-          .sendRoapMediaRequest({
-            sdp: this.meeting.mediaProperties.peerConnection.sdp,
-            roapSeq: this.meeting.roapSeq,
-            meeting: this.meeting,
-            reconnect: true
-          });
-      });
+    // we are not simply calling this.meeting.mediaProperties.webrtcMediaConnection.reconnect(),
+    // but instead manually closing and creating new media connection, because we need to do the TURN discovery again
+
+    await this.meeting.closePeerConnections();
+    this.meeting.mediaProperties.unsetPeerConnection();
+
+    const turnServerInfo = await this.meeting.roap.doTurnDiscovery(this.meeting, true);
+
+    const mc = this.meeting.createMediaConnection(turnServerInfo);
+
+    this.meeting.statsAnalyzer.updateMediaConnection(mc);
+
+    return mc.initiateOffer();
   }
 
   /**
@@ -508,25 +516,4 @@ export default class ReconnectionManager {
       throw (connectError);
     }
   }
-
-  /**
-   * @param {Meeting} meeting
-   * @returns {undefined}
-   * @private
-   * @memberof ReconnectionManager
-   */
-  static async setupPeerConnection(meeting) {
-    LoggerProxy.logger.log('ReconnectionManager:index#setupPeerConnection --> Begin resetting peer connection');
-    // close pcs, unset to null and create a new one with out closing any streams
-    PeerConnectionManager.close(meeting.mediaProperties.peerConnection);
-    meeting.mediaProperties.unsetPeerConnection();
-
-    const turnInfo = await meeting.roap.doTurnDiscovery(meeting, true);
-
-    meeting.mediaProperties.reInitiatePeerconnection(turnInfo);
-    PeerConnectionManager.setPeerConnectionEvents(meeting);
-
-    // update the peerconnection in the stats manager when ever we reconnect
-    meeting.statsAnalyzer.updatePeerconnection(meeting.mediaProperties.peerConnection);
-  }
 }

package/src/roap/index.js

@@ -2,11 +2,8 @@ import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import {ROAP} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
-import MeetingUtil from '../meeting/util';
 
-import RoapHandler from './handler';
 import RoapRequest from './request';
-import RoapCollection from './collection';
 import TurnDiscovery from './turnDiscovery';
 
 /**
@@ -14,8 +11,9 @@ import TurnDiscovery from './turnDiscovery';
  * @typedef {Object} RoapOptions
  * @property {String} sdp
  * @property {Meeting} meeting
- * @property {Number} roapSeq
- * @property {Boolean} reconnect
+ * @property {Number} seq
+ * @property {Number} tieBreaker
+ *  @property {Boolean} reconnect
  */
 
 /**
@@ -52,14 +50,6 @@ export default class Roap extends StatelessWebexPlugin {
      * @memberof Roap
      */
     this.options = options;
-    /**
-     * The Roap Process State Handler
-     * @instance
-     * @type {RoapHandler}
-     * @private
-     * @memberof Roap
-     */
-    this.roapHandler = new RoapHandler(this.attrs, this.options, this.sendRoapOK.bind(this), this.sendRoapAnswer.bind(this), this.roapFinished.bind(this));
     /**
      * The Roap Request Server Proxy Object
      * @instance
@@ -68,63 +58,10 @@ export default class Roap extends StatelessWebexPlugin {
      * @memberof Roap
      */
     this.roapRequest = new RoapRequest({}, options);
-    /**
-     * The last roap offer sent to server and acked
-     * @instance
-     * @type {Object}
-     * @private
-     * @memberof Roap
-     */
-    this.lastRoapOffer = {};
 
     this.turnDiscovery = new TurnDiscovery(this.roapRequest);
   }
 
-  /**
-   * Starts listening to mercury events for Roap messages
-   * @param {object} data event object
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  roapEvent(data) {
-    const msg = data.message;
-    const {correlationId} = data;
-
-    LoggerProxy.logger.log(`Roap:index#roapEvent --> Received Roap Message [${JSON.stringify(msg, null, 2)}]`);
-
-    if (msg.messageType === ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
-      // turn discovery is not part of normal roap protocol and so we are not handling it
-      // through the usual roap state machine
-      this.turnDiscovery.handleTurnDiscoveryResponse(msg);
-    }
-    else {
-      this.roapHandler.submit({
-        type: ROAP.RECEIVE_ROAP_MSG,
-        msg,
-        correlationId
-      });
-    }
-  }
-
-  /**
-   *
-   * @param {String} correlationId correlation id of a meeting
-   * @param {Number} seq ROAP sequence number
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  stop(correlationId, seq) {
-    this.roapHandler.submit({
-      type: ROAP.RECEIVE_CALL_LEAVE,
-      seq,
-      correlationId
-    });
-
-    return Promise.resolve();
-  }
-
   /**
    *
    * @param {SeqOptions} options
@@ -151,22 +88,15 @@ export default class Roap extends StatelessWebexPlugin {
           correlationId: options.correlationId,
           audioMuted: meeting.isAudioMuted(),
           videoMuted: meeting.isVideoMuted(),
-          meetingId: meeting.id
+          meetingId: meeting.id,
+          preferTranscoding: !meeting.isMultistream,
         })
         .then(() => {
-          this.roapHandler.submit({
-            type: ROAP.SEND_ROAP_MSG,
-            msg: roapMessage,
-            correlationId: options.correlationId
-          });
           LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sent with seq ${options.seq}`);
-          meeting.setRoapSeq(options.seq);
         });
     });
   }
 
-  // eslint-disable-next-line no-warning-comments
-  // TODO: try to merge sendRoapOk and roapAnswer
   /**
    * Sends a ROAP answer...
    * @param {SeqOptions} options
@@ -180,56 +110,54 @@ export default class Roap extends StatelessWebexPlugin {
     const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.ANSWER,
-      sdps: options.sdps,
+      sdps: [options.sdp],
       version: ROAP.ROAP_VERSION,
       seq: options.seq
     };
 
-    this.roapHandler.submit({
-      type: ROAP.SEND_ROAP_MSG,
-      msg: roapMessage,
-      correlationId: options.correlationId
-    });
-
     return this.roapRequest
       .sendRoap({
         roapMessage,
         locusSelfUrl: meeting.selfUrl,
         mediaId: options.mediaId,
         correlationId: options.correlationId,
-        audioMuted: options.audioMuted,
-        videoMuted: options.videoMuted,
-        meetingId: meeting.id
-      })
-      .then(() => {
-        meeting.setRoapSeq(options.seq);
-
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId
-        });
+        audioMuted: meeting.isAudioMuted(),
+        videoMuted: meeting.isVideoMuted(),
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
       });
   }
 
   /**
    * Sends a ROAP error...
-   * @param {Object} session
-   * @param {Object} locus
-   * @param {String} errorType
+   * @param {Object} options
    * @returns {Promise}
    * @private
    * @memberof Roap
    */
-  sendRoapError(session, locus, errorType) {
-    const msg = {
+  sendRoapError(options) {
+    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+    const roapMessage = {
       messageType: ROAP.ROAP_TYPES.ERROR,
       version: ROAP.ROAP_VERSION,
-      errorType,
-      seq: session.OFFER.seq
+      errorType: options.errorType,
+      seq: options.seq
+
     };
 
-    return this.roapRequest.sendRoap(msg, locus);
+    return this.roapRequest.sendRoap({
+      roapMessage,
+      locusSelfUrl: meeting.selfUrl,
+      mediaId: options.mediaId,
+      correlationId: options.correlationId,
+      audioMuted: meeting.isAudioMuted(),
+      videoMuted: meeting.isVideoMuted(),
+      meetingId: meeting.id,
+      preferTranscoding: !meeting.isMultistream,
+    })
+      .then(() => {
+        LoggerProxy.logger.log(`Roap:index#sendRoapError --> ROAP ERROR sent with seq ${options.seq}`);
+      });
   }
 
   /**
@@ -240,22 +168,17 @@ export default class Roap extends StatelessWebexPlugin {
    * @memberof Roap
    */
   sendRoapMediaRequest(options) {
-    const {meeting, reconnect} = options;
+    const {
+      meeting, seq, sdp, reconnect, tieBreaker
+    } = options;
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.OFFER,
-      sdps: [options.sdp],
-      // sdps: [options.sdp],
+      sdps: [sdp],
       version: ROAP.ROAP_VERSION,
-      seq: typeof options.roapSeq !== 'number' && Number.isNaN(parseFloat(options.roapSeq)) ? 0 : options.roapSeq + 1,
-      tieBreaker: 4294967294 // Math.floor(Math.random() * (2 ** 32) - 1) // TODO: Handle the roap  conflict scenario
+      seq,
+      tieBreaker
     };
 
-    this.roapHandler.submit({
-      type: ROAP.SEND_ROAP_MSG,
-      msg: roapMessage,
-      correlationId: meeting.correlationId
-    });
-
     // When reconnecting, it's important that the first roap message being sent out has empty media id.
     // Normally this is the roap offer, but when TURN discovery is enabled,
     // then this is the TURN discovery request message
@@ -269,111 +192,28 @@ export default class Roap extends StatelessWebexPlugin {
         mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
         audioMuted: meeting.isAudioMuted(),
         videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
       })
       .then(({locus, mediaConnections}) => {
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId
-        });
-        meeting.setRoapSeq(roapMessage.seq);
-
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
         }
 
-        // eslint-disable-next-line no-warning-comments
-        // TODO: we need to attach peerconenction to locus not sure if we need to pass everything here
         return locus;
-        // eslint-disable-next-line no-warning-comments
-        // TODO: check where to update the sequence number
       });
   }
 
   /**
-   * sends a roap media request
-   * @param {RoapOptions} options
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  sendRoapCallRequest = (options) => {
-    const {meeting} = options;
-    const roapMessage = {
-      messageType: ROAP.ROAP_TYPES.OFFER,
-      sdps: [options.sdp],
-      version: ROAP.ROAP_VERSION,
-      seq: typeof options.roapSeq !== 'number' && Number.isNaN(parseFloat(options.roapSeq)) ? 0 : options.roapSeq + 1,
-      tieBreaker: 4294967294 // Math.floor(Math.random() * (2 ** 32) - 1) // TODO: Handle the roap  conflict scenario
-    };
-
-    this.roapHandler.submit({
-      type: ROAP.SEND_ROAP_MSG,
-      msg: roapMessage,
-      correlationId: meeting.correlationId
-    });
-
-    const roapBody = {
-      localMedias: [
-        {
-          localSdp: JSON.stringify(this.roapRequest.attachRechabilityData({
-            roapMessage,
-            // eslint-disable-next-line no-warning-comments
-            // TODO: check whats the need for video and audiomute
-            audioMuted: !!meeting.isAudioMuted(),
-            videoMuted: !!meeting.isVideoMuted()
-          }))
-        // mediaId: meeting.mediaId
-        }
-      ]
-    };
-
-    return MeetingUtil.joinMeetingOptions(meeting, {roapMessage: roapBody})
-      .then((locus) => {
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId
-        });
-        meeting.setRoapSeq(roapMessage.seq);
-
-        // eslint-disable-next-line no-warning-comments
-        // TODO: we need to attach peerconenction to locus not sure if we need to pass everything here
-        return locus;
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check where to update the sequence number
-      });
-  };
-
-  /**
- * Called when the roap sequence is finished (completed successfully or failed)
- * @param {String} correlationId id of the meeting affected
- * @param {String} sequenceId the id of the finished sequence
- * @returns {undefined}
- * @private
- * @memberof Roap
- */
-  roapFinished(correlationId, sequenceId) {
-    RoapCollection.onSessionSequenceFinish(correlationId, sequenceId);
-    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', correlationId);
-
-    meeting.mediaNegotiatedEvent();
-    if (!RoapCollection.isBusy(correlationId)) {
-      meeting.processNextQueuedMediaUpdate();
-    }
-  }
-
-  /**
-   * Performs a TURN server discovery procedure, which involves exchanging
-   * some roap messages with the server. This exchange has to be done before
-   * any other roap messages are sent
-   *
-   * @param {Meeting} meeting
-   * @param {Boolean} isReconnecting should be set to true if this is a new
-   *                                 media connection just after a reconnection
-   * @returns {Promise}
-   */
+     * Performs a TURN server discovery procedure, which involves exchanging
+     * some roap messages with the server. This exchange has to be done before
+     * any other roap messages are sent
+     *
+     * @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) {
     return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
   }

package/src/roap/request.js

@@ -4,16 +4,13 @@ import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {
-  PARTICIPANT,
-  LOCI,
-  CALL,
   MEDIA,
   HTTP_VERBS,
   REACHABILITY
 } from '../constants';
 import Metrics from '../metrics';
 import {eventType} from '../metrics/config';
-import ParameterError from '../common/errors/parameter';
+
 /**
  * @class RoapRequest
  */
@@ -45,74 +42,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
     return localSdp;
   }
 
-  joinMeetingWithRoap(options) {
-    LoggerProxy.logger.info('Roap:request#joinMeetingWithRoap --> Join locus with roap');
-    LoggerProxy.logger.info(`Roap:request#joinMeetingWithRoap --> Local SDP: ${options.roapMessage}`);
-
-    return Promise.resolve().then(async () => {
-      const deviceUrl = this.webex.internal.device.url;
-      let url = '';
-
-      const body = {
-        deviceUrl,
-        usingResource: options.resourceId || null,
-        correlationId: options.correlationId,
-        localMedias: [
-          {
-            localSdp: JSON.stringify(this.attachRechabilityData({
-              roapMessage: options.roapMessage,
-              audioMuted: false,
-              videoMuted: false
-            }))
-          }
-        ],
-        clientMediaPreferences: {
-          preferTranscoding: options.preferTranscoding ?? true
-        }
-      };
-
-      if (options.locusUrl) {
-        url = `${options.locusUrl}/${PARTICIPANT}`;
-      }
-      else if (options.sipUrl) {
-        try {
-          await this.webex.internal.services.waitForCatalog('postauth');
-          url = `${this.webex.internal.services.get('locus')}/${LOCI}/${CALL}`;
-          body.invitee = {
-            address: options.sipTarget
-          };
-        }
-        catch (e) {
-          LoggerProxy.logger.error(`Roap:request#joinMeetingWithRoap --> ${e}`);
-          throw (e);
-        }
-      }
-      else {
-        throw new ParameterError('Must provide a locusUrl or sipTarget');
-      }
-
-      return this.webex
-        .request({
-          method: HTTP_VERBS.POST,
-          uri: url,
-          body
-        })
-        .then((res) => {
-          const {locus} = res.body;
-
-          locus.roapSeq = options.roapMessage.seq;
-          locus.id = locus.url.split('/').pop();
-          LoggerProxy.logger.info(`Roap:request#joinMeetingWithRoap --> Joined locus [${locus.id}][${locus.fullState.lastActive}]`);
-
-          return locus;
-        })
-        .catch((err) => {
-          LoggerProxy.logger.error(`Roap:request#joinMeetingWithRoap --> failed with error: ${err}`);
-          throw err;
-        });
-    });
-  }
-
   /**
    * Sends a ROAP message
    * @param {Object} options

package/src/roap/turnDiscovery.ts

@@ -9,6 +9,12 @@ import RoapRequest from './request';
 
 const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 
+// Roap spec says that seq should start from 1, but TURN discovery works fine with seq=0
+// and this is handy for us, because TURN discovery is always done before the first SDP exchange,
+// so we can do it with seq=0 or not do it at all and then we create the RoapMediaConnection
+// and do the SDP offer with seq=1
+const TURN_DISCOVERY_SEQ = 0;
+
 /**
  * Handles the process of finding out TURN server information from Linus.
  * This is achieved by sending a TURN_DISCOVERY_REQUEST.
@@ -126,8 +132,6 @@ export default class TurnDiscovery {
    * @memberof Roap
    */
   sendRoapTurnDiscoveryRequest(meeting, isReconnecting) {
-    const seq = meeting.roapSeq + 1;
-
     if (this.defer) {
       LoggerProxy.logger.warn('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress');
 
@@ -139,7 +143,7 @@ export default class TurnDiscovery {
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
       version: ROAP.ROAP_VERSION,
-      seq,
+      seq: TURN_DISCOVERY_SEQ,
     };
 
     LoggerProxy.logger.info('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> sending TURN_DISCOVERY_REQUEST');
@@ -155,8 +159,6 @@ export default class TurnDiscovery {
         meetingId: meeting.id
       })
       .then(({mediaConnections}) => {
-        meeting.setRoapSeq(seq);
-
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
         }
@@ -177,7 +179,7 @@ export default class TurnDiscovery {
       roapMessage: {
         messageType: ROAP.ROAP_TYPES.OK,
         version: ROAP.ROAP_VERSION,
-        seq: meeting.roapSeq
+        seq: TURN_DISCOVERY_SEQ,
       },
       locusSelfUrl: meeting.selfUrl,
       mediaId: meeting.mediaId,
@@ -196,6 +198,10 @@ export default class TurnDiscovery {
    *  | <----TURN_DISCOVERY_RESPONSE----- |
    *  | --------------OK----------------> |
    *
+   * This TURN discovery roap exchange is always done with seq=0.
+   * The RoapMediaConnection SDP exchange always starts with seq=1,
+   * so it works fine no matter if TURN discovery is done or not.
+   *
    * @param {Meeting} meeting
    * @param {Boolean} isReconnecting should be set to true if this is a new
    *                                 media connection just after a reconnection

package/src/statsAnalyzer/global.js

@@ -2,6 +2,7 @@ const STATS_DEFAULT = {
   encryption: 'sha-256',
   audio: {
     send: {
+      trackLabel: '',
       maxPacketLossRatio: 0,
       availableBandwidth: 0,
       bytesSent: 0,
@@ -17,6 +18,7 @@ const STATS_DEFAULT = {
   },
   video: {
     send: {
+      trackLabel: '',
       maxPacketLossRatio: 0,
       availableBandwidth: 0,
       meanRemoteJitter: [],