@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

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,6 +7,8 @@ import LoggerProxy from '../common/logs/logger-proxy';
 import {ROAP} from '../constants';
 
 import RoapRequest from './request';
+import Meeting from '../meeting';
+import MeetingUtil from '../meeting/util';
 
 const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 
@@ -46,7 +49,6 @@ export default class TurnDiscovery {
     };
   }
 
-
   /**
    * waits for TURN_DISCOVERY_RESPONSE message to arrive
    *
@@ -54,22 +56,30 @@ 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');
+      LoggerProxy.logger.warn(
+        'Roap:turnDiscovery#waitForTurnDiscoveryResponse --> TURN discovery is not in progress'
+      );
 
-      return Promise.reject(new Error('waitForTurnDiscoveryResponse() called before sendRoapTurnDiscoveryRequest()'));
+      return Promise.reject(
+        new Error('waitForTurnDiscoveryResponse() called before sendRoapTurnDiscoveryRequest()')
+      );
     }
 
     const {defer} = this;
 
     this.responseTimer = setTimeout(() => {
-      LoggerProxy.logger.warn(`Roap:turnDiscovery#waitForTurnDiscoveryResponse --> timeout! no response arrived within ${TURN_DISCOVERY_TIMEOUT} seconds`);
+      LoggerProxy.logger.warn(
+        `Roap:turnDiscovery#waitForTurnDiscoveryResponse --> timeout! no response arrived within ${TURN_DISCOVERY_TIMEOUT} seconds`
+      );
 
       defer.reject(new Error('Timed out waiting for TURN_DISCOVERY_RESPONSE'));
     }, TURN_DISCOVERY_TIMEOUT * 1000);
 
-    LoggerProxy.logger.info('Roap:turnDiscovery#waitForTurnDiscoveryResponse --> waiting for TURN_DISCOVERY_RESPONSE...');
+    LoggerProxy.logger.info(
+      'Roap:turnDiscovery#waitForTurnDiscoveryResponse --> waiting for TURN_DISCOVERY_RESPONSE...'
+    );
 
     return defer.promise;
   }
@@ -82,11 +92,14 @@ export default class TurnDiscovery {
    * @public
    * @memberof Roap
    */
