@webex/plugin-meetings 3.3.1 → 3.4.0-next.10

package/dist/reachability/index.js

@@ -1,55 +1,108 @@
 "use strict";
 
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$keys2 = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
 var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
 var _entries = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/entries"));
 var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
-var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _lodash = require("lodash");
+var _common = require("@webex/common");
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
 var _util = _interopRequireDefault(require("../meeting/util"));
 var _constants = require("../constants");
 var _request = _interopRequireDefault(require("./request"));
 var _clusterReachability = require("./clusterReachability");
-/*!
+var _eventsScope = _interopRequireDefault(require("../common/events/events-scope"));
+var _constants2 = _interopRequireDefault(require("../metrics/constants"));
+var _metrics = _interopRequireDefault(require("../metrics"));
+function ownKeys(e, r) { var t = _Object$keys2(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-/* eslint-disable class-methods-use-this */
+ */ /* eslint-disable class-methods-use-this */
 /**
  * This is the type that matches what backend expects us to send to them. It is a bit weird, because
  * it uses strings instead of booleans and numbers, but that's what they require.
  */
+
 // this is the type that is required by the backend when we send them reachability results
+
 // this is the type used by Reachability class internally and stored in local storage
+
+// timeouts in seconds
+var DEFAULT_TIMEOUT = 3;
+var VIDEO_MESH_TIMEOUT = 1;
+var OVERALL_TIMEOUT = 15;
+
 /**
  * @class Reachability
  * @export
  */
