@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/dist/reachability/index.js

@@ -9,35 +9,26 @@ 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 _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
 var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
-var _lodash = require("lodash");
+var _uniq2 = _interopRequireDefault(require("lodash/uniq"));
 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");
-/*!
- * 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
+var DEFAULT_TIMEOUT = 3000;
+var VIDEO_MESH_TIMEOUT = 1000;
+
 /**
  * @class Reachability
  * @export
  */
-var Reachability = exports.default = /*#__PURE__*/function () {
+var Reachability = /*#__PURE__*/function () {
   /**
    * Creates an instance of Reachability.
    * @param {object} webex
@@ -45,10 +36,9 @@ var Reachability = exports.default = /*#__PURE__*/function () {
    */
   function Reachability(webex) {
     (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);
+    (0, _defineProperty2.default)(this, "clusterLatencyResults", void 0);
     this.webex = webex;
 
     /**
@@ -59,58 +49,69 @@ var Reachability = exports.default = /*#__PURE__*/function () {
      * @memberof Reachability
      */
     this.reachabilityRequest = new _request.default(this.webex);
-    this.clusterReachability = {};
+
+    /**
+     * internal object of clusters latency results
+     * @instance
+     * @type {object}
+     * @private
+     * @memberof Reachability
+     */
+    this.clusterLatencyResults = {};
   }
 
   /**
-   * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
-   * @returns {Promise<ReachabilityResults>} reachability results
+   * fetches reachability data
+   * @returns {Object} reachability data
    * @public
+   * @async
    * @memberof Reachability
    */
   (0, _createClass2.default)(Reachability, [{
     key: "gatherReachability",
-    value: (function () {
+    value: function () {
       var _gatherReachability = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var _yield$this$reachabil, clusters, joinCookie, results;
+        var _window, _window$localStorage;
+        var clusters, results;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _context.next = 2;
-              return this.webex.boundedStorage.del(this.namespace, _constants.REACHABILITY.localStorageResult);
-            case 2:
-              _context.next = 4;
-              return this.webex.boundedStorage.del(this.namespace, _constants.REACHABILITY.localStorageJoinCookie);
-            case 4:
-              _context.prev = 4;
+              this.setup();
+
+              // Remove stored reachability results to ensure no stale data
+              if (!((_window = window) !== null && _window !== void 0 && (_window$localStorage = _window.localStorage) !== null && _window$localStorage !== void 0 && _window$localStorage.removeItem)) {
+                _context.next = 5;
+                break;
+              }
+              window.localStorage.removeItem(_constants.REACHABILITY.localStorage);
               _context.next = 7;
-              return this.reachabilityRequest.getClusters(_util.default.getIpVersion(this.webex));
+              break;
+            case 5:
+              _loggerProxy.default.logger.error('Reachability:index#gatherReachability --> Error in accessing LocalStorage.');
+              return _context.abrupt("return", {});
             case 7:
-              _yield$this$reachabil = _context.sent;
-              clusters = _yield$this$reachabil.clusters;
-              joinCookie = _yield$this$reachabil.joinCookie;
-              _context.next = 12;
-              return this.performReachabilityChecks(clusters);
-            case 12:
+              _context.prev = 7;
+              _context.next = 10;
+              return this.reachabilityRequest.getClusters();
+            case 10:
+              clusters = _context.sent;
+              _context.next = 13;
+              return this.performReachabilityCheck(clusters);
+            case 13:
               results = _context.sent;
-              _context.next = 15;
-              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageResult, (0, _stringify.default)(results));
-            case 15:
-              _context.next = 17;
-              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageJoinCookie, (0, _stringify.default)(joinCookie));
-            case 17:
+              window.localStorage.setItem(_constants.REACHABILITY.localStorage, (0, _stringify.default)(results));
               _loggerProxy.default.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
               return _context.abrupt("return", results);
-            case 21:
-              _context.prev = 21;
-              _context.t0 = _context["catch"](4);
-              _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error:", _context.t0);
+            case 19:
+              _context.prev = 19;
+              _context.t0 = _context["catch"](7);
+              _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error in calling getClusters(): ".concat(_context.t0));
               return _context.abrupt("return", {});
-            case 25:
+            case 23:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[4, 21]]);
+        }, _callee, this, [[7, 19]]);
       }));
       function gatherReachability() {
         return _gatherReachability.apply(this, arguments);
@@ -118,235 +119,271 @@ var Reachability = exports.default = /*#__PURE__*/function () {
       return gatherReachability;
     }()
     /**
-     * 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.
+     * fetches reachability data and checks for cluster reachability
+     * @returns {boolean}
+     * @public
+     * @memberof Reachability
      */
-    )
   }, {
-    key: "getReachabilityMetrics",
-    value: (function () {
-      var _getReachabilityMetrics = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-        var stats, updateStats, resultsJson, results;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              stats = {
-                reachability_public_udp_success: 0,
-                reachability_public_udp_failed: 0,
-                reachability_public_tcp_success: 0,
-                reachability_public_tcp_failed: 0,
-                reachability_vmn_udp_success: 0,
-                reachability_vmn_udp_failed: 0,
-                reachability_vmn_tcp_success: 0,
-                reachability_vmn_tcp_failed: 0
-              };
-              updateStats = function updateStats(clusterType, result) {
-                if (result.udp && result.udp.result !== 'untested') {
-                  var outcome = result.udp.result === 'reachable' ? 'success' : 'failed';
-                  stats["reachability_".concat(clusterType, "_udp_").concat(outcome)] += 1;
-                }
-                if (result.tcp && result.tcp.result !== 'untested') {
-                  var _outcome = result.tcp.result === 'reachable' ? 'success' : 'failed';
-                  stats["reachability_".concat(clusterType, "_tcp_").concat(_outcome)] += 1;
-                }
-              };
-              _context2.prev = 2;
-              _context2.next = 5;
-              return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
-            case 5:
-              resultsJson = _context2.sent;
-              results = JSON.parse(resultsJson);
-              (0, _values.default)(results).forEach(function (result) {
-                updateStats(result.isVideoMesh ? 'vmn' : 'public', result);
-              });
-              _context2.next = 13;
-              break;
-            case 10:
-              _context2.prev = 10;
-              _context2.t0 = _context2["catch"](2);
-              // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#getReachabilityMetrics --> Error parsing reachability data: ', _context2.t0);
-            case 13:
-              return _context2.abrupt("return", stats);
-            case 14:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[2, 10]]);
-      }));
-      function getReachabilityMetrics() {
-        return _getReachabilityMetrics.apply(this, arguments);
+    key: "isAnyClusterReachable",
+    value: function isAnyClusterReachable() {
+      var reachable = false;
+      var reachabilityData = window.localStorage.getItem(_constants.REACHABILITY.localStorage);
+      if (reachabilityData) {
+        try {
+          var reachabilityResults = JSON.parse(reachabilityData);
+          reachable = (0, _values.default)(reachabilityResults).some(function (result) {
+            var _result$udp, _result$tcp;
+            return ((_result$udp = result.udp) === null || _result$udp === void 0 ? void 0 : _result$udp.reachable) === 'true' || ((_result$tcp = result.tcp) === null || _result$tcp === void 0 ? void 0 : _result$tcp.reachable) === 'true';
+          });
+        } catch (e) {
+          _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
+        }
       }
-      return getReachabilityMetrics;
-    }()
+      return reachable;
+    }
+
     /**
-     * Maps our internal transport result to the format that backend expects
-     * @param {TransportResult} transportResult
-     * @returns {TransportResultForBackend}
+     * Generate peerConnection config settings
+     * @param {object} cluster
+     * @returns {object} peerConnectionConfig
+     * @private
+     * @memberof Reachability
      */
