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

package/src/roap/index.ts

@@ -0,0 +1,229 @@
+// @ts-ignore
+import {StatelessWebexPlugin} from '@webex/webex-core';
+
+import {ROAP} from '../constants';
+import LoggerProxy from '../common/logs/logger-proxy';
+
+import RoapRequest from './request';
+import TurnDiscovery from './turnDiscovery';
+import Meeting from '../meeting';
+
+/**
+ * Roap options
+ * @typedef {Object} RoapOptions
+ * @property {String} sdp
+ * @property {Meeting} meeting
+ * @property {Number} seq
+ * @property {Number} tieBreaker
+ *  @property {Boolean} reconnect
+ */
+
+/**
+  * @typedef {Object} SeqOptions
+  * @property {String} correlationId
+  * @property {String} mediaId
+  * @property {Number} seq
+  */
+
+/**
+ * @class Roap
+ * @export
+ * @private
+ */
+export default class Roap extends StatelessWebexPlugin {
+  attrs: any;
+  lastRoapOffer: any;
+  options: any;
+  roapHandler: any;
+  roapRequest: any;
+  turnDiscovery: any;
+
+  /**
+   *
+   * @param {Object} attrs
+   * @param {Object} options
+   */
+  constructor(attrs: any, options: any) {
+    super({}, options);
+    /**
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Roap
+     */
+    this.attrs = attrs;
+    /**
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Roap
+     */
+    this.options = options;
+    /**
+     * The Roap Request Server Proxy Object
+     * @instance
+     * @type {RoapRequest}
+     * @private
+     * @memberof Roap
+     */
+    // @ts-ignore
+    this.roapRequest = new RoapRequest({}, options);
+
+    this.turnDiscovery = new TurnDiscovery(this.roapRequest);
+  }
+
+  /**
+   *
+   * @param {SeqOptions} options
+   * @returns {null}
+   * @memberof Roap
+   */
+  public sendRoapOK(options: any) {
+    return Promise.resolve().then(() => {
+      // @ts-ignore
+      const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+      const roapMessage = {
+        messageType: ROAP.ROAP_TYPES.OK,
+        version: ROAP.ROAP_VERSION,
+        seq: options.seq
+      };
+
+      LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sending with seq ${options.seq}`);
+
+      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#sendRoapOK --> ROAP OK sent with seq ${options.seq}`);
+        });
+    });
+  }
+
+  /**
+   * Sends a ROAP answer...
+   * @param {SeqOptions} options
+   * @param {Boolean} options.audioMuted
+   * @param {Boolean} options.videoMuted
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  public sendRoapAnswer(options: any) {
+    // @ts-ignore
+    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.ANSWER,
+      sdps: [options.sdp],
+      version: ROAP.ROAP_VERSION,
+      seq: options.seq
+    };
+
+    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,
+      });
+  }
+
+  /**
+   * Sends a ROAP error...
+   * @param {Object} options
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  sendRoapError(options) {
+    // @ts-ignore
+    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', options.correlationId);
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.ERROR,
+      version: ROAP.ROAP_VERSION,
+      errorType: options.errorType,
+      seq: options.seq
+
+    };
+
+    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}`);
+      });
+  }
+
+  /**
+   * sends a roap media request
+   * @param {RoapOptions} options
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  sendRoapMediaRequest(options: any) {
+    const {
+      meeting, seq, sdp, reconnect, tieBreaker
+    } = options;
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.OFFER,
+      sdps: [sdp],
+      version: ROAP.ROAP_VERSION,
+      seq,
+      tieBreaker
+    };
+
+    // 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
+    const sendEmptyMediaId = reconnect && !meeting.config.experimental.enableTurnDiscovery;
+
+    return this.roapRequest
+      .sendRoap({
+        roapMessage,
+        correlationId: meeting.correlationId,
+        locusSelfUrl: meeting.selfUrl,
+        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+        audioMuted: meeting.isAudioMuted(),
+        videoMuted: meeting.isVideoMuted(),
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
+      })
+      .then(({locus, mediaConnections}) => {
+        if (mediaConnections) {
+          meeting.updateMediaConnections(mediaConnections);
+        }
+
+        return locus;
+      });
+  }
+
+  /**
+   * 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: Meeting, isReconnecting: boolean) {
+    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
+  }
+}

package/src/roap/{request.js → request.ts}

@@ -1,19 +1,16 @@
-
 /* global window */
