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

package/dist/reachability/index.js

@@ -12,39 +12,23 @@ var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/obj
 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 _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
 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"));
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-
-/* eslint-disable class-methods-use-this */
-/* globals window */
-
 var DEFAULT_TIMEOUT = 3000;
 var VIDEO_MESH_TIMEOUT = 1000;
 
-// result for a specific transport protocol (like udp or tcp)
-
-// reachability result for a specifc media cluster
-
-// 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
 /**
  * @class Reachability
  * @export
  */
-var Reachability = exports.default = /*#__PURE__*/function () {
+var Reachability = /*#__PURE__*/function () {
   /**
    * Creates an instance of Reachability.
    * @param {object} webex
@@ -52,7 +36,6 @@ 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, "clusterLatencyResults", void 0);
@@ -86,210 +69,80 @@ var Reachability = exports.default = /*#__PURE__*/function () {
    */
   (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:
               this.setup();
 
               // Remove stored reachability results to ensure no stale data
-              // @ts-ignore
-              _context.next = 3;
-              return this.webex.boundedStorage.del(this.namespace, _constants.REACHABILITY.localStorageResult);
-            case 3:
-              _context.next = 5;
-              return this.webex.boundedStorage.del(this.namespace, _constants.REACHABILITY.localStorageJoinCookie);
+              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;
+              break;
             case 5:
-              _context.prev = 5;
-              _context.next = 8;
-              return this.reachabilityRequest.getClusters(_util.default.getIpVersion(this.webex));
-            case 8:
-              _yield$this$reachabil = _context.sent;
-              clusters = _yield$this$reachabil.clusters;
-              joinCookie = _yield$this$reachabil.joinCookie;
+              _loggerProxy.default.logger.error('Reachability:index#gatherReachability --> Error in accessing LocalStorage.');
+              return _context.abrupt("return", {});
+            case 7:
+              _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 = 16;
-              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageResult, (0, _stringify.default)(results));
-            case 16:
-              _context.next = 18;
-              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageJoinCookie, (0, _stringify.default)(joinCookie));
-            case 18:
+              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 22:
-              _context.prev = 22;
-              _context.t0 = _context["catch"](5);
+            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 26:
+            case 23:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[5, 22]]);
+        }, _callee, this, [[7, 19]]);
       }));
       function gatherReachability() {
         return _gatherReachability.apply(this, arguments);
       }
       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.
