@webex/plugin-meetings 3.10.0-next.9 → 3.10.0-set-bitrate.1

package/dist/reachability/reachability.types.js

@@ -4,7 +4,20 @@ var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/defi
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NatType = void 0;
+exports.ReachabilityPeerConnectionEvents = exports.NatType = void 0;
+/**
+ * Events emitted by ReachabilityPeerConnection
+ */
+var ReachabilityPeerConnectionEvents = exports.ReachabilityPeerConnectionEvents = {
+  resultReady: 'resultReady',
+  // emitted when successfully reached over a protocol
+  clientMediaIpsUpdated: 'clientMediaIpsUpdated',
+  // emitted when new public IPs are found
+  natTypeUpdated: 'natTypeUpdated',
+  // emitted when NAT type is determined
+  reachedSubnets: 'reachedSubnets' // emitted when server IP (subnet) is discovered
+};
+
 // result for a specific transport protocol (like udp or tcp)
 var NatType = exports.NatType = /*#__PURE__*/function (NatType) {
   NatType["Unknown"] = "unknown";

package/dist/reachability/reachability.types.js.map

@@ -1 +1 @@
-{"version":3,"names":["NatType","exports"],"sources":["reachability.types.ts"],"sourcesContent":["import {IP_VERSION} from '../constants';\n\n// result for a specific transport protocol (like udp or tcp)\nexport type TransportResult = {\n  result: 'reachable' | 'unreachable' | 'untested';\n  latencyInMilliseconds?: number; // amount of time it took to get the first ICE candidate\n  clientMediaIPs?: string[];\n};\n\nexport enum NatType {\n  Unknown = 'unknown',\n  SymmetricNat = 'symmetric-nat',\n}\n\n// reachability result for a specific media cluster\nexport type ClusterReachabilityResult = {\n  udp: TransportResult;\n  tcp: TransportResult;\n  xtls: TransportResult;\n};\n\nexport type ReachabilityMetrics = {\n  reachability_public_udp_success: number;\n  reachability_public_udp_failed: number;\n  reachability_public_tcp_success: number;\n  reachability_public_tcp_failed: number;\n  reachability_public_xtls_success: number;\n  reachability_public_xtls_failed: number;\n  reachability_vmn_udp_success: number;\n  reachability_vmn_udp_failed: number;\n  reachability_vmn_tcp_success: number;\n  reachability_vmn_tcp_failed: number;\n  reachability_vmn_xtls_success: number;\n  reachability_vmn_xtls_failed: number;\n  natType: NatType;\n};\n\n/**\n * This is the type that matches what backend expects us to send to them. It is a bit weird, because\n * it uses strings instead of booleans and numbers, but that's what they require.\n */\nexport type TransportResultForBackend = {\n  reachable?: 'true' | 'false';\n  latencyInMilliseconds?: string;\n  clientMediaIPs?: string[];\n  untested?: 'true';\n};\n\nexport type ReachabilityResultForBackend = {\n  udp: TransportResultForBackend;\n  tcp: TransportResultForBackend;\n  xtls: TransportResultForBackend;\n};\n\n// this is the type that is required by the backend when we send them reachability results\nexport type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;\n\n// this is the type used by Reachability class internally and stored in local storage\nexport type ReachabilityResults = Record<\n  string,\n  ClusterReachabilityResult & {\n    isVideoMesh?: boolean;\n  }\n>;\n\nexport type ReachabilityReportV0 = ReachabilityResultsForBackend;\n\nexport type ReachabilityReportV1 = {\n  version: 1;\n  result: {\n    usedDiscoveryOptions: {\n      'early-call-min-clusters': number;\n      // there are more options, but we don't support them yet\n    };\n    metrics: {\n      'total-duration-ms': number;\n      // there are more metrics, but we don't support them yet\n    };\n    tests: Record<string, ReachabilityResultForBackend>;\n  };\n};\n\nexport interface ClientMediaPreferences {\n  ipver: IP_VERSION;\n  joinCookie: any;\n  preferTranscoding: boolean;\n  reachability?: ReachabilityReportV1; // only present when using Orpheus API version 1\n}\n\n/* Orpheus API supports more triggers, but we don't use them yet */\nexport type GetClustersTrigger = 'startup' | 'early-call/no-min-reached';\n"],"mappings":";;;;;;;AAEA;AAAA,IAOYA,OAAO,GAAAC,OAAA,CAAAD,OAAA,0BAAPA,OAAO;EAAPA,OAAO;EAAPA,OAAO;EAAA,OAAPA,OAAO;AAAA,OAKnB;AAuBA;AACA;AACA;AACA;AAcA;AAGA;AAgCA","ignoreList":[]}
+{"version":3,"names":["ReachabilityPeerConnectionEvents","exports","resultReady","clientMediaIpsUpdated","natTypeUpdated","reachedSubnets","NatType"],"sources":["reachability.types.ts"],"sourcesContent":["import {IP_VERSION, Enum} from '../constants';\n\nexport type Protocol = 'udp' | 'tcp' | 'xtls';\n\n/**\n * Events emitted by ReachabilityPeerConnection\n */\nexport const ReachabilityPeerConnectionEvents = {\n  resultReady: 'resultReady', // emitted when successfully reached over a protocol\n  clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when new public IPs are found\n  natTypeUpdated: 'natTypeUpdated', // emitted when NAT type is determined\n  reachedSubnets: 'reachedSubnets', // emitted when server IP (subnet) is discovered\n} as const;\n\nexport type ReachabilityPeerConnectionEvents = Enum<typeof ReachabilityPeerConnectionEvents>;\n\n// result for a specific transport protocol (like udp or tcp)\nexport type TransportResult = {\n  result: 'reachable' | 'unreachable' | 'untested';\n  latencyInMilliseconds?: number; // amount of time it took to get the first ICE candidate\n  clientMediaIPs?: string[];\n};\n\nexport enum NatType {\n  Unknown = 'unknown',\n  SymmetricNat = 'symmetric-nat',\n}\n\n// reachability result for a specific media cluster\nexport type ClusterReachabilityResult = {\n  udp: TransportResult;\n  tcp: TransportResult;\n  xtls: TransportResult;\n};\n\nexport type ReachabilityMetrics = {\n  reachability_public_udp_success: number;\n  reachability_public_udp_failed: number;\n  reachability_public_tcp_success: number;\n  reachability_public_tcp_failed: number;\n  reachability_public_xtls_success: number;\n  reachability_public_xtls_failed: number;\n  reachability_vmn_udp_success: number;\n  reachability_vmn_udp_failed: number;\n  reachability_vmn_tcp_success: number;\n  reachability_vmn_tcp_failed: number;\n  reachability_vmn_xtls_success: number;\n  reachability_vmn_xtls_failed: number;\n  natType: NatType;\n};\n\n/**\n * This is the type that matches what backend expects us to send to them. It is a bit weird, because\n * it uses strings instead of booleans and numbers, but that's what they require.\n */\nexport type TransportResultForBackend = {\n  reachable?: 'true' | 'false';\n  latencyInMilliseconds?: string;\n  clientMediaIPs?: string[];\n  untested?: 'true';\n};\n\nexport type ReachabilityResultForBackend = {\n  udp: TransportResultForBackend;\n  tcp: TransportResultForBackend;\n  xtls: TransportResultForBackend;\n};\n\n// this is the type that is required by the backend when we send them reachability results\nexport type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;\n\n// this is the type used by Reachability class internally and stored in local storage\nexport type ReachabilityResults = Record<\n  string,\n  ClusterReachabilityResult & {\n    isVideoMesh?: boolean;\n  }\n>;\n\nexport type ReachabilityReportV0 = ReachabilityResultsForBackend;\n\nexport type ReachabilityReportV1 = {\n  version: 1;\n  result: {\n    usedDiscoveryOptions: {\n      'early-call-min-clusters': number;\n      // there are more options, but we don't support them yet\n    };\n    metrics: {\n      'total-duration-ms': number;\n      // there are more metrics, but we don't support them yet\n    };\n    tests: Record<string, ReachabilityResultForBackend>;\n  };\n};\n\nexport interface ClientMediaPreferences {\n  ipver: IP_VERSION;\n  joinCookie: any;\n  preferTranscoding: boolean;\n  reachability?: ReachabilityReportV1; // only present when using Orpheus API version 1\n}\n\n/* Orpheus API supports more triggers, but we don't use them yet */\nexport type GetClustersTrigger = 'startup' | 'early-call/no-min-reached';\n"],"mappings":";;;;;;;AAIA;AACA;AACA;AACO,IAAMA,gCAAgC,GAAAC,OAAA,CAAAD,gCAAA,GAAG;EAC9CE,WAAW,EAAE,aAAa;EAAE;EAC5BC,qBAAqB,EAAE,uBAAuB;EAAE;EAChDC,cAAc,EAAE,gBAAgB;EAAE;EAClCC,cAAc,EAAE,gBAAgB,CAAE;AACpC,CAAU;;AAIV;AAAA,IAOYC,OAAO,GAAAL,OAAA,CAAAK,OAAA,0BAAPA,OAAO;EAAPA,OAAO;EAAPA,OAAO;EAAA,OAAPA,OAAO;AAAA,OAKnB;AAuBA;AACA;AACA;AACA;AAcA;AAGA;AAgCA","ignoreList":[]}

package/dist/reachability/reachabilityPeerConnection.js

@@ -0,0 +1,445 @@
+"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 _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReachabilityPeerConnection = 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 _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+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 _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 _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; })(); }
+/**
+ * A class to handle RTCPeerConnection lifecycle and ICE candidate gathering for reachability checks.
+ * It will do all the work like PeerConnection lifecycle, candidate processing, result management, and event emission.
+ */
+var ReachabilityPeerConnection = exports.ReachabilityPeerConnection = /*#__PURE__*/function (_EventsScope) {
+  /**
+   * Constructor for ReachabilityPeerConnection
+   * @param {string} clusterName name of the cluster
+   * @param {ClusterNode} clusterInfo information about the media cluster
+   */
+  function ReachabilityPeerConnection(clusterName, clusterInfo) {
+    var _this;
+    (0, _classCallCheck2.default)(this, ReachabilityPeerConnection);
+    _this = _callSuper(this, ReachabilityPeerConnection);
+    (0, _defineProperty2.default)(_this, "numUdpUrls", void 0);
+    (0, _defineProperty2.default)(_this, "numTcpUrls", void 0);
+    (0, _defineProperty2.default)(_this, "numXTlsUrls", void 0);
+    (0, _defineProperty2.default)(_this, "pc", void 0);
+    (0, _defineProperty2.default)(_this, "defer", void 0);
+    (0, _defineProperty2.default)(_this, "startTimestamp", void 0);
+    (0, _defineProperty2.default)(_this, "srflxIceCandidates", []);
+    (0, _defineProperty2.default)(_this, "clusterName", void 0);
+    (0, _defineProperty2.default)(_this, "result", void 0);
+    (0, _defineProperty2.default)(_this, "emittedSubnets", new _set.default());
+    _this.clusterName = clusterName;
+    _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'
+      }
+    };
+    return _this;
+  }
+
+  /**
+   * Gets total elapsed time, can be called only after start() is called
+   * @returns {number} Milliseconds
+   */
+  (0, _inherits2.default)(ReachabilityPeerConnection, _EventsScope);
+  return (0, _createClass2.default)(ReachabilityPeerConnection, [{
+    key: "getElapsedTime",
+    value: function getElapsedTime() {
+      return Math.round(performance.now() - this.startTimestamp);
+    }
+
+    /**
+     * Generate peerConnection config settings
+     * @param {ClusterNode} cluster
+     * @returns {RTCConfiguration} peerConnectionConfig
+     */
+  }, {
+    key: "createPeerConnection",
+    value:
+    /**
+     * Creates an RTCPeerConnection
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     * @returns {RTCPeerConnection|null} peerConnection
+     */
+    function createPeerConnection(clusterInfo) {
+      try {
+        var config = ReachabilityPeerConnection.buildPeerConnectionConfig(clusterInfo);
+        var peerConnection = new RTCPeerConnection(config);
+        return peerConnection;
+      } catch (peerConnectionError) {
+        _loggerProxy.default.logger.warn("Reachability:ReachabilityPeerConnection#createPeerConnection --> Error creating peerConnection:", peerConnectionError);
+        return null;
+      }
+    }
+
+    /**
+     * @returns {ClusterReachabilityResult} reachability result for this instance
+     */
+  }, {
+    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();
+      }
+    }
+
+    /**
+     * Resolves the defer, indicating that reachability checks for this cluster are completed
+     *
+     * @returns {void}
+     */
+  }, {
+    key: "finishReachabilityCheck",
+    value: function finishReachabilityCheck() {
+      this.defer.resolve();
+    }
+
+    /**
+     * 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 && this.pc.connectionState !== CLOSED) {
+        this.closePeerConnection();
+        this.finishReachabilityCheck();
+      }
+    }
+
+    /**
+     * Adds public IP (client media IPs)
+     * @param {string} protocol
+     * @param {string} publicIp
+     * @returns {void}
+     */
+  }, {
+    key: "addPublicIp",
+    value: function addPublicIp(protocol, publicIp) {
+      if (!publicIp) {
+        return;
+      }
+      var result = this.result[protocol];
+      var ipAdded = false;
+      if (result.clientMediaIPs) {
+        if (!result.clientMediaIPs.includes(publicIp)) {
+          result.clientMediaIPs.push(publicIp);
+          ipAdded = true;
+        }
+      } else {
+        result.clientMediaIPs = [publicIp];
+        ipAdded = true;
+      }
+      if (ipAdded) {
+        this.emit({
+          file: 'reachabilityPeerConnection',
+          function: 'addPublicIp'
+        }, _reachability.ReachabilityPeerConnectionEvents.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.defer.resolve();
+        }
+      };
+    }
+
+    /**
+     * 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:ReachabilityPeerConnection#saveResult --> Successfully reached ".concat(this.clusterName, " over ").concat(protocol, ": ").concat(latency, "ms"));
+        result.latencyInMilliseconds = latency;
+        result.result = 'reachable';
+        if (publicIp) {
+          result.clientMediaIPs = [publicIp];
+        }
+        this.emit({
+          file: 'reachabilityPeerConnection',
+          function: 'saveResult'
+        }, _reachability.ReachabilityPeerConnectionEvents.resultReady, _objectSpread({
+          protocol: protocol
+        }, result));
+      } else {
+        this.addPublicIp(protocol, publicIp);
+      }
+      if (serverIp) {
+        if (!this.emittedSubnets.has(serverIp)) {
+          this.emittedSubnets.add(serverIp);
+          this.emit({
+            file: 'reachabilityPeerConnection',
+            function: 'saveResult'
+          }, _reachability.ReachabilityPeerConnectionEvents.reachedSubnets, {
+            subnets: [serverIp]
+          });
+        }
+      }
+    }
+
+    /**
+     * Determines NAT type by analyzing server reflexive candidate patterns
+     * @param {RTCIceCandidate} candidate server reflexive candidate
+     * @returns {void}
+     */
+  }, {
+    key: "determineNatTypeForSrflxCandidate",
+    value: function determineNatTypeForSrflxCandidate(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: 'reachabilityPeerConnection',
+              function: 'determineNatTypeForSrflxCandidate'
+            }, _reachability.ReachabilityPeerConnectionEvents.natTypeUpdated, {
+              natType: _reachability.NatType.SymmetricNat
+            });
+          }
+        });
+      }
+    }
+
+    /**
+     * 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);
+              serverIp = match && match[1];
+            }
+            _this4.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);
+            _this4.determineNatTypeForSrflxCandidate(e.candidate);
+          }
+          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);
+          }
+        }
+      };
+    }
+
+    /**
+     * Starts the process of doing UDP, TCP, and XTLS reachability checks.
+     * @returns {Promise<ClusterReachabilityResult>}
+     */
+  }, {
+    key: "start",
+    value: (function () {
+      var _start = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var offer, gatherIceCandidatePromise, _t;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this.pc) {
+                _context.next = 1;
+                break;
+              }
+              _loggerProxy.default.logger.warn("Reachability:ReachabilityPeerConnection#start --> Error: peerConnection is undefined");
+              return _context.abrupt("return", this.result);
+            case 1:
+              // 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 = 2;
+              _context.next = 3;
+              return this.pc.createOffer({
+                offerToReceiveAudio: true
+              });
+            case 3:
+              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 = 4;
+              return gatherIceCandidatePromise;
+            case 4:
+              _context.next = 6;
+              break;
+            case 5:
+              _context.prev = 5;
+              _t = _context["catch"](2);
+              _loggerProxy.default.logger.warn("Reachability:ReachabilityPeerConnection#start --> Error: ", _t);
+            case 6:
+              return _context.abrupt("return", this.result);
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[2, 5]]);
+      }));
+      function start() {
+        return _start.apply(this, arguments);
+      }
+      return start;
+    }()
+    /**
+     * Starts the process of gathering ICE candidates
+     * @returns {Promise} promise that's resolved once reachability checks are completed or timeout is reached
+     */
+    )
+  }, {
+    key: "gatherIceCandidates",
+    value: function gatherIceCandidates() {
+      this.registerIceGatheringStateChangeListener();
+      this.registerIceCandidateListener();
+      return this.defer.promise;
+    }
+  }], [{
+    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'
+      };
+    }
+  }]);
+}(_eventsScope.default);
+//# sourceMappingURL=reachabilityPeerConnection.js.map