+// @ts-ignore
 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
@@ -125,7 +54,16 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.meetingId
    * @returns {Promise} returns the response/failure of the request
    */
-  sendRoap(options) {
+  sendRoap(options: {
+    roapMessage: any;
+    locusSelfUrl: string;
+    mediaId: string;
+    correlationId: string;
+    audioMuted: boolean;
+    videoMuted: boolean;
+    meetingId: string;
+    preferTranscoding?: boolean;
+  }) {
     const {
       roapMessage, locusSelfUrl, mediaId, correlationId, meetingId
     } = options;
@@ -135,12 +73,14 @@ export default class RoapRequest extends StatelessWebexPlugin {
     }
 
     const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
+    // @ts-ignore
     const deviceUrl = this.webex.internal.device.url;
 
     LoggerProxy.logger.info(`Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`);
 
     Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
+    // @ts-ignore
     return this.webex
       .request({
         uri: mediaUrl,
@@ -148,6 +88,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         body: {
           device: {
             url: deviceUrl,
+            // @ts-ignore
             deviceType: this.config.meetings.deviceType
           },
           correlationId,

package/src/roap/turnDiscovery.ts

@@ -1,3 +1,4 @@
+// @ts-ignore - Types not available for @webex/common
 import {Defer} from '@webex/common';
 
 import Metrics from '../metrics';
@@ -6,9 +7,16 @@ import LoggerProxy from '../common/logs/logger-proxy';
 import {ROAP} from '../constants';
 
 import RoapRequest from './request';
+import Meeting from '../meeting';
 
 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.
@@ -48,7 +56,7 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  waitForTurnDiscoveryResponse() {
+  private waitForTurnDiscoveryResponse() {
     if (!this.defer) {
       LoggerProxy.logger.warn('Roap:turnDiscovery#waitForTurnDiscoveryResponse --> TURN discovery is not in progress');
 
@@ -76,7 +84,8 @@ export default class TurnDiscovery {
    * @public
    * @memberof Roap
    */
-  handleTurnDiscoveryResponse(roapMessage) {
+  public handleTurnDiscoveryResponse(roapMessage: object) {
+    // @ts-ignore - Fix missing type
     const {headers} = roapMessage;
 
     if (!this.defer) {
@@ -125,9 +134,7 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  sendRoapTurnDiscoveryRequest(meeting, isReconnecting) {
-    const seq = meeting.roapSeq + 1;
-
+  sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
     if (this.defer) {
       LoggerProxy.logger.warn('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress');
 
@@ -139,7 +146,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');
@@ -148,15 +155,15 @@ export default class TurnDiscovery {
       .sendRoap({
         roapMessage,
         correlationId: meeting.correlationId,
+       // @ts-ignore - Fix missing type
         locusSelfUrl: meeting.selfUrl,
+        // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
         audioMuted: meeting.isAudioMuted(),
         videoMuted: meeting.isVideoMuted(),
         meetingId: meeting.id
       })
       .then(({mediaConnections}) => {
-        meeting.setRoapSeq(seq);
-
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
         }
@@ -170,16 +177,18 @@ export default class TurnDiscovery {
    * @param {Meeting} meeting
    * @returns {Promise}
    */
-  sendRoapOK(meeting) {
+  sendRoapOK(meeting: 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
+        seq: TURN_DISCOVERY_SEQ,
       },
+      // @ts-ignore - fix type
       locusSelfUrl: meeting.selfUrl,
+      // @ts-ignore - fix type
       mediaId: meeting.mediaId,
       correlationId: meeting.correlationId,
       audioMuted: meeting.isAudioMuted(),
@@ -196,12 +205,17 @@ 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
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting, isReconnecting) {
+  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
+    // @ts-ignore - fix type
     const isAnyClusterReachable = meeting.webex.meetings.reachability.isAnyClusterReachable();
 
     if (isAnyClusterReachable) {
@@ -209,6 +223,7 @@ export default class TurnDiscovery {
       return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: 'reachability'});
     }
 
+    // @ts-ignore - fix type
     if (!meeting.config.experimental.enableTurnDiscovery) {
       LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it');
 

package/src/statsAnalyzer/{global.js → global.ts}

@@ -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: [],