@webex/plugin-meetings 3.3.1-next.14 → 3.3.1-next.16

package/dist/types/reachability/index.d.ts

@@ -1,8 +1,10 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+import { Defer } from '@webex/common';
 import ReachabilityRequest from './request';
 import { ClusterReachability, ClusterReachabilityResult } from './clusterReachability';
+import EventsScope from '../common/events/events-scope';
 export type ReachabilityMetrics = {
     reachability_public_udp_success: number;
     reachability_public_udp_failed: number;
@@ -40,13 +42,37 @@ export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
  * @class Reachability
  * @export
  */
-export default class Reachability {
+export default class Reachability extends EventsScope {
     namespace: string;
     webex: object;
     reachabilityRequest: ReachabilityRequest;
     clusterReachability: {
         [key: string]: ClusterReachability;
     };
+    reachabilityDefer?: Defer;
+    vmnTimer?: ReturnType<typeof setTimeout>;
+    publicCloudTimer?: ReturnType<typeof setTimeout>;
+    overallTimer?: ReturnType<typeof setTimeout>;
+    expectedResultsCount: {
+        videoMesh: {
+            udp: number;
+        };
+        public: {
+            udp: number;
+            tcp: number;
+            xtls: number;
+        };
+    };
+    resultsCount: {
+        videoMesh: {
+            udp: number;
+        };
+        public: {
+            udp: number;
+            tcp: number;
+            xtls: number;
+        };
+    };
     /**
      * Creates an instance of Reachability.
      * @param {object} webex
@@ -111,10 +137,75 @@ export default class Reachability {
      * @memberof Reachability
      */
     private logUnreachableClusters;
+    /**
+     * Returns true if we've obtained all the reachability results for all the public clusters
+     * In other words, it means that all public clusters are reachable over each protocol,
+     * because we only get a "result" if we managed to reach a cluster
+     *
+     * @returns {boolean}
+     */
+    private areAllPublicClusterResultsReady;
+    /**
+     * Returns true if we've obtained all the reachability results for all the clusters
+     *
+     * @returns {boolean}
+     */
+    private areAllResultsReady;
+    /**
+     * Resolves the promise returned by gatherReachability() method
+     * @returns {void}
+     */
+    private resolveReachabilityPromise;
+    /**
+     * Aborts all cluster reachability checks that are in progress
+     *
+     * @returns {void}
+     */
+    private abortClusterReachability;
+    /**
+     * Helper function for calculating min/max/average values of latency
+     *
+     * @param {Array<any>} results
+     * @param {string} protocol
+     * @param {boolean} isVideoMesh
+     * @returns {{min:number, max: number, average: number}}
+     */
+    protected getStatistics(results: Array<ClusterReachabilityResult & {
+        isVideoMesh: boolean;
+    }>, protocol: 'udp' | 'tcp' | 'xtls', isVideoMesh: boolean): {
+        min: number;
+        max: number;
+        average: number;
+    };
+    /**
+     * Sends a metric with all the statistics about how long reachability took
+     *
+     * @returns {void}
+     */
+    protected sendMetric(): Promise<void>;
+    /**
+     * Starts all the timers used for various timeouts
+     *
+     * @returns {void}
+     */
+    private startTimers;
+    /**
+     * Stores given reachability results in local storage
+     *
+     * @param {ReachabilityResults} results
+     * @returns {Promise<void>}
+     */
+    private storeResults;
+    /**
+     * Resets all the internal counters that keep track of the results
+     *
+     * @returns {void}
+     */
+    private resetResultCounters;
     /**
      * Performs reachability checks for all clusters
      * @param {ClusterList} clusterList
-     * @returns {Promise<ReachabilityResults>} reachability check results
+     * @returns {Promise<void>} promise that's resolved as soon as the checks are started
      */
     private performReachabilityChecks;
 }

package/dist/webinar/index.js

@@ -62,7 +62,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
   updateCanManageWebcast: function updateCanManageWebcast(canManageWebcast) {
     this.set('canManageWebcast', canManageWebcast);
   },
-  version: "3.3.1-next.14"
+  version: "3.3.1-next.16"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,7 +43,7 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.3.1-next.14",
+    "@webex/plugin-meetings": "3.3.1-next.16",
     "@webex/plugin-rooms": "3.3.1-next.3",
     "@webex/test-helper-chai": "3.3.1-next.2",
     "@webex/test-helper-mocha": "3.3.1-next.2",
@@ -70,10 +70,11 @@
     "@webex/internal-plugin-metrics": "3.3.1-next.2",
     "@webex/internal-plugin-support": "3.3.1-next.3",
     "@webex/internal-plugin-user": "3.3.1-next.2",
-    "@webex/internal-plugin-voicea": "3.3.1-next.14",
+    "@webex/internal-plugin-voicea": "3.3.1-next.16",
     "@webex/media-helpers": "3.3.1-next.4",
     "@webex/plugin-people": "3.3.1-next.3",
     "@webex/plugin-rooms": "3.3.1-next.3",
+    "@webex/web-capabilities": "^1.3.0",
     "@webex/webex-core": "3.3.1-next.2",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
@@ -91,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.3.1-next.14"
+  "version": "3.3.1-next.16"
 }

package/src/mediaQualityMetrics/config.ts

@@ -4,6 +4,11 @@ export const emptyMqaInterval = {
   intervalMetadata: {
     peerReflexiveIP: '0.0.0.0',
     peripherals: [],
+    cpuInfo: {
+      numberOfCores: 1, // default value from spec if CpuInfo.getNumLogicalCores cannot be determined
+      description: 'NA',
+      architecture: 'unknown',
+    },
     processAverageCPU: 0,
     processMaximumCPU: 0,
     systemAverageCPU: 0,

package/src/metrics/constants.ts

@@ -69,6 +69,7 @@ const BEHAVIORAL_METRICS = {
   ROAP_OFFER_TO_ANSWER_LATENCY: 'js_sdk_roap_offer_to_answer_latency',
   ROAP_HTTP_RESPONSE_MISSING: 'js_sdk_roap_http_response_missing',
   TURN_DISCOVERY_REQUIRES_OK: 'js_sdk_turn_discovery_requires_ok',
+  REACHABILITY_COMPLETED: 'js_sdk_reachability_completed',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/reachability/clusterReachability.ts

@@ -3,11 +3,9 @@ import {Defer} from '@webex/common';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClusterNode} from './request';
 import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
+import EventsScope from '../common/events/events-scope';
 
-import {ICE_GATHERING_STATE, CONNECTION_STATE} from '../constants';
-
-const DEFAULT_TIMEOUT = 3000;
-const VIDEO_MESH_TIMEOUT = 1000;
+import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
 
 // result for a specific transport protocol (like udp or tcp)
 export type TransportResult = {
@@ -23,10 +21,32 @@ export type ClusterReachabilityResult = {
   xtls: TransportResult;
 };
 
+// data for the Events.resultReady event
+export type ResultEventData = {
+  protocol: 'udp' | 'tcp' | 'xtls';
+  result: 'reachable' | 'unreachable' | 'untested';
+  latencyInMilliseconds: number; // amount of time it took to get the ICE candidate
+  clientMediaIPs?: string[];
+};
+
+// data for the Events.clientMediaIpsUpdated event
+export type ClientMediaIpsUpdatedEventData = {
+  protocol: 'udp' | 'tcp' | 'xtls';
+  clientMediaIPs: string[];
+};
+
+export const Events = {
+  resultReady: 'resultReady', // emitted when a cluster is reached successfully using specific protocol
+  clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when more public IPs are found after resultReady was already sent for a given protocol
+} as const;
+
+export type Events = Enum<typeof Events>;
+
 /**
  * A class that handles reachability checks for a single cluster.
+ * It emits events from Events enum
  */
-export class ClusterReachability {
+export class ClusterReachability extends EventsScope {
   private numUdpUrls: number;
   private numTcpUrls: number;
   private numXTlsUrls: number;
@@ -43,6 +63,7 @@ export class ClusterReachability {
    * @param {ClusterNode} clusterInfo information about the media cluster
    */
   constructor(name: string, clusterInfo: ClusterNode) {
+    super();
     this.name = name;
     this.isVideoMesh = clusterInfo.isVideoMesh;
     this.numUdpUrls = clusterInfo.udp.length;
@@ -162,23 +183,54 @@ export class ClusterReachability {
     this.defer.resolve();
   }
 
+  /**
+   * Aborts the cluster reachability checks by closing the peer connection
+   *
+   * @returns {void}
+   */
+  public abort() {
+    const {CLOSED} = CONNECTION_STATE;
+
+    if (this.pc.connectionState !== CLOSED) {
+      this.closePeerConnection();
+      this.finishReachabilityCheck();
+    }
+  }
+
   /**
    * Adds public IP (client media IPs)
    * @param {string} protocol
    * @param {string} publicIP
    * @returns {void}
    */
-  private addPublicIP(protocol: 'udp' | 'tcp', publicIP?: string | null) {
+  private addPublicIP(protocol: 'udp' | 'tcp' | 'xtls', publicIP?: string | null) {
     const result = this.result[protocol];
 
     if (publicIP) {
+      let ipAdded = false;
+
       if (result.clientMediaIPs) {
         if (!result.clientMediaIPs.includes(publicIP)) {
           result.clientMediaIPs.push(publicIP);
+          ipAdded = true;
         }
       } else {
         result.clientMediaIPs = [publicIP];
+        ipAdded = true;
       }
+
+      if (ipAdded)
+        this.emit(
+          {
+            file: 'clusterReachability',
+            function: 'addPublicIP',
+          },
+          Events.clientMediaIpsUpdated,
+          {
+            protocol,
+            clientMediaIPs: result.clientMediaIPs,
+          }
+        );
     }
   }
 
@@ -211,22 +263,43 @@ export class ClusterReachability {
   }
 
   /**
-   * Stores the latency in the result for the given protocol and marks it as reachable
+   * Saves the latency in the result for the given protocol and marks it as reachable,
+   * emits the "resultReady" event if this is the first result for that protocol,
+   * emits the "clientMediaIpsUpdated" event if we already had a result and only found
+   * a new client IP
    *
    * @param {string} protocol
    * @param {number} latency
+   * @param {string|null} [publicIp]
    * @returns {void}
    */
-  private storeLatencyResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number) {
+  private saveResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number, publicIp?: string | null) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
       LoggerProxy.logger.log(
         // @ts-ignore
-        `Reachability:index#storeLatencyResult --> Successfully reached ${this.name} over ${protocol}: ${latency}ms`
+        `Reachability:index#saveResult --> Successfully reached ${this.name} over ${protocol}: ${latency}ms`
       );
       result.latencyInMilliseconds = latency;
       result.result = 'reachable';
+      if (publicIp) {
+        result.clientMediaIPs = [publicIp];
+      }
+
+      this.emit(
+        {
+          file: 'clusterReachability',
+          function: 'saveResult',
+        },
+        Events.resultReady,
+        {
+          protocol,
+          ...result,
+        }
+      );
+    } else {
+      this.addPublicIP(protocol, publicIp);
     }
   }
 
@@ -243,15 +316,16 @@ export class ClusterReachability {
         RELAY: 'relay',
       };
 
+      const latencyInMilliseconds = this.getElapsedTime();
+
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-          this.storeLatencyResult('udp', this.getElapsedTime());
-          this.addPublicIP('udp', e.candidate.address);
+          this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
           const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-          this.storeLatencyResult(protocol, this.getElapsedTime());
+          this.saveResult(protocol, latencyInMilliseconds);
           // we don't add public IP for TCP, because in the case of relay candidates
           // e.candidate.address is the TURN server address, not the client's public IP
         }
@@ -314,22 +388,9 @@ export class ClusterReachability {
    * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
    */
   private gatherIceCandidates() {
-    const timeout = this.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT;
-
     this.registerIceGatheringStateChangeListener();
     this.registerIceCandidateListener();
 
-    // Set maximum timeout
-    setTimeout(() => {
-      const {CLOSED} = CONNECTION_STATE;
-
-      // Close any open peerConnections
-      if (this.pc.connectionState !== CLOSED) {
-        this.closePeerConnection();
-        this.finishReachabilityCheck();
-      }
-    }, timeout);
-
     return this.defer.promise;
   }
 }