-var Reachability = exports.default = /*#__PURE__*/function () {
+var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
+  (0, _inherits2.default)(Reachability, _EventsScope);
+  var _super = _createSuper(Reachability);
   /**
    * Creates an instance of Reachability.
    * @param {object} webex
    * @memberof Reachability
    */
   function Reachability(webex) {
+    var _this;
     (0, _classCallCheck2.default)(this, Reachability);
-    (0, _defineProperty2.default)(this, "namespace", _constants.REACHABILITY.namespace);
-    (0, _defineProperty2.default)(this, "webex", void 0);
-    (0, _defineProperty2.default)(this, "reachabilityRequest", void 0);
-    (0, _defineProperty2.default)(this, "clusterReachability", void 0);
-    this.webex = webex;
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "namespace", _constants.REACHABILITY.namespace);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webex", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "reachabilityRequest", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "clusterReachability", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "reachabilityDefer", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "vmnTimer", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "publicCloudTimer", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "overallTimer", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "expectedResultsCount", {
+      videoMesh: {
+        udp: 0
+      },
+      public: {
+        udp: 0,
+        tcp: 0,
+        xtls: 0
+      }
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "resultsCount", {
+      videoMesh: {
+        udp: 0
+      },
+      public: {
+        udp: 0,
+        tcp: 0,
+        xtls: 0
+      }
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "lastTrigger", void 0);
+    _this.webex = webex;
 
     /**
      * internal request object for the server
@@ -58,55 +111,114 @@ var Reachability = exports.default = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-    this.reachabilityRequest = new _request.default(this.webex);
-    this.clusterReachability = {};
+    _this.reachabilityRequest = new _request.default(_this.webex);
+    _this.clusterReachability = {};
+    return _this;
   }
 
   /**
-   * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
-   * @returns {Promise<ReachabilityResults>} reachability results
-   * @public
-   * @memberof Reachability
+   * Fetches the list of media clusters from the backend
+   * @param {boolean} isRetry
+   * @private
+   * @returns {Promise<{clusters: ClusterList, joinCookie: any}>}
    */
   (0, _createClass2.default)(Reachability, [{
-    key: "gatherReachability",
+    key: "getClusters",
     value: (function () {
-      var _gatherReachability = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var _yield$this$reachabil, clusters, joinCookie, results;
+      var _getClusters = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var isRetry,
+          _yield$this$reachabil,
+          clusters,
+          joinCookie,
+          _args = arguments;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _context.prev = 0;
-              _context.next = 3;
+              isRetry = _args.length > 0 && _args[0] !== undefined ? _args[0] : false;
+              _context.prev = 1;
+              _context.next = 4;
               return this.reachabilityRequest.getClusters(_util.default.getIpVersion(this.webex));
-            case 3:
+            case 4:
               _yield$this$reachabil = _context.sent;
               clusters = _yield$this$reachabil.clusters;
               joinCookie = _yield$this$reachabil.joinCookie;
-              _context.next = 8;
-              return this.performReachabilityChecks(clusters);
-            case 8:
-              results = _context.sent;
-              _context.next = 11;
-              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageResult, (0, _stringify.default)(results));
-            case 11:
-              _context.next = 13;
+              return _context.abrupt("return", {
+                clusters: clusters,
+                joinCookie: joinCookie
+              });
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](1);
+              if (!isRetry) {
+                _context.next = 14;
+                break;
+              }
+              throw _context.t0;
+            case 14:
+              _loggerProxy.default.logger.error("Reachability:index#getClusters --> Failed with error: ".concat(_context.t0, ", retrying..."));
+              return _context.abrupt("return", this.getClusters(true));
+            case 16:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[1, 10]]);
+      }));
+      function getClusters() {
+        return _getClusters.apply(this, arguments);
+      }
+      return getClusters;
+    }()
+    /**
+     * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
+     * @param {string} trigger - explains the reason for starting reachability
+     * @returns {Promise<ReachabilityResults>} reachability results
+     * @public
+     * @memberof Reachability
+     */
+    )
+  }, {
+    key: "gatherReachability",
+    value: (function () {
+      var _gatherReachability = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(trigger) {
+        var _yield$this$getCluste, clusters, joinCookie;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              this.lastTrigger = trigger;
+
+              // kick off ip version detection. For now we don't await it, as we're doing it
+              // to gather the timings and send them with our reachability metrics
+              // @ts-ignore
+              this.webex.internal.device.ipNetworkDetector.detect();
+              _context2.next = 5;
+              return this.getClusters();
+            case 5:
+              _yield$this$getCluste = _context2.sent;
+              clusters = _yield$this$getCluste.clusters;
+              joinCookie = _yield$this$getCluste.joinCookie;
+              _context2.next = 10;
               return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageJoinCookie, (0, _stringify.default)(joinCookie));
+            case 10:
+              this.reachabilityDefer = new _common.Defer();
+
+              // Perform Reachability Check
+              _context2.next = 13;
+              return this.performReachabilityChecks(clusters);
             case 13:
-              _loggerProxy.default.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
-              return _context.abrupt("return", results);
-            case 17:
-              _context.prev = 17;
-              _context.t0 = _context["catch"](0);
-              _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error:", _context.t0);
-              return _context.abrupt("return", {});
-            case 21:
+              return _context2.abrupt("return", this.reachabilityDefer.promise);
+            case 16:
+              _context2.prev = 16;
+              _context2.t0 = _context2["catch"](0);
+              _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error:", _context2.t0);
+              return _context2.abrupt("return", {});
+            case 20:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
-        }, _callee, this, [[0, 17]]);
+        }, _callee2, this, [[0, 16]]);
       }));
