@webex/plugin-meetings 3.7.0 → 3.8.0-next.10

package/dist/reachability/index.js

@@ -12,11 +12,11 @@ _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 _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"));
@@ -43,15 +43,6 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 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 */
-/**
- * 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;
@@ -77,6 +68,8 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
     (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), "minRequiredClusters", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "orpheusApiVersion", 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);
@@ -101,6 +94,8 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
         xtls: 0
       }
     });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "startTime", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "totalDuration", undefined);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "lastTrigger", void 0);
     _this.webex = webex;
 
@@ -118,6 +113,8 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
 
   /**
    * Fetches the list of media clusters from the backend
+   * @param {string} trigger - explains the reason for starting reachability, used by Orpheus
+   * @param {Object} previousReport - last reachability report
    * @param {boolean} isRetry
    * @private
    * @returns {Promise<{clusters: ClusterList, joinCookie: any}>}
@@ -125,45 +122,54 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
   (0, _createClass2.default)(Reachability, [{
     key: "getClusters",
     value: (function () {
-      var _getClusters = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var _getClusters = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(trigger, previousReport) {
         var isRetry,
           _yield$this$reachabil,
           clusters,
           joinCookie,
+          discoveryOptions,
           _args = arguments;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              isRetry = _args.length > 0 && _args[0] !== undefined ? _args[0] : false;
+              isRetry = _args.length > 2 && _args[2] !== undefined ? _args[2] : false;
               _context.prev = 1;
               _context.next = 4;
-              return this.reachabilityRequest.getClusters(_util.default.getIpVersion(this.webex));
+              return this.reachabilityRequest.getClusters(trigger, _util.default.getIpVersion(this.webex), previousReport);
             case 4:
               _yield$this$reachabil = _context.sent;
               clusters = _yield$this$reachabil.clusters;
               joinCookie = _yield$this$reachabil.joinCookie;
+              discoveryOptions = _yield$this$reachabil.discoveryOptions;
+              this.minRequiredClusters = discoveryOptions === null || discoveryOptions === void 0 ? void 0 : discoveryOptions['early-call-min-clusters'];
+              this.orpheusApiVersion = discoveryOptions === null || discoveryOptions === void 0 ? void 0 : discoveryOptions['report-version'];
+
+              // @ts-ignore
+              _context.next = 12;
+              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageJoinCookie, (0, _stringify.default)(joinCookie));
+            case 12:
               return _context.abrupt("return", {
                 clusters: clusters,
                 joinCookie: joinCookie
               });
-            case 10:
-              _context.prev = 10;
+            case 15:
+              _context.prev = 15;
               _context.t0 = _context["catch"](1);
               if (!isRetry) {
-                _context.next = 14;
+                _context.next = 19;
                 break;
               }
               throw _context.t0;
-            case 14:
+            case 19:
               _loggerProxy.default.logger.error("Reachability:index#getClusters --> Failed with error: ".concat(_context.t0, ", retrying..."));
-              return _context.abrupt("return", this.getClusters(true));
-            case 16:
+              return _context.abrupt("return", this.getClusters(trigger, previousReport, true));
+            case 21:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[1, 10]]);
+        }, _callee, this, [[1, 15]]);
       }));
-      function getClusters() {
+      function getClusters(_x, _x2) {
         return _getClusters.apply(this, arguments);
       }
       return getClusters;
@@ -180,63 +186,231 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
     key: "gatherReachability",
     value: (function () {
       var _gatherReachability = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(trigger) {
-        var _yield$this$getCluste, clusters, joinCookie;
+        var _yield$this$getCluste, clusters;
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              _context2.prev = 0;
+              if (this.webex.config.meetings.enableReachabilityChecks) {
+                _context2.next = 2;
+                break;
+              }
+              throw new Error('enableReachabilityChecks is disabled in config');
+            case 2:
+              _context2.prev = 2;
               this.lastTrigger = trigger;
 
               // kick off ip version detection. We don't await it, as we don't want to waste time
               // and if it fails, that's ok we can still carry on
               // @ts-ignore
               this.webex.internal.device.ipNetworkDetector.detect(true);
-              _context2.next = 5;
-              return this.getClusters();
-            case 5:
+              _context2.next = 7;
+              return this.getClusters('startup');
+            case 7:
               _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;
+              _context2.next = 12;
               return this.performReachabilityChecks(clusters);
-            case 13:
+            case 12:
               return _context2.abrupt("return", this.reachabilityDefer.promise);
-            case 16:
-              _context2.prev = 16;
-              _context2.t0 = _context2["catch"](0);
+            case 15:
+              _context2.prev = 15;
+              _context2.t0 = _context2["catch"](2);
               _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error:", _context2.t0);
               return _context2.abrupt("return", {});
-            case 20:
+            case 19:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 16]]);
+        }, _callee2, this, [[2, 15]]);
       }));
-      function gatherReachability(_x) {
+      function gatherReachability(_x3) {
         return _gatherReachability.apply(this, arguments);
       }
       return gatherReachability;
     }()
+    /**
+     * Gets the last join cookie we got from Orpheus
+     *
+     * @returns {Promise<Object>} join cookie
+     */
+    )
+  }, {
+    key: "getJoinCookie",
+    value: (function () {
+      var _getJoinCookie = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        var joinCookieRaw, joinCookie;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageJoinCookie).catch(function () {});
+            case 2:
+              joinCookieRaw = _context3.sent;
+              if (joinCookieRaw) {
+                try {
+                  joinCookie = JSON.parse(joinCookieRaw);
+                } catch (e) {
+                  _loggerProxy.default.logger.error("MeetingRequest#constructor --> Error in parsing join cookie data: ".concat(e));
+                }
+              }
+              return _context3.abrupt("return", joinCookie);
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function getJoinCookie() {
+        return _getJoinCookie.apply(this, arguments);
+      }
+      return getJoinCookie;
+    }()
+    /**
+     * Returns the reachability report that needs to be attached to the ROAP messages
+     * that we send to the backend.
+     *
+     * @returns {Promise<Object>}
+     */
+    )
+  }, {
+    key: "getReachabilityReport",
+    value: (function () {
+      var _getReachabilityReport = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+        var reachabilityResult, joinCookie;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.getReachabilityResults();
+            case 2:
+              reachabilityResult = _context4.sent;
+              _context4.next = 5;
+              return this.getJoinCookie();
+            case 5:
+              joinCookie = _context4.sent;
+              if (this.orpheusApiVersion) {
+                _context4.next = 8;
+                break;
+              }
+              return _context4.abrupt("return", {
+                reachability: reachabilityResult
+              });
+            case 8:
+              return _context4.abrupt("return", {
+                reachability: {
+                  version: 1,
+                  result: {
+                    usedDiscoveryOptions: {
+                      'early-call-min-clusters': this.minRequiredClusters
+                    },
+                    metrics: {
+                      'total-duration-ms': this.totalDuration
+                    },
+                    tests: reachabilityResult
+                  }
+                },
+                joinCookie: joinCookie
+              });
+            case 9:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function getReachabilityReport() {
+        return _getReachabilityReport.apply(this, arguments);
+      }
+      return getReachabilityReport;
+    }()
+    /**
+     * This method is called when we don't succeed in reaching the minimum number of clusters
+     * required by Orpheus. It sends the results to Orpheus and gets a new list that it tries to reach again.
+     * @returns {Promise<ReachabilityResults>} reachability results
+     * @public
+     * @memberof Reachability
+     */
+    )
+  }, {
+    key: "gatherReachabilityFallback",
+    value: (function () {
+      var _gatherReachabilityFallback = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        var reachabilityReport, _yield$this$getCluste2, clusters;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this.getReachabilityReport();
+            case 3:
+              reachabilityReport = _context5.sent;
+              _context5.next = 6;
+              return this.getClusters('early-call/no-min-reached', reachabilityReport);
+            case 6:
+              _yield$this$getCluste2 = _context5.sent;
+              clusters = _yield$this$getCluste2.clusters;
+              // stop all previous reachability checks that might still be going on in the background
+              this.abortCurrentChecks();
+
+              // Perform Reachability Check
+              _context5.next = 11;
+              return this.performReachabilityChecks(clusters);
+            case 11:
+              _context5.next = 16;
+              break;
+            case 13:
+              _context5.prev = 13;
+              _context5.t0 = _context5["catch"](0);
+              _loggerProxy.default.logger.error("Reachability:index#gatherReachabilityFallback --> Error:", _context5.t0);
+            case 16:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[0, 13]]);
+      }));
+      function gatherReachabilityFallback() {
+        return _gatherReachabilityFallback.apply(this, arguments);
+      }
+      return gatherReachabilityFallback;
+    }()
+    /**
+     * Stops all reachability checks that are in progress
+     * @public
+     * @memberof Reachability
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "stopReachability",
+    value: function stopReachability() {
+      // overallTimer is always there only if there is reachability in progress
+      if (this.overallTimer) {
+        _loggerProxy.default.logger.log('Reachability:index#stopReachability --> stopping reachability checks');
+        this.abortCurrentChecks();
+        this.emit({
+          file: 'reachability',
+          function: 'stopReachability'
+        }, 'reachability:stopped', {});
+        this.sendMetric(true);
+        this.resolveReachabilityPromise();
+      }
+    }
+
     /**
      * Returns statistics about last reachability results. The returned value is an object
      * with a flat list of properties so that it can be easily sent with metrics
      *
      * @returns {Promise} Promise with metrics values, it never rejects/throws.
      */