-    )
   }, {
-    key: "mapTransportResultToBackendDataFormat",
-    value: function mapTransportResultToBackendDataFormat(transportResult) {
-      var output = {};
-      for (var _i = 0, _Object$entries = (0, _entries.default)(transportResult); _i < _Object$entries.length; _i++) {
-        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
-          _key = _Object$entries$_i[0],
-          value = _Object$entries$_i[1];
-        switch (_key) {
-          case 'result':
-            switch (value) {
-              case 'reachable':
-                output.reachable = 'true';
-                break;
-              case 'unreachable':
-                output.reachable = 'false';
-                break;
-              case 'untested':
-                output.untested = 'true';
-                break;
-            }
-            break;
-          case 'latencyInMilliseconds':
-            output.latencyInMilliseconds = value.toString();
-            break;
-          default:
-            output[_key] = value;
-        }
-      }
-      return output;
+    key: "buildPeerConnectionConfig",
+    value: function buildPeerConnectionConfig(cluster) {
+      var iceServers = (0, _uniq2.default)([].concat((0, _toConsumableArray2.default)(cluster.udp), (0, _toConsumableArray2.default)(cluster.tcp))).map(function (url) {
+        return {
+          username: '',
+          credential: '',
+          urls: [url]
+        };
+      });
+      return {
+        iceServers: (0, _toConsumableArray2.default)(iceServers),
+        iceCandidatePoolSize: '0',
+        iceTransportPolicy: 'all'
+      };
     }
 
     /**
-     * Reachability results as an object in the format that backend expects
-     *
-     * @returns {any} reachability results that need to be sent to the backend
+     * Creates an RTCPeerConnection
+     * @param {object} cluster
+     * @returns {RTCPeerConnection} peerConnection
+     * @private
+     * @memberof Reachability
      */
   }, {
-    key: "getReachabilityResults",
-    value: (function () {
-      var _getReachabilityResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
-        var _this = this;
-        var results, resultsJson, allClusterResults;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              _context3.prev = 0;
-              _context3.next = 3;
-              return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
-            case 3:
-              resultsJson = _context3.sent;
-              allClusterResults = JSON.parse(resultsJson);
-              results = (0, _lodash.mapValues)(allClusterResults, function (clusterResult) {
-                return {
-                  udp: _this.mapTransportResultToBackendDataFormat(clusterResult.udp || {
-                    result: 'untested'
-                  }),
-                  tcp: _this.mapTransportResultToBackendDataFormat(clusterResult.tcp || {
-                    result: 'untested'
-                  }),
-                  xtls: _this.mapTransportResultToBackendDataFormat(clusterResult.xtls || {
-                    result: 'untested'
-                  })
-                };
-              });
-              _context3.next = 11;
-              break;
-            case 8:
-              _context3.prev = 8;
-              _context3.t0 = _context3["catch"](0);
-              // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#attachReachabilityData --> Error parsing reachability data: ', _context3.t0);
-            case 11:
-              return _context3.abrupt("return", results);
-            case 12:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[0, 8]]);
-      }));
-      function getReachabilityResults() {
-        return _getReachabilityResults.apply(this, arguments);
+    key: "createPeerConnection",
+    value: function createPeerConnection(cluster) {
+      var key = cluster.key,
+        config = cluster.config;
+      try {
+        var peerConnection = new window.RTCPeerConnection(config);
+
+        // @ts-ignore
+        peerConnection.key = key;
+        return peerConnection;
+      } catch (peerConnectionError) {
+        _loggerProxy.default.logger.log("Reachability:index#createPeerConnection --> Error creating peerConnection: ".concat(peerConnectionError));
+        return null;
       }
-      return getReachabilityResults;
-    }()
+    }
+
     /**
-     * fetches reachability data and checks for cluster reachability
-     * @returns {boolean}
-     * @public
+     * Gets total elapsed time
+     * @param {RTCPeerConnection} peerConnection
+     * @returns {Number} Milliseconds
+     * @private
      * @memberof Reachability
      */