-     */
-    )
-  }, {
-    key: "getReachabilityMetrics",
-    value: (function () {
-      var _getReachabilityMetrics = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-        var stats, updateStats, resultsJson, internalResults;
-        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) {
-                var _result$udp, _result$tcp;
-                if ((_result$udp = result.udp) !== null && _result$udp !== void 0 && _result$udp.reachable) {
-                  var outcome = result.udp.reachable === 'true' ? 'success' : 'failed';
-                  stats["reachability_".concat(clusterType, "_udp_").concat(outcome)] += 1;
-                }
-                if ((_result$tcp = result.tcp) !== null && _result$tcp !== void 0 && _result$tcp.reachable) {
-                  var _outcome = result.tcp.reachable === 'true' ? '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;
-              internalResults = JSON.parse(resultsJson);
-              (0, _values.default)(internalResults).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);
-      }
-      return getReachabilityMetrics;
-    }()
-    /**
-     * Reachability results as an object in the format that backend expects
-     *
-     * @returns {any} reachability results that need to be sent to the backend
-     */
-    )
-  }, {
-    key: "getReachabilityResults",
-    value: (function () {
-      var _getReachabilityResults = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
-        var results, reachabilityResultsProps, resultsJson, internalResults;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              // these are the only props that backend needs in the reachability results:
-              reachabilityResultsProps = ['udp', 'tcp', 'xtls'];
-              _context3.prev = 1;
-              _context3.next = 4;
-              return this.webex.boundedStorage.get(_constants.REACHABILITY.namespace, _constants.REACHABILITY.localStorageResult);
-            case 4:
-              resultsJson = _context3.sent;
-              internalResults = JSON.parse(resultsJson);
-              results = (0, _lodash.mapValues)(internalResults, function (result) {
-                return (0, _lodash.pick)(result, reachabilityResultsProps);
-              });
-              _context3.next = 12;
-              break;
-            case 9:
-              _context3.prev = 9;
-              _context3.t0 = _context3["catch"](1);
-              // empty storage, that's ok
-              _loggerProxy.default.logger.warn('Roap:request#attachReachabilityData --> Error parsing reachability data: ', _context3.t0);
-            case 12:
-              return _context3.abrupt("return", results);
-            case 13:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[1, 9]]);
-      }));
-      function getReachabilityResults() {
-        return _getReachabilityResults.apply(this, arguments);
-      }
-      return getReachabilityResults;
-    }()
     /**
      * fetches reachability data and checks for cluster reachability
      * @returns {boolean}
      * @public
      * @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$udp2, _result$tcp2;
-                    return !result.isVideoMesh && (((_result$udp2 = result.udp) === null || _result$udp2 === void 0 ? void 0 : _result$udp2.reachable) === 'true' || ((_result$tcp2 = result.tcp) === null || _result$tcp2 === void 0 ? void 0 : _result$tcp2.reachable) === 'true');
-                  });
-                } 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);
+    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 isAnyPublicClusterReachable;
-    }()
+      return reachable;
+    }
+
     /**
      * Generate peerConnection config settings
      * @param {object} cluster
@@ -297,11 +150,10 @@ var Reachability = exports.default = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-    )
   }, {
     key: "buildPeerConnectionConfig",
     value: function buildPeerConnectionConfig(cluster) {
-      var iceServers = (0, _lodash.uniq)(cluster.udp).map(function (url) {
+      var iceServers = (0, _uniq2.default)([].concat((0, _toConsumableArray2.default)(cluster.udp), (0, _toConsumableArray2.default)(cluster.tcp))).map(function (url) {
         return {
           username: '',
           credential: '',
@@ -367,10 +219,10 @@ var Reachability = exports.default = /*#__PURE__*/function () {
       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 _callee5(key) {
+        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(key) {
           var cluster, config, peerConnection, description;
-          return _regenerator.default.wrap(function _callee5$(_context5) {
-            while (1) switch (_context5.prev = _context5.next) {
+          return _regenerator.default.wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
               case 0:
                 cluster = clusterList[key];
                 config = _this.buildPeerConnectionConfig(cluster);
@@ -378,29 +230,29 @@ var Reachability = exports.default = /*#__PURE__*/function () {
                   key: key,
                   config: config
                 });
-                _context5.next = 5;
+                _context2.next = 5;
                 return peerConnection.createOffer({
                   offerToReceiveAudio: true
                 });
               case 5:
-                description = _context5.sent;
+                description = _context2.sent;
                 // @ts-ignore
                 peerConnection.begin = (0, _now.default)();
                 peerConnection.setLocalDescription(description);
-                return _context5.abrupt("return", _this.iceGatheringState(peerConnection, cluster.isVideoMesh).catch(function (iceGatheringStateError) {
+                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 _context5.stop();
+                return _context2.stop();
             }
-          }, _callee5);
+          }, _callee2);
         }));
         return function (_x) {
           return _ref.apply(this, arguments);
         };
       }());