-    )
   }, {
     key: "getReachabilityMetrics",
     value: (function () {
-      var _getReachabilityMetrics = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var _getReachabilityMetrics = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
         var stats, updateStats, resultsJson, results;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
               stats = {
                 reachability_public_udp_success: 0,
@@ -266,29 +440,29 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                   stats["reachability_".concat(clusterType, "_xtls_").concat(_outcome2)] += 1;
                 }
               };
-              _context3.prev = 2;
-              _context3.next = 5;
+              _context6.prev = 2;
+              _context6.next = 5;
               return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
             case 5:
-              resultsJson = _context3.sent;
+              resultsJson = _context6.sent;
               results = JSON.parse(resultsJson);
               (0, _values.default)(results).forEach(function (result) {
                 updateStats(result.isVideoMesh ? 'vmn' : 'public', result);
               });
-              _context3.next = 13;
+              _context6.next = 13;
               break;
             case 10:
-              _context3.prev = 10;
-              _context3.t0 = _context3["catch"](2);
+              _context6.prev = 10;
+              _context6.t0 = _context6["catch"](2);
               // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#getReachabilityMetrics --> Error parsing reachability data: ', _context3.t0);
+              _loggerProxy.default.logger.warn('Roap:request#getReachabilityMetrics --> Error parsing reachability data: ', _context6.t0);
             case 13:
-              return _context3.abrupt("return", stats);
+              return _context6.abrupt("return", stats);
             case 14:
             case "end":
-              return _context3.stop();
+              return _context6.stop();
           }
-        }, _callee3, this, [[2, 10]]);
+        }, _callee6, this, [[2, 10]]);
       }));
       function getReachabilityMetrics() {
         return _getReachabilityMetrics.apply(this, arguments);
@@ -341,17 +515,17 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "getReachabilityResults",
     value: (function () {
-      var _getReachabilityResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var _getReachabilityResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
         var _this2 = this;
         var results, resultsJson, allClusterResults;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
             case 0:
-              _context4.prev = 0;
-              _context4.next = 3;
+              _context7.prev = 0;
+              _context7.next = 3;
               return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
             case 3:
-              resultsJson = _context4.sent;
+              resultsJson = _context7.sent;
               allClusterResults = JSON.parse(resultsJson);
               results = (0, _lodash.mapValues)(allClusterResults, function (clusterResult) {
                 return {
@@ -366,20 +540,20 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                   })
                 };
               });
-              _context4.next = 11;
+              _context7.next = 11;
               break;
             case 8:
-              _context4.prev = 8;
-              _context4.t0 = _context4["catch"](0);
+              _context7.prev = 8;
+              _context7.t0 = _context7["catch"](0);
               // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#attachReachabilityData --> Error parsing reachability data: ', _context4.t0);
+              _loggerProxy.default.logger.warn('Reachability:index#getReachabilityResults --> Error parsing reachability data: ', _context7.t0);
             case 11:
-              return _context4.abrupt("return", results);
+              return _context7.abrupt("return", results);
             case 12:
             case "end":
-              return _context4.stop();
+              return _context7.stop();
           }