-    )
   }, {
-    key: "isAnyPublicClusterReachable",
-    value: (function () {
-      var _isAnyPublicClusterReachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
-        var reachable, reachabilityData, reachabilityResults;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              reachable = false; // @ts-ignore
-              _context4.next = 3;
-              return this.webex.boundedStorage.get(this.namespace, _constants.REACHABILITY.localStorageResult).catch(function () {});
-            case 3:
-              reachabilityData = _context4.sent;
-              if (reachabilityData) {
-                try {
-                  reachabilityResults = JSON.parse(reachabilityData);
-                  reachable = (0, _values.default)(reachabilityResults).some(function (result) {
-                    var _result$udp, _result$tcp;
-                    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));
-                }
-              }
-              return _context4.abrupt("return", reachable);
-            case 6:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function isAnyPublicClusterReachable() {
-        return _isAnyPublicClusterReachable.apply(this, arguments);
-      }
-      return isAnyPublicClusterReachable;
-    }()
+    key: "getElapsedTime",
+    value: function getElapsedTime(peerConnection) {
+      var startTime = peerConnection.begin;
+      delete peerConnection.begin;
+      return (0, _now.default)() - startTime;
+    }
+
+    /**
+     * creates offer and generates localSDP
+     * @param {object} clusterList cluster List
+     * @returns {Promise} Reachability latency results
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "getLocalSDPForClusters",
+    value: function getLocalSDPForClusters(clusterList) {
+      var _this = this;
+      var clusters = (0, _toConsumableArray2.default)((0, _keys.default)(clusterList));
+      clusters = clusters.map( /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(key) {
+          var cluster, config, peerConnection, description;
+          return _regenerator.default.wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                cluster = clusterList[key];
+                config = _this.buildPeerConnectionConfig(cluster);
+                peerConnection = _this.createPeerConnection({
+                  key: key,
+                  config: config
+                });
+                _context2.next = 5;
+                return peerConnection.createOffer({
+                  offerToReceiveAudio: true
+                });
+              case 5:
+                description = _context2.sent;
+                // @ts-ignore
+                peerConnection.begin = (0, _now.default)();
+                peerConnection.setLocalDescription(description);
+                return _context2.abrupt("return", _this.iceGatheringState(peerConnection, cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT).catch(function (iceGatheringStateError) {
+                  _loggerProxy.default.logger.log("Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ".concat(iceGatheringStateError));
+                }));
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+      return _promise.default.all(clusters).then(this.parseIceResultsToReachabilityResults).then(function (reachabilityLatencyResults) {
+        _this.logUnreachableClusters();
+
+        // return results
+        return reachabilityLatencyResults;
+      });
+    }
+
     /**
      * Get list of all unreachable clusters
      * @returns {array} Unreachable clusters
      * @private
      * @memberof Reachability
      */
-    )
   }, {
-    key: "getUnreachableClusters",
-    value: function getUnreachableClusters() {
+    key: "getUnreachablClusters",
+    value: function getUnreachablClusters() {
       var unreachableList = [];
-      (0, _entries.default)(this.clusterReachability).forEach(function (_ref) {
-        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-          key = _ref2[0],
-          clusterReachability = _ref2[1];
-        var result = clusterReachability.getResult();
-        if (result.udp.result === 'unreachable') {
-          unreachableList.push({
-            name: key,
-            protocol: 'udp'
-          });
-        }
-        if (result.tcp.result === 'unreachable') {
-          unreachableList.push({
-            name: key,
-            protocol: 'tcp'
-          });
+      var clusters = this.clusterLatencyResults;
+      (0, _keys.default)(clusters).forEach(function (key) {
+        var cluster = clusters[key];
+        if (cluster.unreachable && !cluster.reachable) {
+          unreachableList.push(key);
         }
       });
       return unreachableList;
     }
 
+    /**
+     * Attach an event handler for the icegatheringstatechange
+     * event and measure latency.
+     * @param {RTCPeerConnection} peerConnection
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "handleIceGatheringStateChange",
+    value: function handleIceGatheringStateChange(peerConnection) {
+      var _this2 = this;
+      peerConnection.onicegatheringstatechange = function () {
+        var COMPLETE = _constants.ICE_GATHERING_STATE.COMPLETE;
+        if (peerConnection.iceConnectionState === COMPLETE) {
+          var elapsed = _this2.getElapsedTime(peerConnection);
+
+          // @ts-ignore
+          _loggerProxy.default.logger.log( // @ts-ignore
+          "Reachability:index#onIceGatheringStateChange --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
+          _this2.setLatencyAndClose(peerConnection, elapsed);
+        }
+      };
+    }
+
+    /**
+     * Attach an event handler for the icecandidate
+     * event and measure latency.
+     * @param {RTCPeerConnection} peerConnection
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "handleOnIceCandidate",
+    value: function handleOnIceCandidate(peerConnection) {
+      var _this3 = this;
+      peerConnection.onicecandidate = function (e) {
+        var SERVER_REFLEXIVE = 'srflx';
+        if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
+          var elapsed = _this3.getElapsedTime(peerConnection);
+          _loggerProxy.default.logger.log( // @ts-ignore
+          "Reachability:index#onIceCandidate --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
+          _this3.setLatencyAndClose(peerConnection, elapsed);
+        }
+      };
+    }
+
+    /**
+     * An event handler on an RTCPeerConnection when the state of the ICE
+     * candidate gathering process changes. Used to measure connection
+     * speed.
+     * @private
+     * @param {RTCPeerConnection} peerConnection
+     * @param {number} timeout
+     * @returns {Promise}
+     */
+  }, {
+    key: "iceGatheringState",
+    value: function iceGatheringState(peerConnection, timeout) {
+      var _this4 = this;
+      var ELAPSED = 'elapsed';
+      return new _promise.default(function (resolve) {
+        var peerConnectionProxy = new window.Proxy(peerConnection, {
+          get: function get(target, property) {
+            var targetMember = target[property];
+            if (typeof targetMember === 'function') {
+              return targetMember.bind(target);
+            }
+            return targetMember;
+          },
+          set: function set(target, property, value) {
+            // only intercept elapsed property
+            if (property === ELAPSED) {
+              // @ts-ignore
+              resolve({
+                clusterId: peerConnection.key,
+                elapsed: value
+              });
+              return true;
+            }
+
+            // pass thru
+            return window.Reflect.set(target, property, value);
+          }
+        });
+
+        // Using peerConnection proxy so handle functions below
+        // won't be coupled to our promise implementation
+        _this4.handleIceGatheringStateChange(peerConnectionProxy);
+        _this4.handleOnIceCandidate(peerConnectionProxy);
+
+        // Set maximum timeout
+        window.setTimeout(function () {
+          var CLOSED = _constants.CONNECTION_STATE.CLOSED;
+
+          // Close any open peerConnections
+          if (peerConnectionProxy.connectionState !== CLOSED) {
+            _this4.setLatencyAndClose(peerConnectionProxy, null);
+          }
+        }, timeout);
+      });
+    }
+
     /**
      * Make a log of unreachable clusters.
      * @returns {undefined}
@@ -356,71 +393,122 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }, {
     key: "logUnreachableClusters",
     value: function logUnreachableClusters() {
-      var list = this.getUnreachableClusters();
-      list.forEach(function (_ref3) {
-        var name = _ref3.name,
-          protocol = _ref3.protocol;
-        _loggerProxy.default.logger.log("Reachability:index#logUnreachableClusters --> failed to reach ".concat(name, " over ").concat(protocol));
+      var list = this.getUnreachablClusters();
+      list.forEach(function (cluster) {
+        _loggerProxy.default.logger.log("Reachability:index#logUnreachableClusters --> No ice candidate for ".concat(cluster, "."));
       });
     }
 
     /**
-     * Performs reachability checks for all clusters
-     * @param {ClusterList} clusterList
-     * @returns {Promise<ReachabilityResults>} reachability check results
+     * Calculates time to establish connection
+     * @param {array} iceResults iceResults
+     * @returns {object} reachabilityMap
+     * @private
+     * @memberof Reachability
      */
   }, {
-    key: "performReachabilityChecks",
-    value: (function () {
-      var _performReachabilityChecks = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(clusterList) {
-        var _this2 = this;
-        var results, clusterReachabilityChecks;
-        return _regenerator.default.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              results = {};
-              if (!(!clusterList || !(0, _keys.default)(clusterList).length)) {
-                _context5.next = 3;
-                break;
-              }
-              return _context5.abrupt("return", _promise.default.resolve(results));
-            case 3:
-              _loggerProxy.default.logger.log("Reachability:index#performReachabilityChecks --> doing UDP".concat(
-              // @ts-ignore
-              this.webex.config.meetings.experimental.enableTcpReachability ? ' and TCP' : '', " reachability checks"));
-              clusterReachabilityChecks = (0, _keys.default)(clusterList).map(function (key) {
-                var cluster = clusterList[key];
+    key: "parseIceResultsToReachabilityResults",
+    value: function parseIceResultsToReachabilityResults(iceResults) {
+      var reachabilityMap = {};
+      iceResults.forEach(function (_ref2) {
+        var clusterId = _ref2.clusterId,
+          elapsed = _ref2.elapsed;
+        var latencyResult;
+        if (elapsed === null) {
+          latencyResult = {
+            reachable: 'false'
+          };
+        } else {
+          latencyResult = {
+            reachable: 'true',
+            latencyInMilliseconds: elapsed.toString()
+          };
+        }
+        reachabilityMap[clusterId] = {
+          udp: latencyResult,
+          tcp: latencyResult
+        };
+      });
+      return reachabilityMap;
+    }
 
-                // Linus doesn't support TCP reachability checks on video mesh nodes
-                var includeTcpReachability =
-                // @ts-ignore
-                _this2.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
-                if (!includeTcpReachability) {
-                  cluster.tcp = [];
-                }
-                _this2.clusterReachability[key] = new _clusterReachability.ClusterReachability(key, cluster);
-                return _this2.clusterReachability[key].start().then(function (result) {
-                  results[key] = result;
-                  results[key].isVideoMesh = cluster.isVideoMesh;
-                });
-              });
-              _context5.next = 7;
-              return _promise.default.all(clusterReachabilityChecks);
-            case 7:
-              this.logUnreachableClusters();
-              return _context5.abrupt("return", results);
-            case 9:
-            case "end":
-              return _context5.stop();
+    /**
+     * fetches reachability data
+     * @param {object} clusterList
+     * @returns {Promise<localSDPData>} reachability check results
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "performReachabilityCheck",
+    value: function performReachabilityCheck(clusterList) {
+      var _this5 = this;
+      if (!clusterList || !(0, _keys.default)(clusterList).length) {
+        return _promise.default.resolve({});
+      }
+      return new _promise.default(function (resolve) {
+        _this5.getLocalSDPForClusters(clusterList).then(function (localSDPData) {
+          if (!localSDPData || !(0, _keys.default)(localSDPData).length) {
+            // TODO: handle the error condition properly and try retry
+            _loggerProxy.default.logger.log('Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning');
+            resolve({});
+          } else {
+            resolve(localSDPData);
           }
-        }, _callee5, this);
-      }));
-      function performReachabilityChecks(_x) {
-        return _performReachabilityChecks.apply(this, arguments);
+        }).catch(function (error) {
+          _loggerProxy.default.logger.error("Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ".concat(error));
+          resolve({});
+        });
+      });
+    }
+
+    /**
+     * Records latency and closes the peerConnection
+     * @param {RTCPeerConnection} peerConnection
+     * @param {number} elapsed Latency in milliseconds
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "setLatencyAndClose",
+    value: function setLatencyAndClose(peerConnection, elapsed) {
+      var _intialState;
+      var REACHABLE = 'reachable';
+      var UNREACHABLE = 'unreachable';
+      var CLOSED = _constants.CONNECTION_STATE.CLOSED;
+      // @ts-ignore
+      var key = peerConnection.key;
+      var resultKey = elapsed === null ? UNREACHABLE : REACHABLE;
+      var intialState = (_intialState = {}, (0, _defineProperty2.default)(_intialState, REACHABLE, 0), (0, _defineProperty2.default)(_intialState, UNREACHABLE, 0), _intialState);
+      if (peerConnection.connectionState === CLOSED) {
+        _loggerProxy.default.logger.log("Reachability:index#setLatencyAndClose --> Attempting to set latency of ".concat(elapsed, " on closed peerConnection."));
+        return;
       }
-      return performReachabilityChecks;
-    }())
+      this.clusterLatencyResults[key] = this.clusterLatencyResults[key] || intialState;
+      this.clusterLatencyResults[key][resultKey] += 1;
+
+      // Set to null in case this fired from
+      // an event other than onIceCandidate
+      peerConnection.onicecandidate = null;
+      peerConnection.close();
+      // @ts-ignore
+      peerConnection.elapsed = elapsed;
+    }
+
+    /**
+     * utility function
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+  }, {
+    key: "setup",
+    value: function setup() {
+      this.clusterLatencyResults = {};
+    }
   }]);
   return Reachability;
 }();
+exports.default = Reachability;
 //# sourceMappingURL=index.js.map