-  handleTurnDiscoveryResponse(roapMessage) {
+  public handleTurnDiscoveryResponse(roapMessage: object) {
+    // @ts-ignore - Fix missing type
     const {headers} = roapMessage;
 
     if (!this.defer) {
-      LoggerProxy.logger.warn('Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response');
+      LoggerProxy.logger.warn(
+        'Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response'
+      );
 
       return;
     }
@@ -103,7 +116,9 @@ export default class TurnDiscovery {
       // check if it matches any of our expected headers
       expectedHeaders.forEach((expectedHeader) => {
         if (receivedHeader.startsWith(`${expectedHeader.headerName}=`)) {
-          this.turnInfo[expectedHeader.field] = receivedHeader.substring(expectedHeader.headerName.length + 1);
+          this.turnInfo[expectedHeader.field] = receivedHeader.substring(
+            expectedHeader.headerName.length + 1
+          );
           foundHeaders += 1;
         }
       });
@@ -113,11 +128,18 @@ export default class TurnDiscovery {
     this.responseTimer = undefined;
 
     if (foundHeaders !== expectedHeaders.length) {
-      LoggerProxy.logger.warn(`Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received: ${JSON.stringify(headers)}`);
-      this.defer.reject(new Error(`TURN_DISCOVERY_RESPONSE missing some headers: ${JSON.stringify(headers)}`));
-    }
-    else {
-      LoggerProxy.logger.info(`Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response, url=${this.turnInfo.url}`);
+      LoggerProxy.logger.warn(
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received: ${JSON.stringify(
+          headers
+        )}`
+      );
+      this.defer.reject(
+        new Error(`TURN_DISCOVERY_RESPONSE missing some headers: ${JSON.stringify(headers)}`)
+      );
+    } else {
+      LoggerProxy.logger.info(
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response, url=${this.turnInfo.url}`
+      );
       this.defer.resolve();
     }
   }
@@ -131,9 +153,11 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  sendRoapTurnDiscoveryRequest(meeting, isReconnecting) {
+  sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
     if (this.defer) {
-      LoggerProxy.logger.warn('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress');
+      LoggerProxy.logger.warn(
+        'Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress'
+      );
 
       return Promise.resolve();
     }
@@ -146,17 +170,21 @@ export default class TurnDiscovery {
       seq: TURN_DISCOVERY_SEQ,
     };
 
-    LoggerProxy.logger.info('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> sending TURN_DISCOVERY_REQUEST');
+    LoggerProxy.logger.info(
+      'Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> sending TURN_DISCOVERY_REQUEST'
+    );
 
     return this.roapRequest
       .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
+        meetingId: meeting.id,
+        locusMediaRequest: meeting.locusMediaRequest,
+        // @ts-ignore - because of meeting.webex
+        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
       .then(({mediaConnections}) => {
         if (mediaConnections) {
@@ -172,7 +200,7 @@ 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({
@@ -181,15 +209,49 @@ export default class TurnDiscovery {
         version: ROAP.ROAP_VERSION,
         seq: TURN_DISCOVERY_SEQ,
       },
+      // @ts-ignore - fix type
       locusSelfUrl: meeting.selfUrl,
+      // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId,
-      audioMuted: meeting.isAudioMuted(),
-      videoMuted: meeting.isVideoMuted(),
-      meetingId: meeting.id
+      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:
@@ -203,22 +265,23 @@ export default class TurnDiscovery {
    * 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}
    */
-  doTurnDiscovery(meeting, isReconnecting) {
-    const isAnyClusterReachable = meeting.webex.meetings.reachability.isAnyClusterReachable();
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
+    let turnDiscoverySkippedReason: string;
 
-    if (isAnyClusterReachable) {
-      LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery');
-      return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: 'reachability'});
+    if (!isForced) {
+      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
     }
 
-    if (!meeting.config.experimental.enableTurnDiscovery) {
-      LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it');
-
-      return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'});
+    if (turnDiscoverySkippedReason) {
+      return {
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason,
+      };
     }
 
     return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
@@ -233,19 +296,18 @@ export default class TurnDiscovery {
       })
       .catch((e) => {
         // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
-        LoggerProxy.logger.info(`Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`);
-
-        Metrics.sendBehavioralMetric(
-          BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE,
-          {
-            correlation_id: meeting.correlationId,
-            locus_id: meeting.locusUrl.split('/').pop(),
-            reason: e.message,
-            stack: e.stack
-          }
+        LoggerProxy.logger.info(
+          `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`
         );
 
-        return Promise.resolve({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
+          correlation_id: meeting.correlationId,
+          locus_id: meeting.locusUrl.split('/').pop(),
+          reason: e.message,
+          stack: e.stack,
+        });
+
+        return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
       });
   }
 }

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,100 @@
+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) {
+      this.metricsQueue.push(data);
+    }
+  }
+
+  /**
+   * Clear the metrics interval.
+   *
+   * @returns {void}
+   */
+  closeMetrics() {
+    this.sendMetricsInQueue();
+    clearInterval(this.intervalId);
+  }
+
+  /**
+   * 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,
+          },
+        ],
+      },
+    });
+  }
+}

package/src/statsAnalyzer/global.ts

@@ -0,0 +1,37 @@
+const STATS_DEFAULT = {
+  encryption: 'sha-256',
+  bandwidth: {
+    systemBandwidth: 0,
+    sentPerSecond: 0,
+    encodedPerSecond: 0,
+    helper: {
+      audioBytesSent: 0,
+      videoBytestSent: 0,
+    },
+    speed: 0,
+  },
+  results: {},
+  connectionType: {
+    systemNetworkType: 'unknown',
+    systemIpAddress: '0.0.0.0',
+    local: {
+      candidateType: [],
+      transport: [],
+      ipAddress: [],
+      networkType: [],
+    },
+    remote: {
+      candidateType: [],
+      transport: [],
+      ipAddress: [],
+      networkType: [],
+    },
+  },
+  resolutions: {},
+  internal: {
+    remote: {},
+    candidates: {},
+  },
+};
+
+export default STATS_DEFAULT;