-        }, _callee4, this, [[0, 8]]);
+        }, _callee7, this, [[0, 8]]);
       }));
       function getReachabilityResults() {
         return _getReachabilityResults.apply(this, arguments);
@@ -396,16 +570,16 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "isAnyPublicClusterReachable",
     value: (function () {
-      var _isAnyPublicClusterReachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var _isAnyPublicClusterReachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
         var reachable, reachabilityData, reachabilityResults;
-        return _regenerator.default.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
             case 0:
               reachable = false; // @ts-ignore
-              _context5.next = 3;
+              _context8.next = 3;
               return this.webex.boundedStorage.get(this.namespace, _constants.REACHABILITY.localStorageResult).catch(function () {});
             case 3:
-              reachabilityData = _context5.sent;
+              reachabilityData = _context8.sent;
               if (reachabilityData) {
                 try {
                   reachabilityResults = JSON.parse(reachabilityData);
@@ -414,15 +588,15 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                     return !result.isVideoMesh && (((_result$udp = result.udp) === null || _result$udp === void 0 ? void 0 : _result$udp.result) === 'reachable' || ((_result$tcp = result.tcp) === null || _result$tcp === void 0 ? void 0 : _result$tcp.result) === 'reachable');
                   });
                 } catch (e) {
-                  _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
+                  _loggerProxy.default.logger.error("Reachability:index#isAnyPublicClusterReachable --> Error in parsing reachability data: ".concat(e));
                 }
               }
-              return _context5.abrupt("return", reachable);
+              return _context8.abrupt("return", reachable);
             case 6:
             case "end":
-              return _context5.stop();
+              return _context8.stop();
           }