-      function gatherReachability() {
+      function gatherReachability(_x) {
         return _gatherReachability.apply(this, arguments);
       }
       return gatherReachability;
@@ -121,10 +233,10 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }, {
     key: "getReachabilityMetrics",
     value: (function () {
-      var _getReachabilityMetrics = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var _getReachabilityMetrics = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
         var stats, updateStats, resultsJson, results;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
               stats = {
                 reachability_public_udp_success: 0,
@@ -154,29 +266,29 @@ var Reachability = exports.default = /*#__PURE__*/function () {
                   stats["reachability_".concat(clusterType, "_xtls_").concat(_outcome2)] += 1;
                 }
               };
-              _context2.prev = 2;
-              _context2.next = 5;
+              _context3.prev = 2;
+              _context3.next = 5;
               return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
             case 5:
-              resultsJson = _context2.sent;
+              resultsJson = _context3.sent;
               results = JSON.parse(resultsJson);
               (0, _values.default)(results).forEach(function (result) {
                 updateStats(result.isVideoMesh ? 'vmn' : 'public', result);
               });
-              _context2.next = 13;
+              _context3.next = 13;
               break;
             case 10:
-              _context2.prev = 10;
-              _context2.t0 = _context2["catch"](2);
+              _context3.prev = 10;
+              _context3.t0 = _context3["catch"](2);
               // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#getReachabilityMetrics --> Error parsing reachability data: ', _context2.t0);
+              _loggerProxy.default.logger.warn('Roap:request#getReachabilityMetrics --> Error parsing reachability data: ', _context3.t0);
             case 13:
-              return _context2.abrupt("return", stats);
+              return _context3.abrupt("return", stats);
             case 14:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this, [[2, 10]]);
+        }, _callee3, this, [[2, 10]]);
       }));
       function getReachabilityMetrics() {
         return _getReachabilityMetrics.apply(this, arguments);
@@ -229,45 +341,45 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }, {
     key: "getReachabilityResults",
     value: (function () {
-      var _getReachabilityResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
-        var _this = this;
+      var _getReachabilityResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+        var _this2 = this;
         var results, resultsJson, allClusterResults;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
             case 0:
-              _context3.prev = 0;
-              _context3.next = 3;
+              _context4.prev = 0;
+              _context4.next = 3;
               return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
             case 3:
-              resultsJson = _context3.sent;
+              resultsJson = _context4.sent;
               allClusterResults = JSON.parse(resultsJson);
               results = (0, _lodash.mapValues)(allClusterResults, function (clusterResult) {
                 return {
-                  udp: _this.mapTransportResultToBackendDataFormat(clusterResult.udp || {
+                  udp: _this2.mapTransportResultToBackendDataFormat(clusterResult.udp || {
                     result: 'untested'
                   }),
-                  tcp: _this.mapTransportResultToBackendDataFormat(clusterResult.tcp || {
+                  tcp: _this2.mapTransportResultToBackendDataFormat(clusterResult.tcp || {
                     result: 'untested'
                   }),
-                  xtls: _this.mapTransportResultToBackendDataFormat(clusterResult.xtls || {
+                  xtls: _this2.mapTransportResultToBackendDataFormat(clusterResult.xtls || {
                     result: 'untested'
                   })
                 };
               });
-              _context3.next = 11;
+              _context4.next = 11;
               break;
             case 8:
-              _context3.prev = 8;
-              _context3.t0 = _context3["catch"](0);
+              _context4.prev = 8;
+              _context4.t0 = _context4["catch"](0);
               // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#attachReachabilityData --> Error parsing reachability data: ', _context3.t0);
+              _loggerProxy.default.logger.warn('Roap:request#attachReachabilityData --> Error parsing reachability data: ', _context4.t0);
             case 11:
-              return _context3.abrupt("return", results);
+              return _context4.abrupt("return", results);
             case 12:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
-        }, _callee3, this, [[0, 8]]);
+        }, _callee4, this, [[0, 8]]);
       }));
       function getReachabilityResults() {
         return _getReachabilityResults.apply(this, arguments);
@@ -284,16 +396,16 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }, {
     key: "isAnyPublicClusterReachable",
     value: (function () {
-      var _isAnyPublicClusterReachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var _isAnyPublicClusterReachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
         var reachable, reachabilityData, reachabilityResults;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
             case 0:
               reachable = false; // @ts-ignore
-              _context4.next = 3;
+              _context5.next = 3;
               return this.webex.boundedStorage.get(this.namespace, _constants.REACHABILITY.localStorageResult).catch(function () {});
             case 3:
-              reachabilityData = _context4.sent;
+              reachabilityData = _context5.sent;
               if (reachabilityData) {
                 try {
                   reachabilityResults = JSON.parse(reachabilityData);
@@ -305,12 +417,12 @@ var Reachability = exports.default = /*#__PURE__*/function () {
                   _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
                 }
               }
-              return _context4.abrupt("return", reachable);
+              return _context5.abrupt("return", reachable);
             case 6:
             case "end":
-              return _context4.stop();
+              return _context5.stop();
           }
-        }, _callee4, this);
+        }, _callee5, this);
       }));
       function isAnyPublicClusterReachable() {
         return _isAnyPublicClusterReachable.apply(this, arguments);
@@ -331,16 +443,16 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }, {
     key: "isWebexMediaBackendUnreachable",
     value: (function () {
-      var _isWebexMediaBackendUnreachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var _isWebexMediaBackendUnreachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
         var unreachable, reachabilityData, reachabilityResults, protocols;
-        return _regenerator.default.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
               unreachable = false; // @ts-ignore
-              _context5.next = 3;
+              _context6.next = 3;
               return this.webex.boundedStorage.get(this.namespace, _constants.REACHABILITY.localStorageResult).catch(function () {});
             case 3:
-              reachabilityData = _context5.sent;
+              reachabilityData = _context6.sent;
               if (reachabilityData) {
                 try {
                   reachabilityResults = JSON.parse(reachabilityData);
@@ -378,12 +490,12 @@ var Reachability = exports.default = /*#__PURE__*/function () {
                   _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
                 }
               }
-              return _context5.abrupt("return", unreachable);
+              return _context6.abrupt("return", unreachable);
             case 6:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
-        }, _callee5, this);
+        }, _callee6, this);
       }));
       function isWebexMediaBackendUnreachable() {
         return _isWebexMediaBackendUnreachable.apply(this, arguments);
@@ -445,71 +557,390 @@ var Reachability = exports.default = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * 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}
+     */
+  }, {
+    key: "areAllPublicClusterResultsReady",
+    value: function areAllPublicClusterResultsReady() {
+      return (0, _lodash.isEqual)(this.expectedResultsCount.public, this.resultsCount.public);
+    }
+
+    /**
+     * Returns true if we've obtained all the reachability results for all the clusters
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "areAllResultsReady",
+    value: function areAllResultsReady() {
+      return (0, _lodash.isEqual)(this.expectedResultsCount, this.resultsCount);
+    }
+
+    /**
+     * Resolves the promise returned by gatherReachability() method
+     * @returns {void}
+     */
+  }, {
+    key: "resolveReachabilityPromise",
+    value: function resolveReachabilityPromise() {
+      var _this$reachabilityDef;
+      if (this.vmnTimer) {
+        clearTimeout(this.vmnTimer);
+      }
+      if (this.publicCloudTimer) {
+        clearTimeout(this.publicCloudTimer);
+      }
+      this.logUnreachableClusters();
+      (_this$reachabilityDef = this.reachabilityDefer) === null || _this$reachabilityDef === void 0 ? void 0 : _this$reachabilityDef.resolve();
+    }
+
+    /**
+     * Aborts all cluster reachability checks that are in progress
+     *
+     * @returns {void}
+     */
+  }, {
+    key: "abortClusterReachability",
+    value: function abortClusterReachability() {
+      (0, _values.default)(this.clusterReachability).forEach(function (clusterReachability) {
+        clusterReachability.abort();
+      });
+    }
+
+    /**
+     * 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}}
+     */
+  }, {
+    key: "getStatistics",
+    value: function getStatistics(results, protocol, isVideoMesh) {
+      var values = results.filter(function (result) {
+        return result.isVideoMesh === isVideoMesh;
+      }).filter(function (result) {
+        return result[protocol].result === 'reachable';
+      }).map(function (result) {
+        return result[protocol].latencyInMilliseconds;
+      });
+      if (values.length === 0) {
+        return {
+          min: -1,
+          max: -1,
+          average: -1
+        };
+      }
+      return {
+        min: Math.min.apply(Math, (0, _toConsumableArray2.default)(values)),
+        max: Math.max.apply(Math, (0, _toConsumableArray2.default)(values)),
+        average: (0, _lodash.mean)(values)
+      };
+    }
+
+    /**
+     * Sends a metric with all the statistics about how long reachability took
+     *
+     * @returns {void}
+     */
+  }, {
+    key: "sendMetric",
+    value: (function () {
+      var _sendMetric = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+        var results, stats;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              results = [];
+              (0, _values.default)(this.clusterReachability).forEach(function (clusterReachability) {
+                results.push(_objectSpread(_objectSpread({}, clusterReachability.getResult()), {}, {
+                  isVideoMesh: clusterReachability.isVideoMesh
+                }));
+              });
+              stats = {
+                vmn: {
+                  udp: this.getStatistics(results, 'udp', true)
+                },
+                public: {
+                  udp: this.getStatistics(results, 'udp', false),
+                  tcp: this.getStatistics(results, 'tcp', false),
+                  xtls: this.getStatistics(results, 'xtls', false)
+                },
+                ipver: {
+                  // @ts-ignore
+                  firstIpV4: this.webex.internal.device.ipNetworkDetector.firstIpV4,
+                  // @ts-ignore
+                  firstIpV6: this.webex.internal.device.ipNetworkDetector.firstIpV6,
+                  // @ts-ignore
+                  firstMdns: this.webex.internal.device.ipNetworkDetector.firstMdns,
+                  // @ts-ignore
+                  totalTime: this.webex.internal.device.ipNetworkDetector.totalTime
+                },
+                trigger: this.lastTrigger
+              };
+              _metrics.default.sendBehavioralMetric(_constants2.default.REACHABILITY_COMPLETED, _metrics.default.prepareMetricFields(stats));
+            case 4:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function sendMetric() {
+        return _sendMetric.apply(this, arguments);
+      }
+      return sendMetric;
+    }()
+    /**
+     * Starts all the timers used for various timeouts
+     *
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "startTimers",
+    value: function startTimers() {
+      var _this3 = this;
+      this.vmnTimer = setTimeout(function () {
+        _this3.vmnTimer = undefined;
+        // if we are only missing VMN results, then we don't want to wait for them any longer
+        // as they are likely to fail if users are not on corporate network
+        if (_this3.areAllPublicClusterResultsReady()) {
+          _loggerProxy.default.logger.log('Reachability:index#startTimers --> Reachability checks timed out (VMN timeout)');
+          _this3.resolveReachabilityPromise();
+        }
+      }, VIDEO_MESH_TIMEOUT * 1000);
+      this.publicCloudTimer = setTimeout(function () {
+        _this3.publicCloudTimer = undefined;
+        _loggerProxy.default.logger.log("Reachability:index#startTimers --> Reachability checks timed out (".concat(DEFAULT_TIMEOUT, "s)"));
+
+        // resolve the promise, so that the client won't be blocked waiting on meetings.register() for too long
+        _this3.resolveReachabilityPromise();
+      }, DEFAULT_TIMEOUT * 1000);
+      this.overallTimer = setTimeout(function () {
+        _this3.overallTimer = undefined;
+        _this3.abortClusterReachability();
+        _this3.emit({
+          file: 'reachability',
+          function: 'overallTimer timeout'
+        }, 'reachability:done', {});
+        _this3.sendMetric();
+        _loggerProxy.default.logger.log("Reachability:index#startTimers --> Reachability checks fully timed out (".concat(OVERALL_TIMEOUT, "s)"));
+      }, OVERALL_TIMEOUT * 1000);
+    }
+
+    /**
+     * Stores given reachability results in local storage
+     *
+     * @param {ReachabilityResults} results
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "storeResults",
+    value: (function () {
+      var _storeResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(results) {
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageResult, (0, _stringify.default)(results));
+            case 2:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function storeResults(_x2) {
+        return _storeResults.apply(this, arguments);
+      }
+      return storeResults;
+    }()
+    /**
+     * Resets all the internal counters that keep track of the results
+     *
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "resetResultCounters",
+    value: function resetResultCounters() {
+      this.expectedResultsCount.videoMesh.udp = 0;
+      this.expectedResultsCount.public.udp = 0;
+      this.expectedResultsCount.public.tcp = 0;
+      this.expectedResultsCount.public.xtls = 0;
+      this.resultsCount.videoMesh.udp = 0;
+      this.resultsCount.public.udp = 0;
+      this.resultsCount.public.tcp = 0;
+      this.resultsCount.public.xtls = 0;
+    }
+
     /**
      * 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
      */
   }, {
     key: "performReachabilityChecks",
     value: (function () {
-      var _performReachabilityChecks = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(clusterList) {
-        var _this2 = this;
-        var results, clusterReachabilityChecks;
-        return _regenerator.default.wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+      var _performReachabilityChecks = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(clusterList) {
+        var _this4 = this;
+        var results, isFirstResult;
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
             case 0:
               results = {};
+              this.clusterReachability = {};
               if (!(!clusterList || !(0, _keys.default)(clusterList).length)) {
-                _context6.next = 3;
+                _context11.next = 4;
                 break;
               }
-              return _context6.abrupt("return", _promise.default.resolve(results));
-            case 3:
+              return _context11.abrupt("return");
+            case 4:
               _loggerProxy.default.logger.log("Reachability:index#performReachabilityChecks --> doing UDP".concat(
               // @ts-ignore
               this.webex.config.meetings.experimental.enableTcpReachability ? ',TCP' : '').concat(
               // @ts-ignore
               this.webex.config.meetings.experimental.enableTlsReachability ? ',TLS' : '', " reachability checks"));
-              clusterReachabilityChecks = (0, _keys.default)(clusterList).map(function (key) {
+              this.resetResultCounters();
+              this.startTimers();
+
+              // sanitize the urls in the clusterList
+              (0, _keys.default)(clusterList).forEach(function (key) {
                 var cluster = clusterList[key];
 
                 // Linus doesn't support TCP reachability checks on video mesh nodes
                 var includeTcpReachability =
                 // @ts-ignore
-                _this2.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
+                _this4.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
                 if (!includeTcpReachability) {
                   cluster.tcp = [];
                 }
+
+                // Linus doesn't support xTLS reachability checks on video mesh nodes
                 var includeTlsReachability =
                 // @ts-ignore
-                _this2.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
+                _this4.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
                 if (!includeTlsReachability) {
                   cluster.xtls = [];
                 }
-                _this2.clusterReachability[key] = new _clusterReachability.ClusterReachability(key, cluster);
-                return _this2.clusterReachability[key].start().then(function (result) {
-                  results[key] = result;
-                  results[key].isVideoMesh = cluster.isVideoMesh;
-                });
+
+                // initialize the result for this cluster
+                results[key] = {
+                  udp: {
+                    result: cluster.udp.length > 0 ? 'unreachable' : 'untested'
+                  },
+                  tcp: {
+                    result: cluster.tcp.length > 0 ? 'unreachable' : 'untested'
+                  },
+                  xtls: {
+                    result: cluster.xtls.length > 0 ? 'unreachable' : 'untested'
+                  },
+                  isVideoMesh: cluster.isVideoMesh
+                };
+
+                // update expected results counters to include this cluster
+                _this4.expectedResultsCount[cluster.isVideoMesh ? 'videoMesh' : 'public'].udp += cluster.udp.length;
+                if (!cluster.isVideoMesh) {
+                  _this4.expectedResultsCount.public.tcp += cluster.tcp.length;
+                  _this4.expectedResultsCount.public.xtls += cluster.xtls.length;
+                }
               });
-              _context6.next = 7;
-              return _promise.default.all(clusterReachabilityChecks);
-            case 7:
-              this.logUnreachableClusters();
-              return _context6.abrupt("return", results);
-            case 9:
+              isFirstResult = {
+                udp: true,
+                tcp: true,
+                xtls: true
+              }; // save the initialized results (in case we don't get any "resultReady" events at all)
+              _context11.next = 11;
+              return this.storeResults(results);
+            case 11:
+              // now start the reachability on all the clusters
+              (0, _keys.default)(clusterList).forEach(function (key) {
+                var cluster = clusterList[key];
+                _this4.clusterReachability[key] = new _clusterReachability.ClusterReachability(key, cluster);
+                _this4.clusterReachability[key].on(_clusterReachability.Events.resultReady, /*#__PURE__*/function () {
+                  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(data) {
+                    var protocol, result, clientMediaIPs, latencyInMilliseconds, areAllResultsReady;
+                    return _regenerator.default.wrap(function _callee9$(_context9) {
+                      while (1) switch (_context9.prev = _context9.next) {
+                        case 0:
+                          protocol = data.protocol, result = data.result, clientMediaIPs = data.clientMediaIPs, latencyInMilliseconds = data.latencyInMilliseconds;
+                          if (isFirstResult[protocol]) {
+                            _this4.emit({
+                              file: 'reachability',
+                              function: 'resultReady event handler'
+                            }, 'reachability:firstResultAvailable', {
+                              protocol: protocol
+                            });
+                            isFirstResult[protocol] = false;
+                          }
+                          _this4.resultsCount[cluster.isVideoMesh ? 'videoMesh' : 'public'][protocol] += 1;
+                          areAllResultsReady = _this4.areAllResultsReady();
+                          results[key][protocol].result = result;
+                          results[key][protocol].clientMediaIPs = clientMediaIPs;
+                          results[key][protocol].latencyInMilliseconds = latencyInMilliseconds;
+                          _context9.next = 9;
+                          return _this4.storeResults(results);
+                        case 9:
+                          if (areAllResultsReady) {
+                            clearTimeout(_this4.overallTimer);
+                            _this4.overallTimer = undefined;
+                            _this4.emit({
+                              file: 'reachability',
+                              function: 'performReachabilityChecks'
+                            }, 'reachability:done', {});
+                            _this4.sendMetric();
+                            _loggerProxy.default.logger.log("Reachability:index#gatherReachability --> Reachability checks fully completed");
+                            _this4.resolveReachabilityPromise();
+                          }
+                        case 10:
+                        case "end":
+                          return _context9.stop();
+                      }
+                    }, _callee9);
+                  }));
+                  return function (_x4) {
+                    return _ref4.apply(this, arguments);
+                  };
+                }());
+
+                // clientMediaIps can be updated independently from the results, so we need to listen for them too
+                _this4.clusterReachability[key].on(_clusterReachability.Events.clientMediaIpsUpdated, /*#__PURE__*/function () {
+                  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(data) {
+                    return _regenerator.default.wrap(function _callee10$(_context10) {
+                      while (1) switch (_context10.prev = _context10.next) {
+                        case 0:
+                          results[key][data.protocol].clientMediaIPs = data.clientMediaIPs;
+                          _context10.next = 3;
+                          return _this4.storeResults(results);
+                        case 3:
+                        case "end":
+                          return _context10.stop();
+                      }
+                    }, _callee10);
+                  }));
+                  return function (_x5) {
+                    return _ref5.apply(this, arguments);
+                  };
+                }());
+                _this4.clusterReachability[key].start(); // not awaiting on purpose
+              });
+            case 12:
             case "end":
-              return _context6.stop();
+              return _context11.stop();
           }
-        }, _callee6, this);
+        }, _callee11, this);
       }));
-      function performReachabilityChecks(_x) {
+      function performReachabilityChecks(_x3) {
         return _performReachabilityChecks.apply(this, arguments);
       }
       return performReachabilityChecks;
     }())
   }]);
   return Reachability;
-}();
+}(_eventsScope.default);
 //# sourceMappingURL=index.js.map