package/dist/reachability/reachabilityPeerConnection.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_common","require","_loggerProxy","_interopRequireDefault","_util","_eventsScope","_constants","_reachability","ownKeys","e","r","t","_Object$keys","_Object$getOwnPropertySymbols","o","filter","_Object$getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","Object","forEach","_defineProperty2","default","_Object$getOwnPropertyDescriptors","_Object$defineProperties","_Object$defineProperty","_callSuper","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","_Reflect$construct","constructor","Boolean","prototype","valueOf","call","ReachabilityPeerConnection","exports","_EventsScope","clusterName","clusterInfo","_this","_classCallCheck2","_set","numUdpUrls","udp","numTcpUrls","tcp","numXTlsUrls","xtls","pc","createPeerConnection","defer","Defer","result","_inherits2","_createClass2","key","value","getElapsedTime","Math","round","performance","now","startTimestamp","config","buildPeerConnectionConfig","peerConnection","RTCPeerConnection","peerConnectionError","LoggerProxy","logger","warn","getResult","closePeerConnection","onicecandidate","onicegatheringstatechange","close","finishReachabilityCheck","resolve","abort","CLOSED","CONNECTION_STATE","connectionState","addPublicIp","protocol","publicIp","ipAdded","clientMediaIPs","includes","emit","file","function","ReachabilityPeerConnectionEvents","clientMediaIpsUpdated","registerIceGatheringStateChangeListener","_this2","iceGatheringState","ICE_GATHERING_STATE","COMPLETE","saveResult","latency","serverIp","latencyInMilliseconds","undefined","log","concat","resultReady","emittedSubnets","has","add","reachedSubnets","subnets","determineNatTypeForSrflxCandidate","candidate","_this3","srflxIceCandidates","portsFound","c","address","relatedPort","port","_entries","_ref","_ref2","_slicedToArray2","ports","size","natTypeUpdated","natType","NatType","SymmetricNat","registerIceCandidateListener","_this4","TURN_TLS_PORT","CANDIDATE_TYPES","SERVER_REFLEXIVE","RELAY","type","stunServerUrlRegex","match","url","_start","_asyncToGenerator2","_regenerator","mark","_callee","offer","gatherIceCandidatePromise","_t","wrap","_context","prev","next","abrupt","createOffer","offerToReceiveAudio","sent","gatherIceCandidates","setLocalDescription","stop","start","promise","cluster","udpIceServers","map","username","credential","urls","tcpIceServers","urlString","convertStunUrlToTurn","turnTlsIceServers","convertStunUrlToTurnTls","iceServers","_toConsumableArray2","iceCandidatePoolSize","iceTransportPolicy","EventsScope"],"sources":["reachabilityPeerConnection.ts"],"sourcesContent":["import {Defer} from '@webex/common';\n\nimport LoggerProxy from '../common/logs/logger-proxy';\nimport {ClusterNode} from './request';\nimport {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';\nimport EventsScope from '../common/events/events-scope';\n\nimport {CONNECTION_STATE, ICE_GATHERING_STATE} from '../constants';\nimport {\n  ClusterReachabilityResult,\n  NatType,\n  Protocol,\n  ReachabilityPeerConnectionEvents,\n} from './reachability.types';\n\n/**\n * A class to handle RTCPeerConnection lifecycle and ICE candidate gathering for reachability checks.\n * It will do all the work like PeerConnection lifecycle, candidate processing, result management, and event emission.\n */\nexport class ReachabilityPeerConnection extends EventsScope {\n  public numUdpUrls: number;\n  public numTcpUrls: number;\n  public numXTlsUrls: number;\n  private pc: RTCPeerConnection | null;\n  private defer: Defer;\n  private startTimestamp: number;\n  private srflxIceCandidates: RTCIceCandidate[] = [];\n  private clusterName: string;\n  private result: ClusterReachabilityResult;\n  private emittedSubnets: Set<string> = new Set();\n\n  /**\n   * Constructor for ReachabilityPeerConnection\n   * @param {string} clusterName name of the cluster\n   * @param {ClusterNode} clusterInfo information about the media cluster\n   */\n  constructor(clusterName: string, clusterInfo: ClusterNode) {\n    super();\n    this.clusterName = clusterName;\n    this.numUdpUrls = clusterInfo.udp.length;\n    this.numTcpUrls = clusterInfo.tcp.length;\n    this.numXTlsUrls = clusterInfo.xtls.length;\n\n    this.pc = this.createPeerConnection(clusterInfo);\n\n    this.defer = new Defer();\n    this.result = {\n      udp: {\n        result: 'untested',\n      },\n      tcp: {\n        result: 'untested',\n      },\n      xtls: {\n        result: 'untested',\n      },\n    };\n  }\n\n  /**\n   * Gets total elapsed time, can be called only after start() is called\n   * @returns {number} Milliseconds\n   */\n  private getElapsedTime() {\n    return Math.round(performance.now() - this.startTimestamp);\n  }\n\n  /**\n   * Generate peerConnection config settings\n   * @param {ClusterNode} cluster\n   * @returns {RTCConfiguration} peerConnectionConfig\n   */\n  private static buildPeerConnectionConfig(cluster: ClusterNode): RTCConfiguration {\n    const udpIceServers = cluster.udp.map((url) => ({\n      username: '',\n      credential: '',\n      urls: [url],\n    }));\n\n    // STUN servers are contacted only using UDP, so in order to test TCP reachability\n    // we pretend that Linus is a TURN server, because we can explicitly say \"transport=tcp\" in TURN urls.\n    // We then check for relay candidates to know if TURN-TCP worked (see registerIceCandidateListener()).\n    const tcpIceServers = cluster.tcp.map((urlString: string) => {\n      return {\n        username: 'webexturnreachuser',\n        credential: 'webexturnreachpwd',\n        urls: [convertStunUrlToTurn(urlString, 'tcp')],\n      };\n    });\n\n    const turnTlsIceServers = cluster.xtls.map((urlString: string) => {\n      return {\n        username: 'webexturnreachuser',\n        credential: 'webexturnreachpwd',\n        urls: [convertStunUrlToTurnTls(urlString)],\n      };\n    });\n\n    return {\n      iceServers: [...udpIceServers, ...tcpIceServers, ...turnTlsIceServers],\n      iceCandidatePoolSize: 0,\n      iceTransportPolicy: 'all',\n    };\n  }\n\n  /**\n   * Creates an RTCPeerConnection\n   * @param {ClusterNode} clusterInfo information about the media cluster\n   * @returns {RTCPeerConnection|null} peerConnection\n   */\n  private createPeerConnection(clusterInfo: ClusterNode): RTCPeerConnection | null {\n    try {\n      const config = ReachabilityPeerConnection.buildPeerConnectionConfig(clusterInfo);\n\n      const peerConnection = new RTCPeerConnection(config);\n\n      return peerConnection;\n    } catch (peerConnectionError) {\n      LoggerProxy.logger.warn(\n        `Reachability:ReachabilityPeerConnection#createPeerConnection --> Error creating peerConnection:`,\n        peerConnectionError\n      );\n\n      return null;\n    }\n  }\n\n  /**\n   * @returns {ClusterReachabilityResult} reachability result for this instance\n   */\n  getResult() {\n    return this.result;\n  }\n\n  /**\n   * Closes the peerConnection\n   * @returns {void}\n   */\n  private closePeerConnection() {\n    if (this.pc) {\n      this.pc.onicecandidate = null;\n      this.pc.onicegatheringstatechange = null;\n      this.pc.close();\n    }\n  }\n\n  /**\n   * Resolves the defer, indicating that reachability checks for this cluster are completed\n   *\n   * @returns {void}\n   */\n  private finishReachabilityCheck() {\n    this.defer.resolve();\n  }\n\n  /**\n   * Aborts the cluster reachability checks by closing the peer connection\n   *\n   * @returns {void}\n   */\n  public abort() {\n    const {CLOSED} = CONNECTION_STATE;\n\n    if (this.pc && this.pc.connectionState !== CLOSED) {\n      this.closePeerConnection();\n      this.finishReachabilityCheck();\n    }\n  }\n\n  /**\n   * Adds public IP (client media IPs)\n   * @param {string} protocol\n   * @param {string} publicIp\n   * @returns {void}\n   */\n  private addPublicIp(protocol: Protocol, publicIp?: string | null) {\n    if (!publicIp) {\n      return;\n    }\n\n    const result = this.result[protocol];\n    let ipAdded = false;\n\n    if (result.clientMediaIPs) {\n      if (!result.clientMediaIPs.includes(publicIp)) {\n        result.clientMediaIPs.push(publicIp);\n        ipAdded = true;\n      }\n    } else {\n      result.clientMediaIPs = [publicIp];\n      ipAdded = true;\n    }\n\n    if (ipAdded) {\n      this.emit(\n        {\n          file: 'reachabilityPeerConnection',\n          function: 'addPublicIp',\n        },\n        ReachabilityPeerConnectionEvents.clientMediaIpsUpdated,\n        {\n          protocol,\n          clientMediaIPs: result.clientMediaIPs,\n        }\n      );\n    }\n  }\n\n  /**\n   * Registers a listener for the iceGatheringStateChange event\n   *\n   * @returns {void}\n   */\n  private registerIceGatheringStateChangeListener() {\n    this.pc.onicegatheringstatechange = () => {\n      if (this.pc.iceGatheringState === ICE_GATHERING_STATE.COMPLETE) {\n        this.closePeerConnection();\n        this.defer.resolve();\n      }\n    };\n  }\n\n  /**\n   * Saves the latency in the result for the given protocol and marks it as reachable,\n   * emits the \"resultReady\" event if this is the first result for that protocol,\n   * emits the \"clientMediaIpsUpdated\" event if we already had a result and only found\n   * a new client IP\n   *\n   * @param {string} protocol\n   * @param {number} latency\n   * @param {string|null} [publicIp]\n   * @param {string|null} [serverIp]\n   * @returns {void}\n   */\n  private saveResult(\n    protocol: Protocol,\n    latency: number,\n    publicIp?: string | null,\n    serverIp?: string | null\n  ) {\n    const result = this.result[protocol];\n\n    if (result.latencyInMilliseconds === undefined) {\n      LoggerProxy.logger.log(\n        // @ts-ignore\n        `Reachability:ReachabilityPeerConnection#saveResult --> Successfully reached ${this.clusterName} over ${protocol}: ${latency}ms`\n      );\n      result.latencyInMilliseconds = latency;\n      result.result = 'reachable';\n      if (publicIp) {\n        result.clientMediaIPs = [publicIp];\n      }\n\n      this.emit(\n        {\n          file: 'reachabilityPeerConnection',\n          function: 'saveResult',\n        },\n        ReachabilityPeerConnectionEvents.resultReady,\n        {\n          protocol,\n          ...result,\n        }\n      );\n    } else {\n      this.addPublicIp(protocol, publicIp);\n    }\n\n    if (serverIp) {\n      if (!this.emittedSubnets.has(serverIp)) {\n        this.emittedSubnets.add(serverIp);\n        this.emit(\n          {\n            file: 'reachabilityPeerConnection',\n            function: 'saveResult',\n          },\n          ReachabilityPeerConnectionEvents.reachedSubnets,\n          {\n            subnets: [serverIp],\n          }\n        );\n      }\n    }\n  }\n\n  /**\n   * Determines NAT type by analyzing server reflexive candidate patterns\n   * @param {RTCIceCandidate} candidate server reflexive candidate\n   * @returns {void}\n   */\n  private determineNatTypeForSrflxCandidate(candidate: RTCIceCandidate) {\n    this.srflxIceCandidates.push(candidate);\n\n    if (this.srflxIceCandidates.length > 1) {\n      const portsFound: Record<string, Set<number>> = {};\n\n      this.srflxIceCandidates.forEach((c) => {\n        const key = `${c.address}:${c.relatedPort}`;\n        if (!portsFound[key]) {\n          portsFound[key] = new Set();\n        }\n        portsFound[key].add(c.port);\n      });\n\n      Object.entries(portsFound).forEach(([, ports]) => {\n        if (ports.size > 1) {\n          // Found candidates with the same address and relatedPort, but different ports\n          this.emit(\n            {\n              file: 'reachabilityPeerConnection',\n              function: 'determineNatTypeForSrflxCandidate',\n            },\n            ReachabilityPeerConnectionEvents.natTypeUpdated,\n            {\n              natType: NatType.SymmetricNat,\n            }\n          );\n        }\n      });\n    }\n  }\n\n  /**\n   * Registers a listener for the icecandidate event\n   *\n   * @returns {void}\n   */\n  private registerIceCandidateListener() {\n    this.pc.onicecandidate = (e) => {\n      const TURN_TLS_PORT = 443;\n      const CANDIDATE_TYPES = {\n        SERVER_REFLEXIVE: 'srflx',\n        RELAY: 'relay',\n      };\n\n      const latencyInMilliseconds = this.getElapsedTime();\n\n      if (e.candidate) {\n        if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {\n          let serverIp = null;\n          if ('url' in e.candidate) {\n            const stunServerUrlRegex = /stun:([\\d.]+):\\d+/;\n\n            const match = (e.candidate as any).url.match(stunServerUrlRegex);\n            serverIp = match && match[1];\n          }\n\n          this.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);\n\n          this.determineNatTypeForSrflxCandidate(e.candidate);\n        }\n\n        if (e.candidate.type === CANDIDATE_TYPES.RELAY) {\n          const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';\n          this.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);\n        }\n      }\n    };\n  }\n\n  /**\n   * Starts the process of doing UDP, TCP, and XTLS reachability checks.\n   * @returns {Promise<ClusterReachabilityResult>}\n   */\n  async start(): Promise<ClusterReachabilityResult> {\n    if (!this.pc) {\n      LoggerProxy.logger.warn(\n        `Reachability:ReachabilityPeerConnection#start --> Error: peerConnection is undefined`\n      );\n\n      return this.result;\n    }\n\n    // Initialize this.result as saying that nothing is reachable.\n    // It will get updated as we go along and successfully gather ICE candidates.\n    this.result.udp = {\n      result: this.numUdpUrls > 0 ? 'unreachable' : 'untested',\n    };\n    this.result.tcp = {\n      result: this.numTcpUrls > 0 ? 'unreachable' : 'untested',\n    };\n    this.result.xtls = {\n      result: this.numXTlsUrls > 0 ? 'unreachable' : 'untested',\n    };\n\n    try {\n      const offer = await this.pc.createOffer({offerToReceiveAudio: true});\n\n      this.startTimestamp = performance.now();\n\n      // Set up the state change listeners before triggering the ICE gathering\n      const gatherIceCandidatePromise = this.gatherIceCandidates();\n\n      // not awaiting the next call on purpose, because we're not sending the offer anywhere and there won't be any answer\n      // we just need to make this call to trigger the ICE gathering process\n      this.pc.setLocalDescription(offer);\n\n      await gatherIceCandidatePromise;\n    } catch (error) {\n      LoggerProxy.logger.warn(`Reachability:ReachabilityPeerConnection#start --> Error: `, error);\n    }\n\n    return this.result;\n  }\n\n  /**\n   * Starts the process of gathering ICE candidates\n   * @returns {Promise} promise that's resolved once reachability checks are completed or timeout is reached\n   */\n  private gatherIceCandidates() {\n    this.registerIceGatheringStateChangeListener();\n    this.registerIceCandidateListener();\n\n    return this.defer.promise;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/types/constants.d.ts

@@ -622,28 +622,33 @@ export declare const LOCUSINFO: {
     };
 };
 export declare const LOCUSEVENT: {
-    LOCUS_MERCURY: string;
-    CONTROLS_UPDATED: string;
-    DIFFERENCE: string;
-    BREAKOUT_ROSTER: string;
-    FLOOR_GRANTED: string;
-    FLOOR_RELEASED: string;
-    MESSAGE_ROAP: string;
-    PARTICIPANT_JOIN: string;
-    PARTICIPANT_LEFT: string;
-    PARTICIPANT_DECLINED: string;
-    PARTICIPANT_UPDATED: string;
-    PARTICIPANT_CONTROLS_UPDATED: string;
-    PARTICIPANT_ROLES_UPDATED: string;
-    PARTICIPANT_AUDIO_MUTED: string;
-    PARTICIPANT_AUDIO_UNMUTED: string;
-    PARTICIPANT_VIDEO_MUTED: string;
-    PARTICIPANT_VIDEO_UNMUTED: string;
-    RECORDING_STARTED: string;
-    RECORDING_START_FAILED: string;
-    RECORDING_STOPPED: string;
-    SELF_CHANGED: string;
+    readonly LOCUS_MERCURY: "event:locus";
+    readonly CONTROLS_UPDATED: "locus.controls_updated";
+    readonly DIFFERENCE: "locus.difference";
+    readonly BREAKOUT_ROSTER: "breakout.roster";
+    readonly FLOOR_GRANTED: "locus.floor_granted";
+    readonly FLOOR_RELEASED: "locus.floor_released";
+    readonly MESSAGE_ROAP: "locus.message.roap";
+    readonly PARTICIPANT_JOIN: "locus.participant_joined";
+    readonly PARTICIPANT_LEFT: "locus.participant_left";
+    readonly PARTICIPANT_DECLINED: "locus.participant_declined";
+    readonly PARTICIPANT_UPDATED: "locus.participant_updated";
+    readonly PARTICIPANT_CONTROLS_UPDATED: "locus.participant_controls_updated";
+    readonly PARTICIPANT_ROLES_UPDATED: "locus.participant_roles_updated";
+    readonly PARTICIPANT_AUDIO_MUTED: "locus.participant_audio_muted";
+    readonly PARTICIPANT_AUDIO_UNMUTED: "locus.participant_audio_unmuted";
+    readonly PARTICIPANT_VIDEO_MUTED: "locus.participant_video_muted";
+    readonly PARTICIPANT_VIDEO_UNMUTED: "locus.participant_video_unmuted";
+    readonly RECORDING_STARTED: "locus.recording_started";
+    readonly RECORDING_START_FAILED: "locus.recording_start_failed";
+    readonly RECORDING_STOPPED: "locus.recording_stopped";
+    readonly SELF_CHANGED: "locus.self_changed";
+    readonly HASH_TREE_DATA_UPDATED: "locus.state_message";
+    readonly SDK_LOCUS_FROM_SYNC_MEETINGS: "jsSdk.locus_from_sync_meetings";
+    readonly SDK_NO_EVENT: "jsSdk.no_event";
 };
+export type LOCUSEVENT = Enum<typeof LOCUSEVENT>;
+export declare const LOCUS_LLM_EVENT: string;
 export declare const MEDIA_TRACK_CONSTRAINT: {
     CURSOR: {
         AWLAYS: string;

package/dist/types/hashTree/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const EMPTY_HASH = "99aa06d3014798d86001c324468d497f";
+export declare const DataSetNames: {
+    MAIN: string;
+    ATTENDEES: string;
+    ATD_ACTIVE: string;
+    ATD_UNMUTED: string;
+    SELF: string;
+};