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

package/src/roap/request.ts

@@ -1,45 +1,118 @@
+/* global window */
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {IP_VERSION, REACHABILITY} from '../constants';
-import {LocusMediaRequest} from '../meeting/locusMediaRequest';
-
+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
  */
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
-   * Returns reachability data.
-   * @param {Object} localSdp
-   * @returns {Object}
+   * Joins a meeting via ROAP
+   * @param {Object} options
+   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
    */
-  async attachReachabilityData(localSdp) {
-    let joinCookie;
-
-    // @ts-ignore
-    const reachabilityResult = await this.webex.meetings.reachability.getReachabilityResults();
 
-    if (reachabilityResult && Object.keys(reachabilityResult).length) {
-      localSdp.reachability = reachabilityResult;
-    }
-
-    // @ts-ignore
-    const joinCookieRaw = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
-      .catch(() => {});
+  attachRechabilityData(localSdp) {
+    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
 
-    if (joinCookieRaw) {
+    if (reachabilityData) {
       try {
-        joinCookie = JSON.parse(joinCookieRaw);
+        const reachabilityResult = JSON.parse(reachabilityData);
+
+        /* istanbul ignore else */
+        if (reachabilityResult && Object.keys(reachabilityResult).length) {
+          localSdp.reachability = reachabilityResult;
+        }
       } catch (e) {
         LoggerProxy.logger.error(
-          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
         );
       }
     }
 
-    return {localSdp, joinCookie};
+    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 () => {
+      // @ts-ignore
+      const deviceUrl = this.webex.internal.device.url;
+      let url = '';
+
+      const body: any = {
+        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 {
+          // @ts-ignore
+          await this.webex.internal.services.waitForCatalog('postauth');
+          // @ts-ignore
+          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');
+      }
+
+      // @ts-ignore
+      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;
+        });
+    });
   }
 
   /**
@@ -49,74 +122,78 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.locusSelfUrl
    * @param {String} options.mediaId
    * @param {String} options.correlationId
+   * @param {Boolean} options.audioMuted
+   * @param {Boolean} options.videoMuted
    * @param {String} options.meetingId
-   * @param {IP_VERSION} options.ipVersion only required for offers
    * @returns {Promise} returns the response/failure of the request
    */
-  async sendRoap(options: {
+  sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
+    correlationId: string;
+    audioMuted: boolean;
+    videoMuted: boolean;
     meetingId: string;
-    ipVersion?: IP_VERSION;
-    locusMediaRequest?: LocusMediaRequest;
-    audioMuted?: boolean;
-    videoMuted?: boolean;
+    preferTranscoding?: boolean;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
+    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
     }
 
-    if (!locusMediaRequest) {
-      LoggerProxy.logger.warn(
-        'Roap:request#sendRoap --> locusMediaRequest unavailable, not sending roap'
-      );
-
-      return Promise.reject(new Error('sendRoap called when locusMediaRequest is undefined'));
-    }
-    const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
-      roapMessage,
-    });
+    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
+    // @ts-ignore
+    const deviceUrl = this.webex.internal.device.url;
 
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    // @ts-ignore
-    this.webex.internal.newMetrics.submitClientEvent({
-      name: 'client.locus.media.request',
-      options: {
-        meetingId,
-      },
-    });
+    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
-    return locusMediaRequest
-      .send({
-        type: 'RoapMessage',
-        selfUrl: locusSelfUrl,
-        joinCookie,
-        mediaId,
-        roapMessage,
-        reachability: localSdpWithReachabilityData.reachability,
-        ipVersion,
+    // @ts-ignore
+    return this.webex
+      .request({
+        uri: mediaUrl,
+        method: HTTP_VERBS.PUT,
+        body: {
+          device: {
+            url: deviceUrl,
+            // @ts-ignore
+            deviceType: this.config.meetings.deviceType,
+          },
+          correlationId,
+          localMedias: [
+            {
+              localSdp: JSON.stringify(
+                this.attachRechabilityData({
+                  roapMessage,
+                  // eslint-disable-next-line no-warning-comments
+                  // TODO: check whats the need for video and audiomute
+                  audioMuted: !!options.audioMuted,
+                  videoMuted: !!options.videoMuted,
+                })
+              ),
+              mediaId: options.mediaId,
+            },
+          ],
+          clientMediaPreferences: {
+            preferTranscoding: options.preferTranscoding ?? true,
+          },
+        },
       })
       .then((res) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-          },
-        });
+        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
+
         // always it will be the first mediaConnection Object
         const mediaConnections =
           res.body.mediaConnections &&
           res.body.mediaConnections.length > 0 &&
           res.body.mediaConnections[0];
 
