@webex/plugin-meetings 2.60.0 → 2.60.1-next.1

package/src/recording-controller/util.ts

@@ -1,17 +1,34 @@
-import {DISPLAY_HINTS} from '../constants';
+import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
 import RecordingAction from './enums';
+import MeetingUtil from '../meeting/util';
 
-const canUserStart = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
+const canUserStart = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
-const canUserPause = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
+const canUserPause = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
-const canUserResume = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
+const canUserResume = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
-const canUserStop = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
+const canUserStop = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
   return url?.split('/').pop();

package/src/roap/index.ts

@@ -3,21 +3,22 @@ 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';
 import Meeting from '../meeting';
+import MeetingUtil from '../meeting/util';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * Roap options
  * @typedef {Object} RoapOptions
  * @property {String} sdp
  * @property {Meeting} meeting
- * @property {Number} roapSeq
- * @property {Boolean} reconnect
+ * @property {Number} seq
+ * @property {Number} tieBreaker
+ *  @property {Boolean} reconnect
  */
 
 /**
@@ -61,20 +62,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
@@ -84,72 +71,17 @@ export default class Roap extends StatelessWebexPlugin {
      */
     // @ts-ignore
     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
-   */
-  private roapEvent(data: any) {
-    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
-   */
-  private stop(correlationId: string, seq: number) {
-    this.roapHandler.submit({
-      type: ROAP.RECEIVE_CALL_LEAVE,
-      seq,
-      correlationId,
-    });
-
-    return Promise.resolve();
-  }
-
   /**
    *
    * @param {SeqOptions} options
    * @returns {null}
-   * @private
    * @memberof Roap
    */
-  private sendRoapOK(options: any) {
+  public sendRoapOK(options: any) {
     return Promise.resolve().then(() => {
       // @ts-ignore
       const meeting = this.webex.meetings.meetingCollection.getByKey(
@@ -169,35 +101,26 @@ export default class Roap extends StatelessWebexPlugin {
           roapMessage,
           locusSelfUrl: meeting.selfUrl,
           mediaId: options.mediaId,
-          correlationId: options.correlationId,
           audioMuted: meeting.audio?.isLocallyMuted(),
           videoMuted: meeting.video?.isLocallyMuted(),
           meetingId: meeting.id,
+          locusMediaRequest: meeting.locusMediaRequest,
         })
         .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
    * @param {Boolean} options.audioMuted
    * @param {Boolean} options.videoMuted
    * @returns {Promise}
-   * @private
    * @memberof Roap
    */
-  private sendRoapAnswer(options: any) {
+  public sendRoapAnswer(options: any) {
     // @ts-ignore
     const meeting = this.webex.meetings.meetingCollection.getByKey(
       'correlationId',
@@ -205,200 +128,133 @@ export default class Roap extends StatelessWebexPlugin {
     );
     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,
+      meetingId: meeting.id,
+      audioMuted: meeting.audio?.isLocallyMuted(),
+      videoMuted: meeting.video?.isLocallyMuted(),
+      locusMediaRequest: meeting.locusMediaRequest,
     });
+  }
+
+  /**
+   * 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.audio?.isLocallyMuted(),
         videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
+        locusMediaRequest: meeting.locusMediaRequest,
       })
       .then(() => {
-        meeting.setRoapSeq(options.seq);
-
-        this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: roapMessage.seq,
-          correlationId: meeting.correlationId,
-        });
+        LoggerProxy.logger.log(
+          `Roap:index#sendRoapError --> ROAP ERROR sent with seq ${options.seq}`
+        );
       });
   }
 
-  /**
-   * Sends a ROAP error...
-   * @param {Object} session
-   * @param {Object} locus
-   * @param {String} errorType
-   * @returns {Promise}
-   * @private
-   * @memberof Roap
-   */
-  private sendRoapError(session: any, locus: object, errorType: string) {
-    const msg = {
-      messageType: ROAP.ROAP_TYPES.ERROR,
-      version: ROAP.ROAP_VERSION,
-      errorType,
-      seq: session.OFFER.seq,
-    };
-
-    return this.roapRequest.sendRoap(msg, locus);
-  }
-
   /**
    * sends a roap media request
    * @param {RoapOptions} options
    * @returns {Promise}
-   * @private
    * @memberof Roap
    */
   sendRoapMediaRequest(options: any) {
-    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,
+      headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
     };
 
-    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
-    return this.turnDiscovery
-      .isSkipped(meeting)
-      .then((isTurnDiscoverySkipped) => {
-        const sendEmptyMediaId = reconnect && isTurnDiscoverySkipped;
+    return this.turnDiscovery.isSkipped(meeting).then((isTurnDiscoverySkipped) => {
+      const sendEmptyMediaId = reconnect && isTurnDiscoverySkipped;
 
-        return this.roapRequest.sendRoap({
+      return this.roapRequest
+        .sendRoap({
           roapMessage,
-          correlationId: meeting.correlationId,
           locusSelfUrl: meeting.selfUrl,
           mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-          audioMuted: meeting.audio?.isLocallyMuted(),
-          videoMuted: meeting.video?.isLocallyMuted(),
           meetingId: meeting.id,
+          preferTranscoding: !meeting.isMultistream,
+          locusMediaRequest: meeting.locusMediaRequest,
+          ipVersion: MeetingUtil.getIpVersion(meeting.webex),
+        })
+        .then(({locus, mediaConnections}) => {
+          if (mediaConnections) {
+            meeting.updateMediaConnections(mediaConnections);
+          }
+
+          let roapAnswer;
+
+          if (mediaConnections?.[0]?.remoteSdp) {
+            const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
+
+            if (remoteSdp.roapMessage) {
+              const {
+                seq: answerSeq,
+                messageType,
+                sdps,
+                errorType,
+                errorCause,
+                headers,
+              } = remoteSdp.roapMessage;
+
+              roapAnswer = {
+                seq: answerSeq,
+                messageType,
+                sdp: sdps[0],
+                errorType,
+                errorCause,
+                headers,
+              };
+            }
+          }
+
+          if (!roapAnswer) {
+            Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
+              correlationId: meeting.correlationId,
+              messageType: 'ANSWER',
+              isMultistream: meeting.isMultistream,
+            });
+          }
+
+          return {locus, roapAnswer};
         });
-      })
-
-      .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: any) => {
-    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.audio?.isLocallyMuted(),
-              videoMuted: meeting.video?.isLocallyMuted(),
-            })
-          ),
-          // 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
-   */
-  private roapFinished(correlationId: string, sequenceId: string) {
-    RoapCollection.onSessionSequenceFinish(correlationId, sequenceId);
-    // @ts-ignore
-    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', correlationId);
-
-    meeting.mediaNegotiatedEvent();
-    if (!RoapCollection.isBusy(correlationId)) {
-      meeting.processNextQueuedMediaUpdate();
-    }
   }
 
   /**
@@ -409,9 +265,10 @@ export default class Roap extends StatelessWebexPlugin {
    * @param {Meeting} meeting
    * @param {Boolean} isReconnecting should be set to true if this is a new
    *                                 media connection just after a reconnection
+   * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
-    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
+  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean, isForced?: boolean) {
+    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting, isForced);
   }
 }