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

package/src/roap/request.ts

@@ -1,118 +1,45 @@
-/* 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';
+import {IP_VERSION, REACHABILITY} from '../constants';
+import {LocusMediaRequest} from '../meeting/locusMediaRequest';
+
 /**
  * @class RoapRequest
  */
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
-   * Joins a meeting via ROAP
-   * @param {Object} options
-   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
+   * Returns reachability data.
+   * @param {Object} localSdp
+   * @returns {Object}
    */
+  async attachReachabilityData(localSdp) {
+    let joinCookie;
 
-  attachRechabilityData(localSdp) {
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
+    // @ts-ignore
+    const reachabilityResult = await this.webex.meetings.reachability.getReachabilityResults();
 
-    if (reachabilityData) {
-      try {
-        const reachabilityResult = JSON.parse(reachabilityData);
+    if (reachabilityResult && Object.keys(reachabilityResult).length) {
+      localSdp.reachability = reachabilityResult;
+    }
+
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
 
-        /* istanbul ignore else */
-        if (reachabilityResult && Object.keys(reachabilityResult).length) {
-          localSdp.reachability = reachabilityResult;
-        }
+    if (joinCookieRaw) {
+      try {
+        joinCookie = JSON.parse(joinCookieRaw);
       } catch (e) {
         LoggerProxy.logger.error(
-          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
         );
       }
     }
 
-    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;
-        });
-    });
+    return {localSdp, joinCookie};
   }
 
   /**
@@ -122,78 +49,74 @@ 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
    */
-  sendRoap(options: {
+  async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    correlationId: string;
-    audioMuted: boolean;
-    videoMuted: boolean;
     meetingId: string;
-    preferTranscoding?: boolean;
+    ipVersion?: IP_VERSION;
+    locusMediaRequest?: LocusMediaRequest;
+    audioMuted?: boolean;
+    videoMuted?: boolean;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
+    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
     }
 
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    // @ts-ignore
-    const deviceUrl = this.webex.internal.device.url;
+    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,
+    });
 
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
-
     // @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,