-        LoggerProxy.logger.debug(
+        LoggerProxy.logger.info(
           `Roap:request#sendRoap --> response:${JSON.stringify(
             mediaConnections,
             null,
@@ -125,7 +202,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         );
         const {locus} = res.body;
 
-        locus.roapSeq = roapMessage.seq;
+        locus.roapSeq = options.roapMessage.seq;
 
         return {
           locus,
@@ -133,13 +210,10 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-            rawError: err,
-          },
+        Metrics.postEvent({
+          event: eventType.MEDIA_RESPONSE,
+          meetingId,
+          data: {error: Metrics.parseLocusError(err, true)},
         });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
         LoggerProxy.logger.error(

package/src/roap/state.ts

@@ -0,0 +1,156 @@
+import StateMachine from 'javascript-state-machine';
+
+import LoggerProxy from '../common/logs/logger-proxy';
+import {ROAP, _OFFER_, _ANSWER_, _REQUESTED_} from '../constants';
+import Meeting from '../meeting';
+
+const shouldStep = (roap, meeting) => {
+  const {messageType} = roap.msg;
+
+  if (meeting) {
+    if (messageType === _OFFER_ && roap.remote && meeting.shareStatus === _REQUESTED_) {
+      // The peer-connection is waiting for answer but got an offer Reset. Try to
+      // send the offer later after you accept the answer
+      return false;
+    }
+    // Assuming the mercury event has come first before the response for the event
+    // we have to wait for the response and trigger the ROAP request later on
+    if (!meeting.mediaProperties.peerConnection && messageType === _ANSWER_) {
+      return false;
+    }
+  }
+  LoggerProxy.logger.log(
+    'Roap:state#shouldStep --> RoapStateMachine: PeerConnectionState, ',
+    meeting.mediaProperties.peerConnection.signalingState
+  );
+  LoggerProxy.logger.log(
+    'Roap:state#shouldStep --> RoapStateMachine: success save proceeding with transition, ',
+    roap.msg
+  );
+
+  return true;
+};
+
+const handleTransition = (value, signal, meeting) => {
+  LoggerProxy.logger.log(`Roap:state#handleTransition --> current ${value} to ${signal}`);
+
+  switch (value) {
+    case ROAP.ROAP_STATE.INIT:
+      if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {
+        return ROAP.ROAP_STATE.WAIT_TX_ANSWER;
+      }
+      if (signal === ROAP.ROAP_SIGNAL.TX_OFFER) {
+        return ROAP.ROAP_STATE.WAIT_RX_ANSWER;
+      }
+
+      return value;
+
+    case ROAP.ROAP_STATE.WAIT_RX_OFFER:
+      return value;
+
+    case ROAP.ROAP_STATE.WAIT_RX_ANSWER:
+      if (signal === ROAP.ROAP_SIGNAL.RX_ANSWER) {
+        // There is a race condition where the /call response comes after mercury event from the server
+        // As mercury sends roap event if it didnt get back a response. We can send the roap ok after that
+        if (meeting.mediaId) {
+          return ROAP.ROAP_STATE.WAIT_TX_OK;
+        }
+        LoggerProxy.logger.error(
+          'Roap:state#handleTransition --> Race Condition no mediaId, continuing.'
+        );
+
+        return value;
+      }
+
+      if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {
+        return ROAP.ROAP_STATE.GLARE;
+      }
+
+      return value;
+
+    case ROAP.ROAP_STATE.WAIT_TX_OFFER:
+      return value;
+
+    case ROAP.ROAP_STATE.WAIT_TX_ANSWER:
+      if (signal === ROAP.ROAP_SIGNAL.TX_ANSWER) {
+        return ROAP.ROAP_STATE.WAIT_RX_OK;
+      }
+
+      return value;
+
+    case ROAP.ROAP_STATE.WAIT_TX_OK:
+      if (signal === ROAP.ROAP_SIGNAL.TX_OK) {
+        return ROAP.ROAP_STATE.INIT;
+      }
+
+      return value;
+
+    case ROAP.ROAP_STATE.WAIT_RX_OK:
+      if (signal === ROAP.ROAP_SIGNAL.RX_OK) {
+        return ROAP.ROAP_STATE.INIT;
+      }
+
+      return value;
+
+    case ROAP.ROAP_STATE.ERROR:
+      // eslint-disable-next-line no-warning-comments
+      // TODO: resolve error state. Add a signal constant and handle the cleanup
+      return ROAP.ROAP_STATE.INIT;
+
+    case ROAP.ROAP_STATE.GLARE:
+      return ROAP.ROAP_STATE.WAIT_RX_ANSWER;
+    default:
+      return value;
+  }
+};
+
+const RoapStateMachine = {
+  /**
+   * @param {Roap} roapRef
+   * initializes the state machine
+   * @returns {StateMachine} an instance of a state machine
+   */
+  createState() {
+    const RoapState = StateMachine.factory({
+      init: ROAP.ROAP_STATE.INIT,
+      transitions: [
+        {
+          name: ROAP.ROAP_TRANSITIONS.STEP,
+          from: '*',
+          /**
+           * Method to handle the transitions between states
+           * @param {String} signal
+           * @param {Meeting} meeting instance of a Meeting
+           * @param {Object} roap
+           * @returns {String} new state value
+           */
+          to(signal: string, meeting: Meeting, roap: object) {
+            const value = this.state;
+
+            if (!shouldStep(roap, meeting)) {
+              return value;
+            }
+
+            return handleTransition(value, signal, meeting);
+          },
+        },
+      ],
+      methods: {
+        /**
+         * Event that fires after we've transitioned to a new state
+         * @param {Object} transition
+         * @returns {null}
+         */
+        onAfterStep(transition: any) {
+          LoggerProxy.logger.log(
+            `Roap:state#onAfterStep --> RoapStateMachine->onAfterStep#fired! State changed from '${transition.from}' to '${transition.to}' with transition '${transition.transition}''.`
+          );
+        },
+      },
+    });
+
+    return new RoapState();
+  },
+};
+
+export default RoapStateMachine;

package/src/roap/turnDiscovery.ts

@@ -8,16 +8,9 @@ import {ROAP} from '../constants';
 
 import RoapRequest from './request';
 import Meeting from '../meeting';
-import MeetingUtil from '../meeting/util';
 
 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.
@@ -153,7 +146,9 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
+  private sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
+    const seq = meeting.roapSeq + 1;
+
     if (this.defer) {
       LoggerProxy.logger.warn(
         'Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress'
@@ -167,7 +162,7 @@ export default class TurnDiscovery {
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
       version: ROAP.ROAP_VERSION,
-      seq: TURN_DISCOVERY_SEQ,
+      seq,
     };
 
     LoggerProxy.logger.info(
@@ -177,6 +172,7 @@ export default class TurnDiscovery {
     return this.roapRequest
       .sendRoap({
         roapMessage,
+        correlationId: meeting.correlationId,
         // @ts-ignore - Fix missing type
         locusSelfUrl: meeting.selfUrl,
         // @ts-ignore - Fix missing type
@@ -184,11 +180,10 @@ export default class TurnDiscovery {
         audioMuted: meeting.audio?.isLocallyMuted(),
         videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
-        locusMediaRequest: meeting.locusMediaRequest,
-        // @ts-ignore - because of meeting.webex
-        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
       .then(({mediaConnections}) => {
+        meeting.setRoapSeq(seq);
+
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
         }
@@ -209,53 +204,19 @@ export default class TurnDiscovery {
       roapMessage: {
         messageType: ROAP.ROAP_TYPES.OK,
         version: ROAP.ROAP_VERSION,
-        seq: TURN_DISCOVERY_SEQ,
+        seq: meeting.roapSeq,
       },
       // @ts-ignore - fix type
       locusSelfUrl: meeting.selfUrl,
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      meetingId: meeting.id,
+      correlationId: meeting.correlationId,
       audioMuted: meeting.audio?.isLocallyMuted(),
       videoMuted: meeting.video?.isLocallyMuted(),
-      locusMediaRequest: meeting.locusMediaRequest,
+      meetingId: meeting.id,
     });
   }
 
-  /**
-   * Gets the reason why reachability is skipped.
-   *
-   * @param {Meeting} meeting
-   * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
-   */
-  private async getSkipReason(meeting: Meeting): Promise<string> {
-    const isAnyPublicClusterReachable =
-      // @ts-ignore - fix type
-      await meeting.webex.meetings.reachability.isAnyPublicClusterReachable();
-
-    if (isAnyPublicClusterReachable) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
-      );
-
-      return 'reachability';
-    }
-
-    return '';
-  }
-
-  /**
-   * Checks if TURN discovery is skipped.
-   *
-   * @param {Meeting} meeting
-   * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
-   */
-  async isSkipped(meeting) {
-    const skipReason = await this.getSkipReason(meeting);
-
-    return !!skipReason;
-  }
-
   /**
    * Retrieves TURN server information from the backend by doing
    * a roap message exchange:
@@ -264,22 +225,13 @@ 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
+   * @param {Boolean} isReconnecting should be set to true if this is a new
    *                                 media connection just after a reconnection
-   * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
-    let turnDiscoverySkippedReason: string;
-
-    if (!isForced) {
-      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
-    }
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
+    const turnDiscoverySkippedReason = await this.getSkipReason(meeting);
 
     if (turnDiscoverySkippedReason) {
       return {
@@ -311,7 +263,49 @@ export default class TurnDiscovery {
           stack: e.stack,
         });
 
-        return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+        return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
       });
   }
+
+  /**
+   * Gets the reason why reachability is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+   */
+  private async getSkipReason(meeting: Meeting): Promise<string> {
+    // @ts-ignore - fix type
+    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+
+    if (isAnyClusterReachable) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
+      );
+
+      return 'reachability';
+    }
+
+    // @ts-ignore - fix type
+    if (!meeting.config.experimental.enableTurnDiscovery) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> TURN discovery disabled in config, skipping it'
+      );
+
+      return 'config';
+    }
+
+    return '';
+  }
+
+  /**
+   * Checks if TURN discovery is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+   */
+  async isSkipped(meeting) {
+    const skipReason = await this.getSkipReason(meeting);
+
+    return !!skipReason;
+  }
 }