@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/roap/index.ts

@@ -3,22 +3,21 @@ 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} seq
- * @property {Number} tieBreaker
- *  @property {Boolean} reconnect
+ * @property {Number} roapSeq
+ * @property {Boolean} reconnect
  */
 
 /**
@@ -62,6 +61,20 @@ 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
@@ -71,17 +84,72 @@ 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
    */
-  public sendRoapOK(options: any) {
+  private sendRoapOK(options: any) {
     return Promise.resolve().then(() => {
       // @ts-ignore
       const meeting = this.webex.meetings.meetingCollection.getByKey(
@@ -101,26 +169,35 @@ 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
    */
-  public sendRoapAnswer(options: any) {
+  private sendRoapAnswer(options: any) {
     // @ts-ignore
     const meeting = this.webex.meetings.meetingCollection.getByKey(
       'correlationId',
@@ -128,131 +205,200 @@ export default class Roap extends StatelessWebexPlugin {
     );
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.ANSWER,
-      sdps: [options.sdp],
+      sdps: options.sdps,
       version: ROAP.ROAP_VERSION,
       seq: options.seq,
     };
 
-    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,
+    this.roapHandler.submit({
+      type: ROAP.SEND_ROAP_MSG,
+      msg: roapMessage,
+      correlationId: options.correlationId,
     });
-  }
-
-  /**
-   * 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(() => {
-        LoggerProxy.logger.log(
-          `Roap:index#sendRoapError --> ROAP ERROR sent with seq ${options.seq}`
-        );
+        meeting.setRoapSeq(options.seq);
+
+        this.roapHandler.submit({
+          type: ROAP.SEND_ROAP_MSG_SUCCESS,
+          seq: roapMessage.seq,
+          correlationId: meeting.correlationId,
+        });
       });
   }
 
+  /**
+   * 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, seq, sdp, tieBreaker} = options;
+    const {meeting, reconnect} = options;
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.OFFER,
-      sdps: [sdp],
+      sdps: [options.sdp],
+      // sdps: [options.sdp],
       version: ROAP.ROAP_VERSION,
-      seq,
-      tieBreaker,
-      headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+      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
     };
 
-    // The only time we want to send an empty media id is when we are reconnecting, because this way we tell Locus
-    // that it needs to create a new confluence, but when reconnecting we always send TURN_DISCOVERY_REQUEST first,
-    // so we don't need to ever send an empty media id here
-    const sendEmptyMediaId = false;
+    this.roapHandler.submit({
+      type: ROAP.SEND_ROAP_MSG,
+      msg: roapMessage,
+      correlationId: meeting.correlationId,
+    });
 
-    return this.roapRequest
-      .sendRoap({
-        roapMessage,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-        meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
-        locusMediaRequest: meeting.locusMediaRequest,
-        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
+    // 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.roapRequest.sendRoap({
+          roapMessage,
+          correlationId: meeting.correlationId,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+          audioMuted: meeting.audio?.isLocallyMuted(),
+          videoMuted: meeting.video?.isLocallyMuted(),
+          meetingId: meeting.id,
+        });
       })
+
       .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);
         }
 
-        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,
-            };
-          }
-        }
+        // 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
+      });
+  }
 
-        if (!roapAnswer) {
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
-            correlationId: meeting.correlationId,
-            messageType: 'ANSWER',
-            isMultistream: meeting.isMultistream,
-          });
-        }
+  /**
+   * 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,
+    });
 
-        return {locus, roapAnswer};
+    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();
+    }
   }
 
   /**
@@ -263,10 +409,9 @@ 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, isForced?: boolean) {
-    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting, isForced);
+  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
+    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
   }
 }