-          },
-        },
+    this.webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {
+        meetingId,
+      },
+    });
+
+    return locusMediaRequest
+      .send({
+        type: 'RoapMessage',
+        selfUrl: locusSelfUrl,
+        joinCookie,
+        mediaId,
+        roapMessage,
+        reachability: localSdpWithReachabilityData.reachability,
+        ipVersion,
       })
       .then((res) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            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.info(
+        LoggerProxy.logger.debug(
           `Roap:request#sendRoap --> response:${JSON.stringify(
             mediaConnections,
             null,
@@ -202,7 +125,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         );
         const {locus} = res.body;
 
-        locus.roapSeq = options.roapMessage.seq;
+        locus.roapSeq = roapMessage.seq;
 
         return {
           locus,
@@ -210,10 +133,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        Metrics.postEvent({
-          event: eventType.MEDIA_RESPONSE,
-          meetingId,
-          data: {error: Metrics.parseLocusError(err, true)},
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
+            rawError: err,
+          },
         });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
         LoggerProxy.logger.error(

package/src/roap/turnDiscovery.ts

@@ -8,9 +8,16 @@ 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.
@@ -146,9 +153,7 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  private sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
-    const seq = meeting.roapSeq + 1;
-
+  sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
     if (this.defer) {
       LoggerProxy.logger.warn(
         'Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress'
@@ -162,7 +167,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(
@@ -172,7 +177,6 @@ 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
@@ -180,10 +184,11 @@ 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);
         }
@@ -204,19 +209,53 @@ export default class TurnDiscovery {
       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,
+      meetingId: meeting.id,
       audioMuted: meeting.audio?.isLocallyMuted(),
       videoMuted: meeting.video?.isLocallyMuted(),
-      meetingId: meeting.id,
+      locusMediaRequest: meeting.locusMediaRequest,
     });
   }
 
+  /**
+   * 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:
@@ -225,13 +264,22 @@ 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) {
-    const turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
+    let turnDiscoverySkippedReason: string;
+
+    if (!isForced) {
+      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+    }
 
     if (turnDiscoverySkippedReason) {
       return {
@@ -263,49 +311,7 @@ export default class TurnDiscovery {
           stack: e.stack,
         });
 
-        return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+        return {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;
-  }
 }

package/src/rtcMetrics/constants.ts

@@ -0,0 +1,3 @@
+const RTC_METRICS = {APP_ID: 'FFB51ED5-4319-4C55-8303-B1F2FCCDE231'};
+
+export {RTC_METRICS as default};

package/src/rtcMetrics/index.ts

@@ -0,0 +1,124 @@
+/* eslint-disable class-methods-use-this */
+import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
+import RTC_METRICS from './constants';
+
+/**
+ * Rtc Metrics
+ */
+export default class RtcMetrics {
+  /**
+   * Array of MetricData items to be sent to the metrics service.
+   */
+  metricsQueue = [];
+
+  intervalId: number;
+
+  webex: any;
+
+  meetingId: string;
+
+  correlationId: string;
+
+  /**
+   * Initialize the interval.
+   *
+   * @param {object} webex - The main `webex` object.
+   * @param {string} meetingId - The meeting id.
+   * @param {string} correlationId - The correlation id.
+   */
+  constructor(webex, meetingId, correlationId) {
+    // `window` is used to prevent typescript from returning a NodeJS.Timer.
+    this.intervalId = window.setInterval(this.sendMetricsInQueue.bind(this), 30 * 1000);
+    this.meetingId = meetingId;
+    this.webex = webex;
+    this.correlationId = correlationId;
+    // Send the first set of metrics at 5 seconds in the case of a user leaving the call shortly after joining.
+    setTimeout(this.sendMetricsInQueue.bind(this), 5 * 1000);
+  }
+
+  /**
+   * Check to see if the metrics queue has any items.
+   *
+   * @returns {void}
+   */
+  public sendMetricsInQueue() {
+    if (this.metricsQueue.length) {
+      this.sendMetrics();
+      this.metricsQueue = [];
+    }
+  }
+
+  /**
+   * Add metrics items to the metrics queue.
+   *
+   * @param {object} data - An object with a payload array of metrics items.
+   *
+   * @returns {void}
+   */
+  addMetrics(data) {
+    if (data.payload.length) {
+      if (data.name === 'stats-report') {
+        data.payload = data.payload.map(this.anonymizeIp);
+      }
+      this.metricsQueue.push(data);
+    }
+  }
+
+  /**
+   * Clear the metrics interval.
+   *
+   * @returns {void}
+   */
+  closeMetrics() {
+    this.sendMetricsInQueue();
+    clearInterval(this.intervalId);
+  }
+
+  /**
+   * Anonymize IP addresses.
+   *
+   * @param {array} stats - An RTCStatsReport organized into an array of strings.
+   * @returns {string}
+   */
+  anonymizeIp(stats: string): string {
+    const data = JSON.parse(stats);
+    // on local and remote candidates, anonymize the last 4 bits.
+    if (data.type === 'local-candidate' || data.type === 'remote-candidate') {
+      data.ip = CallDiagnosticUtils.anonymizeIPAddress(data.ip) || undefined;
+      data.address = CallDiagnosticUtils.anonymizeIPAddress(data.address) || undefined;
+      data.relatedAddress =
+        CallDiagnosticUtils.anonymizeIPAddress(data.relatedAddress) || undefined;
+    }
+
+    return JSON.stringify(data);
+  }
+
+  /**
+   * Send metrics to the metrics service.
+   *
+   * @returns {void}
+   */
+  private sendMetrics() {
+    this.webex.request({
+      method: 'POST',
+      service: 'unifiedTelemetry',
+      resource: 'metric/v2',
+      headers: {
+        type: 'webrtcMedia',
+        appId: RTC_METRICS.APP_ID,
+      },
+      body: {
+        metrics: [
+          {
+            type: 'webrtc',
+            version: '1.0.1',
+            userId: this.webex.internal.device.userId,
+            meetingId: this.meetingId,
+            correlationId: this.correlationId,
+            data: this.metricsQueue,
+          },
+        ],
+      },
+    });
+  }
+}