-      return _promise.default.all(clusters).then(this.parseIceResultsToInternalReachabilityResults).then(function (reachabilityLatencyResults) {
+      return _promise.default.all(clusters).then(this.parseIceResultsToReachabilityResults).then(function (reachabilityLatencyResults) {
         _this.logUnreachableClusters();
 
         // return results
@@ -471,8 +323,6 @@ var Reachability = exports.default = /*#__PURE__*/function () {
           var elapsed = _this3.getElapsedTime(peerConnection);
           _loggerProxy.default.logger.log( // @ts-ignore
           "Reachability:index#onIceCandidate --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
-          // order is important
-          _this3.addPublicIP(peerConnection, e.candidate.address);
           _this3.setLatencyAndClose(peerConnection, elapsed);
         }
       };
@@ -484,18 +334,16 @@ var Reachability = exports.default = /*#__PURE__*/function () {
      * speed.
      * @private
      * @param {RTCPeerConnection} peerConnection
-     * @param {boolean} isVideoMesh
+     * @param {number} timeout
      * @returns {Promise}
      */
   }, {
     key: "iceGatheringState",
-    value: function iceGatheringState(peerConnection, isVideoMesh) {
+    value: function iceGatheringState(peerConnection, timeout) {
       var _this4 = this;
       var ELAPSED = 'elapsed';
-      var timeout = isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT;
       return new _promise.default(function (resolve) {
         var peerConnectionProxy = new window.Proxy(peerConnection, {
-          // eslint-disable-next-line require-jsdoc
           get: function get(target, property) {
             var targetMember = target[property];
             if (typeof targetMember === 'function') {
@@ -506,12 +354,9 @@ var Reachability = exports.default = /*#__PURE__*/function () {
           set: function set(target, property, value) {
             // only intercept elapsed property
             if (property === ELAPSED) {
+              // @ts-ignore
               resolve({
-                // @ts-ignore
                 clusterId: peerConnection.key,
-                isVideoMesh: isVideoMesh,
-                // @ts-ignore
-                publicIPs: target.publicIPs,
                 elapsed: value
               });
               return true;
@@ -533,8 +378,6 @@ var Reachability = exports.default = /*#__PURE__*/function () {
 
           // Close any open peerConnections
           if (peerConnectionProxy.connectionState !== CLOSED) {
-            // order is important
-            _this4.addPublicIP(peerConnectionProxy, null);
             _this4.setLatencyAndClose(peerConnectionProxy, null);
           }
         }, timeout);
@@ -558,45 +401,32 @@ var Reachability = exports.default = /*#__PURE__*/function () {
 
     /**
      * Calculates time to establish connection
-     * @param {Array<ICECandidateResult>} iceResults iceResults
+     * @param {array} iceResults iceResults
      * @returns {object} reachabilityMap
-     * @protected
+     * @private
      * @memberof Reachability
      */
   }, {
-    key: "parseIceResultsToInternalReachabilityResults",
-    value: function parseIceResultsToInternalReachabilityResults(iceResults) {
+    key: "parseIceResultsToReachabilityResults",
+    value: function parseIceResultsToReachabilityResults(iceResults) {
       var reachabilityMap = {};
       iceResults.forEach(function (_ref2) {
         var clusterId = _ref2.clusterId,
-          isVideoMesh = _ref2.isVideoMesh,
-          elapsed = _ref2.elapsed,
-          publicIPs = _ref2.publicIPs;
-        var latencyResult = {};
-        if (!elapsed) {
-          (0, _assign.default)(latencyResult, {
+          elapsed = _ref2.elapsed;
+        var latencyResult;
+        if (elapsed === null) {
+          latencyResult = {
             reachable: 'false'
-          });
+          };
         } else {
-          (0, _assign.default)(latencyResult, {
+          latencyResult = {
             reachable: 'true',
             latencyInMilliseconds: elapsed.toString()
-          });
-        }
-        if (publicIPs) {
-          (0, _assign.default)(latencyResult, {
-            clientMediaIPs: publicIPs
-          });
+          };
         }
         reachabilityMap[clusterId] = {
           udp: latencyResult,
-          tcp: {
-            untested: 'true'
-          },
-          xtls: {
-            untested: 'true'
-          },
-          isVideoMesh: isVideoMesh
+          tcp: latencyResult
         };
       });
       return reachabilityMap;
@@ -605,7 +435,7 @@ var Reachability = exports.default = /*#__PURE__*/function () {
     /**
      * fetches reachability data
      * @param {object} clusterList
-     * @returns {Promise<InternalReachabilityResults>} reachability check results
+     * @returns {Promise<localSDPData>} reachability check results
      * @private
      * @memberof Reachability
      */
@@ -632,31 +462,6 @@ var Reachability = exports.default = /*#__PURE__*/function () {
       });
     }
 
-    /**
-     * Adds public IP (client media IPs)
-     * @param {RTCPeerConnection} peerConnection
-     * @param {string} publicIP
-     * @returns {void}
-     */
-  }, {
-    key: "addPublicIP",
-    value: function addPublicIP(peerConnection, publicIP) {
-      var modifiedPeerConnection = peerConnection;
-      var CLOSED = _constants.CONNECTION_STATE.CLOSED;
-      if (modifiedPeerConnection.connectionState === CLOSED) {
-        _loggerProxy.default.logger.log("Reachability:index#addPublicIP --> Attempting to set publicIP of ".concat(publicIP, " on closed peerConnection."));
-      }
-      if (publicIP) {
-        if (modifiedPeerConnection.publicIPs) {
-          modifiedPeerConnection.publicIPs.push(publicIP);
-        } else {
-          modifiedPeerConnection.publicIPs = [publicIP];
-        }
-      } else {
-        modifiedPeerConnection.publicIPs = null;
-      }
-    }
-
     /**
      * Records latency and closes the peerConnection
      * @param {RTCPeerConnection} peerConnection
@@ -668,13 +473,14 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }, {
     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 = (0, _defineProperty2.default)((0, _defineProperty2.default)({}, REACHABLE, 0), UNREACHABLE, 0);
+      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;
@@ -704,4 +510,5 @@ var Reachability = exports.default = /*#__PURE__*/function () {
   }]);
   return Reachability;
 }();
+exports.default = Reachability;
 //# sourceMappingURL=index.js.map