-        }, _callee5, this);
+        }, _callee8, this);
       }));
       function isAnyPublicClusterReachable() {
         return _isAnyPublicClusterReachable.apply(this, arguments);
@@ -443,16 +617,16 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "isWebexMediaBackendUnreachable",
     value: (function () {
-      var _isWebexMediaBackendUnreachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      var _isWebexMediaBackendUnreachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
         var unreachable, reachabilityData, reachabilityResults, protocols;
-        return _regenerator.default.wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
+        return _regenerator.default.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
             case 0:
               unreachable = false; // @ts-ignore
-              _context6.next = 3;
+              _context9.next = 3;
               return this.webex.boundedStorage.get(this.namespace, _constants.REACHABILITY.localStorageResult).catch(function () {});
             case 3:
-              reachabilityData = _context6.sent;
+              reachabilityData = _context9.sent;
               if (reachabilityData) {
                 try {
                   reachabilityResults = JSON.parse(reachabilityData);
@@ -487,15 +661,15 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                     return protocol.tested && !protocol.reachable;
                   });
                 } catch (e) {
-                  _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
+                  _loggerProxy.default.logger.error("Reachability:index#isWebexMediaBackendUnreachable --> Error in parsing reachability data: ".concat(e));
                 }
               }
-              return _context6.abrupt("return", unreachable);
+              return _context9.abrupt("return", unreachable);
             case 6:
             case "end":
-              return _context6.stop();
+              return _context9.stop();
           }
-        }, _callee6, this);
+        }, _callee9, this);
       }));
       function isWebexMediaBackendUnreachable() {
         return _isWebexMediaBackendUnreachable.apply(this, arguments);
@@ -540,6 +714,28 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
       return unreachableList;
     }
 
