@webex/plugin-meetings 3.10.0 → 3.11.0

package/dist/reachability/clusterReachability.js

@@ -1,11 +1,10 @@
 "use strict";
 
 var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
-var _Object$keys = 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 _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
+var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
+var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
+var _Array$isArray = require("@babel/runtime-corejs2/core-js/array/is-array");
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 _Object$defineProperty(exports, "__esModule", {
@@ -14,27 +13,23 @@ _Object$defineProperty(exports, "__esModule", {
 exports.Events = exports.ClusterReachability = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
 var _set = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/set"));
-var _entries = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/entries"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 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 _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
-var _common = require("@webex/common");
-var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
-var _util = require("./util");
 var _eventsScope = _interopRequireDefault(require("../common/events/events-scope"));
-var _constants = require("../constants");
+var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
 var _reachability = require("./reachability.types");
-function ownKeys(e, r) { var t = _Object$keys(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; } }
+var _reachabilityPeerConnection = require("./reachabilityPeerConnection");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 // data for the Events.resultReady event
 
 // data for the Events.clientMediaIpsUpdated event
@@ -48,392 +43,233 @@ var Events = exports.Events = {
 };
 /**
  * A class that handles reachability checks for a single cluster.
- * It emits events from Events enum
+ * Creates and orchestrates ReachabilityPeerConnection instance(s).
+ * Listens to events and emits them to consumers.
+ *
+ * When enablePerUdpUrlReachability is true:
+ *   - Creates one ReachabilityPeerConnection for each UDP URL
+ *   - Creates one ReachabilityPeerConnection for all TCP and TLS URLs together
+ * Otherwise:
+ *   - Creates a single ReachabilityPeerConnection for all URLs
  */
 var ClusterReachability = exports.ClusterReachability = /*#__PURE__*/function (_EventsScope) {
-  (0, _inherits2.default)(ClusterReachability, _EventsScope);
-  var _super = _createSuper(ClusterReachability);
   /**
    * Constructor for ClusterReachability
    * @param {string} name cluster name
    * @param {ClusterNode} clusterInfo information about the media cluster
+   * @param {boolean} enablePerUdpUrlReachability whether to create separate peer connections per UDP URL
    */
   function ClusterReachability(name, clusterInfo) {
     var _this;
+    var enablePerUdpUrlReachability = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     (0, _classCallCheck2.default)(this, ClusterReachability);
-    _this = _super.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "numUdpUrls", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "numTcpUrls", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "numXTlsUrls", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "result", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "pc", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "defer", void 0);
-    // this defer is resolved once reachability checks for this cluster are completed
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "startTimestamp", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "srflxIceCandidates", []);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isVideoMesh", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "name", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "reachedSubnets", new _set.default());
+    _this = _callSuper(this, ClusterReachability);
+    (0, _defineProperty2.default)(_this, "reachabilityPeerConnection", null);
+    (0, _defineProperty2.default)(_this, "reachabilityPeerConnectionsForUdp", []);
+    (0, _defineProperty2.default)(_this, "isVideoMesh", void 0);
+    (0, _defineProperty2.default)(_this, "name", void 0);
+    (0, _defineProperty2.default)(_this, "reachedSubnets", new _set.default());
+    (0, _defineProperty2.default)(_this, "enablePerUdpUrlReachability", void 0);
+    (0, _defineProperty2.default)(_this, "udpResultEmitted", false);
     _this.name = name;
     _this.isVideoMesh = clusterInfo.isVideoMesh;
-    _this.numUdpUrls = clusterInfo.udp.length;
-    _this.numTcpUrls = clusterInfo.tcp.length;
-    _this.numXTlsUrls = clusterInfo.xtls.length;
-    _this.pc = _this.createPeerConnection(clusterInfo);
-    _this.defer = new _common.Defer();
-    _this.result = {
-      udp: {
-        result: 'untested'
-      },
-      tcp: {
-        result: 'untested'
-      },
-      xtls: {
-        result: 'untested'
-      }
-    };
+    _this.enablePerUdpUrlReachability = enablePerUdpUrlReachability;
+    if (_this.enablePerUdpUrlReachability) {
+      _this.initializePerUdpUrlReachabilityCheck(clusterInfo);
+    } else {
+      _this.initializeSingleReachabilityPeerConnection(clusterInfo);
+    }
     return _this;
   }
 
   /**
-   * Gets total elapsed time, can be called only after start() is called
-   * @returns {Number} Milliseconds
+   * Initializes a single ReachabilityPeerConnection for all protocols
+   * @param {ClusterNode} clusterInfo information about the media cluster
+   * @returns {void}
    */
-  (0, _createClass2.default)(ClusterReachability, [{
-    key: "getElapsedTime",
-    value: function getElapsedTime() {
-      return Math.round(performance.now() - this.startTimestamp);
-    }
-
-    /**
-     * Generate peerConnection config settings
-     * @param {ClusterNode} cluster
-     * @returns {RTCConfiguration} peerConnectionConfig
-     */
-  }, {
-    key: "buildPeerConnectionConfig",
-    value: function buildPeerConnectionConfig(cluster) {
-      var udpIceServers = cluster.udp.map(function (url) {
-        return {
-          username: '',
-          credential: '',
-          urls: [url]
-        };
-      });
-
-      // STUN servers are contacted only using UDP, so in order to test TCP reachability
-      // we pretend that Linus is a TURN server, because we can explicitly say "transport=tcp" in TURN urls.
-      // We then check for relay candidates to know if TURN-TCP worked (see registerIceCandidateListener()).
-      var tcpIceServers = cluster.tcp.map(function (urlString) {
-        return {
-          username: 'webexturnreachuser',
-          credential: 'webexturnreachpwd',
-          urls: [(0, _util.convertStunUrlToTurn)(urlString, 'tcp')]
-        };
-      });
-      var turnTlsIceServers = cluster.xtls.map(function (urlString) {
-        return {
-          username: 'webexturnreachuser',
-          credential: 'webexturnreachpwd',
-          urls: [(0, _util.convertStunUrlToTurnTls)(urlString)]
-        };
-      });
-      return {
-        iceServers: [].concat((0, _toConsumableArray2.default)(udpIceServers), (0, _toConsumableArray2.default)(tcpIceServers), (0, _toConsumableArray2.default)(turnTlsIceServers)),
-        iceCandidatePoolSize: 0,
-        iceTransportPolicy: 'all'
-      };
+  (0, _inherits2.default)(ClusterReachability, _EventsScope);
+  return (0, _createClass2.default)(ClusterReachability, [{
+    key: "initializeSingleReachabilityPeerConnection",
+    value: function initializeSingleReachabilityPeerConnection(clusterInfo) {
+      this.reachabilityPeerConnection = new _reachabilityPeerConnection.ReachabilityPeerConnection(this.name, clusterInfo);
+      this.setupReachabilityPeerConnectionEventListeners(this.reachabilityPeerConnection);
     }
 
     /**
-     * Creates an RTCPeerConnection
+     * Initializes per-URL UDP reachability checks:
+     * - One ReachabilityPeerConnection per UDP URL
+     * - One ReachabilityPeerConnection for all TCP and TLS URLs together
      * @param {ClusterNode} clusterInfo information about the media cluster
-     * @returns {RTCPeerConnection} peerConnection
-     */
-  }, {
-    key: "createPeerConnection",
-    value: function createPeerConnection(clusterInfo) {
-      try {
-        var config = this.buildPeerConnectionConfig(clusterInfo);
-        var peerConnection = new RTCPeerConnection(config);
-        return peerConnection;
-      } catch (peerConnectionError) {
-        _loggerProxy.default.logger.warn("Reachability:index#createPeerConnection --> Error creating peerConnection:", peerConnectionError);
-        return undefined;
-      }
-    }
-
-    /**
-     * @returns {ClusterReachabilityResult} reachability result for this cluster
-     */
-  }, {
-    key: "getResult",
-    value: function getResult() {
-      return this.result;
-    }
-
-    /**
-     * Closes the peerConnection
-     *
      * @returns {void}
      */
   }, {
-    key: "closePeerConnection",
-    value: function closePeerConnection() {
-      if (this.pc) {
-        this.pc.onicecandidate = null;
-        this.pc.onicegatheringstatechange = null;
-        this.pc.close();
-      }
-    }
+    key: "initializePerUdpUrlReachabilityCheck",
+    value: function initializePerUdpUrlReachabilityCheck(clusterInfo) {
+      var _this2 = this;
+      _loggerProxy.default.logger.log("ClusterReachability#initializePerUdpUrlReachabilityCheck --> cluster: ".concat(this.name, ", performing per-URL UDP reachability for ").concat(clusterInfo.udp.length, " URLs"));
 
-    /**
-     * Resolves the defer, indicating that reachability checks for this cluster are completed
-     *
-     * @returns {void}
-     */
-  }, {
-    key: "finishReachabilityCheck",
-    value: function finishReachabilityCheck() {
-      this.defer.resolve();
-    }
+      // Create one ReachabilityPeerConnection for each UDP URL
+      clusterInfo.udp.forEach(function (udpUrl) {
+        var singleUdpClusterInfo = {
+          isVideoMesh: clusterInfo.isVideoMesh,
+          udp: [udpUrl],
+          tcp: [],
+          xtls: []
+        };
+        var rpc = new _reachabilityPeerConnection.ReachabilityPeerConnection(_this2.name, singleUdpClusterInfo);
+        _this2.setupReachabilityPeerConnectionEventListeners(rpc, true);
+        _this2.reachabilityPeerConnectionsForUdp.push(rpc);
+      });
 
-    /**
-     * Aborts the cluster reachability checks by closing the peer connection
-     *
-     * @returns {void}
-     */
-  }, {
-    key: "abort",
-    value: function abort() {
-      var CLOSED = _constants.CONNECTION_STATE.CLOSED;
-      if (this.pc.connectionState !== CLOSED) {
-        this.closePeerConnection();
-        this.finishReachabilityCheck();
+      // Create one ReachabilityPeerConnection for all TCP and TLS URLs together
+      if (clusterInfo.tcp.length > 0 || clusterInfo.xtls.length > 0) {
+        var tcpTlsClusterInfo = {
+          isVideoMesh: clusterInfo.isVideoMesh,
+          udp: [],
+          tcp: clusterInfo.tcp,
+          xtls: clusterInfo.xtls
+        };
+        this.reachabilityPeerConnection = new _reachabilityPeerConnection.ReachabilityPeerConnection(this.name, tcpTlsClusterInfo);
+        this.setupReachabilityPeerConnectionEventListeners(this.reachabilityPeerConnection);
       }
     }
 
     /**
-     * Adds public IP (client media IPs)
-     * @param {string} protocol
-     * @param {string} publicIP
+     * Sets up event listeners for a ReachabilityPeerConnection instance
+     * @param {ReachabilityPeerConnection} rpc the ReachabilityPeerConnection instance
+     * @param {boolean} isUdpPerUrl whether this is a per-URL UDP instance
      * @returns {void}
      */
   }, {
-    key: "addPublicIP",
-    value: function addPublicIP(protocol, publicIP) {
-      var result = this.result[protocol];
-      if (publicIP) {
-        var ipAdded = false;
-        if (result.clientMediaIPs) {
-          if (!result.clientMediaIPs.includes(publicIP)) {
-            result.clientMediaIPs.push(publicIP);
-            ipAdded = true;
+    key: "setupReachabilityPeerConnectionEventListeners",
+    value: function setupReachabilityPeerConnectionEventListeners(rpc) {
+      var _this3 = this;
+      var isUdpPerUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      rpc.on(_reachability.ReachabilityPeerConnectionEvents.resultReady, function (data) {
+        // For per-URL UDP checks, only emit the first successful UDP result
+        if (isUdpPerUrl && data.protocol === 'udp') {
+          if (_this3.udpResultEmitted) {
+            return;
+          }
+          if (data.result === 'reachable') {
+            _this3.udpResultEmitted = true;
           }
-        } else {
-          result.clientMediaIPs = [publicIP];
-          ipAdded = true;
         }
-        if (ipAdded) this.emit({
+        _this3.emit({
           file: 'clusterReachability',
-          function: 'addPublicIP'
-        }, Events.clientMediaIpsUpdated, {
-          protocol: protocol,
-          clientMediaIPs: result.clientMediaIPs
-        });
-      }
-    }
-
-    /**
-     * Registers a listener for the iceGatheringStateChange event
-     *
-     * @returns {void}
-     */
-  }, {
-    key: "registerIceGatheringStateChangeListener",
-    value: function registerIceGatheringStateChangeListener() {
-      var _this2 = this;
-      this.pc.onicegatheringstatechange = function () {
-        if (_this2.pc.iceGatheringState === _constants.ICE_GATHERING_STATE.COMPLETE) {
-          _this2.closePeerConnection();
-          _this2.finishReachabilityCheck();
-        }
-      };
-    }
-
-    /**
-     * 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]
-     * @param {string|null} [serverIp]
-     * @returns {void}
-     */
-  }, {
-    key: "saveResult",
-    value: function saveResult(protocol, latency, publicIp, serverIp) {
-      var result = this.result[protocol];
-      if (result.latencyInMilliseconds === undefined) {
-        _loggerProxy.default.logger.log( // @ts-ignore
-        "Reachability:index#saveResult --> Successfully reached ".concat(this.name, " over ").concat(protocol, ": ").concat(latency, "ms"));
-        result.latencyInMilliseconds = latency;
-        result.result = 'reachable';
-        if (publicIp) {
-          result.clientMediaIPs = [publicIp];
-        }
-        this.emit({
+          function: 'setupReachabilityPeerConnectionEventListeners'
+        }, Events.resultReady, data);
+      });
+      rpc.on(_reachability.ReachabilityPeerConnectionEvents.clientMediaIpsUpdated, function (data) {
+        _this3.emit({
           file: 'clusterReachability',
-          function: 'saveResult'
-        }, Events.resultReady, _objectSpread({
-          protocol: protocol
-        }, result));
-      } else {
-        this.addPublicIP(protocol, publicIp);
-      }
-      if (serverIp) {
-        this.reachedSubnets.add(serverIp);
-      }
+          function: 'setupReachabilityPeerConnectionEventListeners'
+        }, Events.clientMediaIpsUpdated, data);
+      });
+      rpc.on(_reachability.ReachabilityPeerConnectionEvents.natTypeUpdated, function (data) {
+        _this3.emit({
+          file: 'clusterReachability',
+          function: 'setupReachabilityPeerConnectionEventListeners'
+        }, Events.natTypeUpdated, data);
+      });
+      rpc.on(_reachability.ReachabilityPeerConnectionEvents.reachedSubnets, function (data) {
+        data.subnets.forEach(function (subnet) {
+          _this3.reachedSubnets.add(subnet);
+        });
+      });
     }
 
     /**
-     * Determines NAT Type.
-     *
-     * @param {RTCIceCandidate} candidate
-     * @returns {void}
+     * Gets the aggregated reachability result for this cluster.
+     * @returns {ClusterReachabilityResult} reachability result for this cluster
      */
   }, {
-    key: "determineNatType",
-    value: function determineNatType(candidate) {
-      var _this3 = this;
-      this.srflxIceCandidates.push(candidate);
-      if (this.srflxIceCandidates.length > 1) {
-        var portsFound = {};
-        this.srflxIceCandidates.forEach(function (c) {
-          var key = "".concat(c.address, ":").concat(c.relatedPort);
-          if (!portsFound[key]) {
-            portsFound[key] = new _set.default();
-          }
-          portsFound[key].add(c.port);
-        });
-        (0, _entries.default)(portsFound).forEach(function (_ref) {
-          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-            ports = _ref2[1];
-          if (ports.size > 1) {
-            // Found candidates with the same address and relatedPort, but different ports
-            _this3.emit({
-              file: 'clusterReachability',
-              function: 'determineNatType'
-            }, Events.natTypeUpdated, {
-              natType: _reachability.NatType.SymmetricNat
-            });
+    key: "getResult",
+    value: function getResult() {
+      if (!this.enablePerUdpUrlReachability) {
+        var _this$reachabilityPee, _this$reachabilityPee2;
+        return (_this$reachabilityPee = (_this$reachabilityPee2 = this.reachabilityPeerConnection) === null || _this$reachabilityPee2 === void 0 ? void 0 : _this$reachabilityPee2.getResult()) !== null && _this$reachabilityPee !== void 0 ? _this$reachabilityPee : {
+          udp: {
+            result: 'untested'
+          },
+          tcp: {
+            result: 'untested'
+          },
+          xtls: {
+            result: 'untested'
           }
-        });
+        };
       }
-    }
+      var result = {
+        udp: {
+          result: 'untested'
+        },
+        tcp: {
+          result: 'untested'
+        },
+        xtls: {
+          result: 'untested'
+        }
+      };
 
-    /**
-     * Registers a listener for the icecandidate event
-     *
-     * @returns {void}
-     */
-  }, {
-    key: "registerIceCandidateListener",
-    value: function registerIceCandidateListener() {
-      var _this4 = this;
-      this.pc.onicecandidate = function (e) {
-        var TURN_TLS_PORT = 443;
-        var CANDIDATE_TYPES = {
-          SERVER_REFLEXIVE: 'srflx',
-          RELAY: 'relay'
-        };
-        var latencyInMilliseconds = _this4.getElapsedTime();
-        if (e.candidate) {
-          if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-            var serverIp = null;
-            if ('url' in e.candidate) {
-              var stunServerUrlRegex = /stun:([\d.]+):\d+/;
-              var match = e.candidate.url.match(stunServerUrlRegex);
-              if (match) {
-                // eslint-disable-next-line prefer-destructuring
-                serverIp = match[1];
-              }
-            }
-            _this4.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);
-            _this4.determineNatType(e.candidate);
+      // Get the first reachable UDP result from per-URL instances
+      var _iterator = _createForOfIteratorHelper(this.reachabilityPeerConnectionsForUdp),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var rpc = _step.value;
+          var rpcResult = rpc.getResult();
+          if (rpcResult.udp.result === 'reachable') {
+            result.udp = rpcResult.udp;
+            break;
           }
-          if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
-            var protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-            _this4.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);
+          if (rpcResult.udp.result === 'unreachable' && result.udp.result === 'untested') {
+            result.udp = rpcResult.udp;
           }
         }
-      };
+
+        // Get TCP and TLS results from the main peer connection
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (this.reachabilityPeerConnection) {
+        var mainResult = this.reachabilityPeerConnection.getResult();
+        result.tcp = mainResult.tcp;
+        result.xtls = mainResult.xtls;
+      }
+      return result;
     }
 
     /**
-     * Starts the process of doing UDP and TCP reachability checks on the media cluster.
-     * XTLS reachability checking is not supported.
-     *
-     * @returns {Promise}
+     * Starts the process of doing UDP, TCP, and XTLS reachability checks on the media cluster.
+     * @returns {Promise<ClusterReachabilityResult>}
      */
   }, {
     key: "start",
     value: (function () {
-      var _start = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var offer, gatherIceCandidatePromise;
-        return _regenerator.default.wrap(function _callee$(_context) {
+      var _start = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var startPromises;
+        return _regenerator.default.wrap(function (_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              if (this.pc) {
-                _context.next = 3;
-                break;
-              }
-              _loggerProxy.default.logger.warn("Reachability:ClusterReachability#start --> Error: peerConnection is undefined");
-              return _context.abrupt("return", this.result);
-            case 3:
-              // Initialize this.result as saying that nothing is reachable.
-              // It will get updated as we go along and successfully gather ICE candidates.
-              this.result.udp = {
-                result: this.numUdpUrls > 0 ? 'unreachable' : 'untested'
-              };
-              this.result.tcp = {
-                result: this.numTcpUrls > 0 ? 'unreachable' : 'untested'
-              };
-              this.result.xtls = {
-                result: this.numXTlsUrls > 0 ? 'unreachable' : 'untested'
-              };
-              _context.prev = 6;
-              _context.next = 9;
-              return this.pc.createOffer({
-                offerToReceiveAudio: true
+              startPromises = [];
+              this.reachabilityPeerConnectionsForUdp.forEach(function (rpc) {
+                startPromises.push(rpc.start());
               });
-            case 9:
-              offer = _context.sent;
-              this.startTimestamp = performance.now();
-
-              // Set up the state change listeners before triggering the ICE gathering
-              gatherIceCandidatePromise = this.gatherIceCandidates(); // not awaiting the next call on purpose, because we're not sending the offer anywhere and there won't be any answer
-              // we just need to make this call to trigger the ICE gathering process
-              this.pc.setLocalDescription(offer);
-              _context.next = 15;
-              return gatherIceCandidatePromise;
-            case 15:
-              _context.next = 20;
-              break;
-            case 17:
-              _context.prev = 17;
-              _context.t0 = _context["catch"](6);
-              _loggerProxy.default.logger.warn("Reachability:ClusterReachability#start --> Error: ", _context.t0);
-            case 20:
-              return _context.abrupt("return", this.result);
-            case 21:
+              if (this.reachabilityPeerConnection) {
+                startPromises.push(this.reachabilityPeerConnection.start());
+              }
+              _context.next = 1;
+              return _promise.default.all(startPromises);
+            case 1:
+              return _context.abrupt("return", this.getResult());
+            case 2:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[6, 17]]);
+        }, _callee, this);
       }));
       function start() {
         return _start.apply(this, arguments);
@@ -441,19 +277,19 @@ var ClusterReachability = exports.ClusterReachability = /*#__PURE__*/function (_
       return start;
     }()
     /**
-     * Starts the process of gathering ICE candidates
-     *
-     * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
+     * Aborts the cluster reachability checks
+     * @returns {void}
      */
     )
   }, {
-    key: "gatherIceCandidates",
-    value: function gatherIceCandidates() {
-      this.registerIceGatheringStateChangeListener();
-      this.registerIceCandidateListener();
-      return this.defer.promise;
+    key: "abort",
+    value: function abort() {
+      var _this$reachabilityPee3;
+      this.reachabilityPeerConnectionsForUdp.forEach(function (rpc) {
+        return rpc.abort();
+      });
+      (_this$reachabilityPee3 = this.reachabilityPeerConnection) === null || _this$reachabilityPee3 === void 0 ? void 0 : _this$reachabilityPee3.abort();
     }
   }]);
-  return ClusterReachability;
 }(_eventsScope.default);
 //# sourceMappingURL=clusterReachability.js.map