+    /**
+     * Gets the number of reachable clusters from last run reachability check
+     * @returns {number} reachable clusters count
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "getNumberOfReachableClusters",
+    value: function getNumberOfReachableClusters() {
+      var count = 0;
+      (0, _entries.default)(this.clusterReachability).forEach(function (_ref3) {
+        var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+          key = _ref4[0],
+          clusterReachability = _ref4[1];
+        var result = clusterReachability.getResult();
+        if (result.udp.result === 'reachable' || result.tcp.result === 'reachable' || result.xtls.result === 'reachable') {
+          count += 1;
+        }
+      });
+      return count;
+    }
+
     /**
      * Make a log of unreachable clusters.
      * @returns {undefined}
@@ -550,9 +746,9 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
     key: "logUnreachableClusters",
     value: function logUnreachableClusters() {
       var list = this.getUnreachableClusters();
-      list.forEach(function (_ref3) {
-        var name = _ref3.name,
-          protocol = _ref3.protocol;
+      list.forEach(function (_ref5) {
+        var name = _ref5.name,
+          protocol = _ref5.protocol;
         _loggerProxy.default.logger.log("Reachability:index#logUnreachableClusters --> failed to reach ".concat(name, " over ").concat(protocol));
       });
     }
@@ -583,20 +779,26 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
 
     /**
      * Resolves the promise returned by gatherReachability() method
+     * @param {boolean} checkMinRequiredClusters - if true, it will check if we have reached the minimum required clusters and do a fallback if needed
      * @returns {void}
      */
   }, {
     key: "resolveReachabilityPromise",
     value: function resolveReachabilityPromise() {
       var _this$reachabilityDef;
-      if (this.vmnTimer) {
-        clearTimeout(this.vmnTimer);
-      }
-      if (this.publicCloudTimer) {
-        clearTimeout(this.publicCloudTimer);
-      }
+      var checkMinRequiredClusters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      this.totalDuration = performance.now() - this.startTime;
+      this.clearTimer('vmnTimer');
+      this.clearTimer('publicCloudTimer');
       this.logUnreachableClusters();
       (_this$reachabilityDef = this.reachabilityDefer) === null || _this$reachabilityDef === void 0 ? void 0 : _this$reachabilityDef.resolve();
+      if (checkMinRequiredClusters) {
+        var numReachableClusters = this.getNumberOfReachableClusters();
+        if (this.minRequiredClusters && numReachableClusters < this.minRequiredClusters) {
+          _loggerProxy.default.logger.log("Reachability:index#resolveReachabilityPromise --> minRequiredClusters not reached (".concat(numReachableClusters, " < ").concat(this.minRequiredClusters, "), doing reachability fallback"));
+          this.gatherReachabilityFallback();
+        }
+      }
     }
 
     /**
@@ -647,16 +849,21 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
     /**
      * Sends a metric with all the statistics about how long reachability took
      *
+     * @param {boolean} aborted true if the reachability checks were aborted
      * @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) {
+      var _sendMetric = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10() {
+        var aborted,
+          results,
+          stats,
+          _args10 = arguments;
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
             case 0:
+              aborted = _args10.length > 0 && _args10[0] !== undefined ? _args10[0] : false;
               results = [];
               (0, _values.default)(this.clusterReachability).forEach(function (clusterReachability) {
                 results.push(_objectSpread(_objectSpread({}, clusterReachability.getResult()), {}, {
@@ -664,6 +871,7 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                 }));
               });
               stats = {
+                aborted: aborted,
                 vmn: {
                   udp: this.getStatistics(results, 'udp', true)
                 },
@@ -685,11 +893,11 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                 trigger: this.lastTrigger
               };
               _metrics.default.sendBehavioralMetric(_constants2.default.REACHABILITY_COMPLETED, _metrics.default.prepareMetricFields(stats));
-            case 4:
+            case 5:
             case "end":
-              return _context7.stop();
+              return _context10.stop();
           }
-        }, _callee7, this);
+        }, _callee10, this);
       }));
       function sendMetric() {
         return _sendMetric.apply(this, arguments);
@@ -719,6 +927,8 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
         _this3.publicCloudTimer = undefined;
         _loggerProxy.default.logger.log("Reachability:index#startTimers --> Reachability checks timed out (".concat(DEFAULT_TIMEOUT, "s)"));
 
+        // check against minimum required clusters, do a new call if we don't have enough
+
         // resolve the promise, so that the client won't be blocked waiting on meetings.register() for too long
         _this3.resolveReachabilityPromise();
       }, DEFAULT_TIMEOUT * 1000);
@@ -743,19 +953,19 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     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) {
+      var _storeResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(results) {
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
             case 0:
-              _context8.next = 2;
+              _context11.next = 2;
               return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageResult, (0, _stringify.default)(results));
             case 2:
             case "end":
-              return _context8.stop();
+              return _context11.stop();
           }
-        }, _callee8, this);
+        }, _callee11, this);
       }));
-      function storeResults(_x2) {
+      function storeResults(_x4) {
         return _storeResults.apply(this, arguments);
       }
       return storeResults;
@@ -779,6 +989,35 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
       this.resultsCount.public.xtls = 0;
     }
 
+    /**
+     * Clears the timer
+     *
+     * @param {string} timer name of the timer to clear
+     * @returns {void}
+     */
+  }, {
+    key: "clearTimer",
+    value: function clearTimer(timer) {
+      if (this[timer]) {
+        clearTimeout(this[timer]);
+        this[timer] = undefined;
+      }
+    }
+
+    /**
+     * Aborts current checks that are in progress
+     *
+     * @returns {void}
+     */
+  }, {
+    key: "abortCurrentChecks",
+    value: function abortCurrentChecks() {
+      this.clearTimer('vmnTimer');
+      this.clearTimer('publicCloudTimer');
+      this.clearTimer('overallTimer');
+      this.abortClusterReachability();
+    }
+
     /**
      * Performs reachability checks for all clusters
      * @param {ClusterList} clusterList
@@ -787,27 +1026,21 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
   }, {
     key: "performReachabilityChecks",
     value: (function () {
-      var _performReachabilityChecks = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(clusterList) {
+      var _performReachabilityChecks = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(clusterList) {
         var _this4 = this;
         var results, isFirstResult;
-        return _regenerator.default.wrap(function _callee11$(_context11) {
-          while (1) switch (_context11.prev = _context11.next) {
+        return _regenerator.default.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
             case 0:
               results = {};
               this.clusterReachability = {};
-              if (!(!clusterList || !(0, _keys.default)(clusterList).length)) {
-                _context11.next = 4;
-                break;
-              }
-              return _context11.abrupt("return");
-            case 4:
+              this.startTime = performance.now();
               _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"));
               this.resetResultCounters();
-              this.startTimers();
 
               // sanitize the urls in the clusterList
               (0, _keys.default)(clusterList).forEach(function (key) {
@@ -855,18 +1088,32 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                 tcp: true,
                 xtls: true
               }; // save the initialized results (in case we don't get any "resultReady" events at all)
-              _context11.next = 11;
+              _context14.next = 9;
               return this.storeResults(results);
-            case 11:
+            case 9:
+              if (!(!clusterList || !(0, _keys.default)(clusterList).length)) {
+                _context14.next = 13;
+                break;
+              }
+              // nothing to do, finish immediately
+              this.resolveReachabilityPromise(false);
+              this.emit({
+                file: 'reachability',
+                function: 'performReachabilityChecks'
+              }, 'reachability:done', {});
+              return _context14.abrupt("return");
+            case 13:
+              this.startTimers();
+
               // 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 _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(data) {
                     var protocol, result, clientMediaIPs, latencyInMilliseconds, areAllResultsReady;
-                    return _regenerator.default.wrap(function _callee9$(_context9) {
-                      while (1) switch (_context9.prev = _context9.next) {
+                    return _regenerator.default.wrap(function _callee12$(_context12) {
+                      while (1) switch (_context12.prev = _context12.next) {
                         case 0:
                           protocol = data.protocol, result = data.result, clientMediaIPs = data.clientMediaIPs, latencyInMilliseconds = data.latencyInMilliseconds;
                           if (isFirstResult[protocol]) {
@@ -883,12 +1130,11 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                           results[key][protocol].result = result;
                           results[key][protocol].clientMediaIPs = clientMediaIPs;
                           results[key][protocol].latencyInMilliseconds = latencyInMilliseconds;
-                          _context9.next = 9;
+                          _context12.next = 9;
                           return _this4.storeResults(results);
                         case 9:
                           if (areAllResultsReady) {
-                            clearTimeout(_this4.overallTimer);
-                            _this4.overallTimer = undefined;
+                            _this4.clearTimer('overallTimer');
                             _this4.emit({
                               file: 'reachability',
                               function: 'performReachabilityChecks'
@@ -899,46 +1145,131 @@ var Reachability = exports.default = /*#__PURE__*/function (_EventsScope) {
                           }
                         case 10:
                         case "end":
-                          return _context9.stop();
+                          return _context12.stop();
                       }
-                    }, _callee9);
+                    }, _callee12);
                   }));
-                  return function (_x4) {
-                    return _ref4.apply(this, arguments);
+                  return function (_x6) {
+                    return _ref6.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) {
+                  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(data) {
+                    return _regenerator.default.wrap(function _callee13$(_context13) {
+                      while (1) switch (_context13.prev = _context13.next) {
                         case 0:
                           results[key][data.protocol].clientMediaIPs = data.clientMediaIPs;
-                          _context10.next = 3;
+                          _context13.next = 3;
                           return _this4.storeResults(results);
                         case 3:
                         case "end":
-                          return _context10.stop();
+                          return _context13.stop();
                       }
-                    }, _callee10);
+                    }, _callee13);
                   }));
-                  return function (_x5) {
-                    return _ref5.apply(this, arguments);
+                  return function (_x7) {
+                    return _ref7.apply(this, arguments);
                   };
                 }());
                 _this4.clusterReachability[key].start(); // not awaiting on purpose
               });
-            case 12:
+            case 15:
             case "end":
-              return _context11.stop();
+              return _context14.stop();
           }
-        }, _callee11, this);
+        }, _callee14, this);
       }));
-      function performReachabilityChecks(_x3) {
+      function performReachabilityChecks(_x5) {
         return _performReachabilityChecks.apply(this, arguments);
       }
       return performReachabilityChecks;
+    }()
+    /**
+     * Returns the clientMediaPreferences object that needs to be sent to the backend
+     * when joining a meeting
+     *
+     * @param {boolean} isMultistream
+     * @param {IP_VERSION} ipver
+     * @returns {Object}
+     */
+    )
+  }, {
+    key: "getClientMediaPreferences",
+    value: (function () {
+      var _getClientMediaPreferences = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15(isMultistream, ipver) {
+        var reachabilityReport;
+        return _regenerator.default.wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              if (this.orpheusApiVersion) {
+                _context15.next = 7;
+                break;
+              }
+              _context15.t0 = ipver;
+              _context15.next = 4;
+              return this.getJoinCookie();
+            case 4:
+              _context15.t1 = _context15.sent;
+              _context15.t2 = !isMultistream;
+              return _context15.abrupt("return", {
+                ipver: _context15.t0,
+                joinCookie: _context15.t1,
+                preferTranscoding: _context15.t2
+              });
+            case 7:
+              _context15.next = 9;
+              return this.getReachabilityReport();
+            case 9:
+              reachabilityReport = _context15.sent;
+              return _context15.abrupt("return", _objectSpread({
+                ipver: ipver,
+                preferTranscoding: !isMultistream
+              }, reachabilityReport));
+            case 11:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function getClientMediaPreferences(_x8, _x9) {
+        return _getClientMediaPreferences.apply(this, arguments);
+      }
+      return getClientMediaPreferences;
+    }()
+    /**
+     * Returns the reachability report that needs to be attached to the ROAP messages
+     * that we send to the backend.
+     * It may return undefined, if reachability is not needed to be attached to ROAP messages (that's the case for v1 or Orpheus API)
+     *
+     * @returns {Promise<ReachabilityReportV0>} object that needs to be attached to Roap messages
+     */
+    )
+  }, {
+    key: "getReachabilityReportToAttachToRoap",
+    value: (function () {
+      var _getReachabilityReportToAttachToRoap = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
+        return _regenerator.default.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              if (this.orpheusApiVersion) {
+                _context16.next = 2;
+                break;
+              }
+              return _context16.abrupt("return", this.getReachabilityResults());
+            case 2:
+              return _context16.abrupt("return", undefined);
+            case 3:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function getReachabilityReportToAttachToRoap() {
+        return _getReachabilityReportToAttachToRoap.apply(this, arguments);
+      }
+      return getReachabilityReportToAttachToRoap;
     }())
   }]);
   return Reachability;