@webex/plugin-meetings 3.12.0-next.54 → 3.12.0-next.56

package/dist/aiEnableRequest/index.js

@@ -191,7 +191,7 @@ var AIEnableRequest = _webexCore.WebexPlugin.extend({
       method: _constants.HTTP_VERBS.PUT
     });
   },
-  version: "3.12.0-next.54"
+  version: "3.12.0-next.56"
 });
 var _default = exports.default = AIEnableRequest;
 //# sourceMappingURL=index.js.map

package/dist/breakouts/breakout.js

@@ -214,7 +214,7 @@ var Breakout = _webexCore.WebexPlugin.extend({
       sessionId: this.sessionId
     });
   },
-  version: "3.12.0-next.54"
+  version: "3.12.0-next.56"
 });
 var _default = exports.default = Breakout;
 //# sourceMappingURL=breakout.js.map

package/dist/breakouts/index.js

@@ -1110,7 +1110,7 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       this.trigger(_constants.BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
     }
   },
-  version: "3.12.0-next.54"
+  version: "3.12.0-next.56"
 });
 var _default = exports.default = Breakouts;
 //# sourceMappingURL=index.js.map

package/dist/hashTree/hashTreeParser.js

@@ -622,6 +622,9 @@ var HashTreeParser = /*#__PURE__*/function () {
           version: version
         };
       }))));
+      this.cancelPendingSyncsForDataSets(dataSets.map(function (ds) {
+        return ds.name;
+      }));
       dataSets.forEach(function (dataSet) {
         _this4.updateDataSetInfo(dataSet);
         _this4.runSyncAlgorithm(dataSet);
@@ -736,6 +739,9 @@ var HashTreeParser = /*#__PURE__*/function () {
       var dataSets = update.dataSets,
         locus = update.locus,
         metadata = update.metadata;
+      _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received update with dataSets=").concat(dataSets === null || dataSets === void 0 ? void 0 : dataSets.map(function (ds) {
+        return ds.name;
+      }).join(','), " metadata=").concat(metadata ? 'yes' : 'no'));
       if (!dataSets) {
         // this happens for example when we handle GET /loci response
         _loggerProxy.default.logger.info("HashTreeParser#handleLocusUpdate --> ".concat(this.debugId, " received hash tree update without dataSets"));
@@ -908,7 +914,10 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "deleteHashTree",
     value: function deleteHashTree(dataSetName) {
+      var _this$dataSets$dataSe;
       this.dataSets[dataSetName].hashTree = undefined;
+      (_this$dataSets$dataSe = this.dataSets[dataSetName].syncAbortController) === null || _this$dataSets$dataSe === void 0 ? void 0 : _this$dataSets$dataSe.abort();
+      this.dataSets[dataSetName].syncAbortController = undefined;
 
       // we also need to stop the timers as there is no hash tree anymore to sync
       if (this.dataSets[dataSetName].timer) {
@@ -1105,17 +1114,27 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "parseMessage",
     value: function parseMessage(message, debugText) {
-      var _message$locusStateEl,
+      var _message$dataSets,
+        _message$locusStateEl,
+        _message$locusStateEl2,
         _this0 = this;
       if (this.state === 'stopped') {
         return [];
       }
       var dataSets = message.dataSets,
         visibleDataSetsUrl = message.visibleDataSetsUrl;
-      _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " received message ").concat(debugText || '', ":"), message);
-      if (((_message$locusStateEl = message.locusStateElements) === null || _message$locusStateEl === void 0 ? void 0 : _message$locusStateEl.length) === 0) {
+      _loggerProxy.default.logger.info("HashTreeParser#parseMessage --> ".concat(this.debugId, " ").concat(debugText || '', " dataSets: ").concat((_message$dataSets = message.dataSets) === null || _message$dataSets === void 0 ? void 0 : _message$dataSets.map(function (_ref5) {
+        var name = _ref5.name,
+          version = _ref5.version;
+        return "".concat(name, ":").concat(version);
+      }).join(','), ", elements: ").concat((_message$locusStateEl = message.locusStateElements) === null || _message$locusStateEl === void 0 ? void 0 : _message$locusStateEl.map(function (el) {
+        return "".concat(el.htMeta.elementId.type, ":").concat(el.htMeta.elementId.id, ":").concat(el.htMeta.elementId.version).concat(el.data ? '+' : '-');
+      }).join(',')));
+      if (((_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.length) === 0) {
         _loggerProxy.default.logger.warn("HashTreeParser#parseMessage --> ".concat(this.debugId, " got empty locusStateElements!!!"));
-        // todo: send a metric
+        _metrics.default.sendBehavioralMetric(_constants.default.HASH_TREE_EMPTY_LOCUS_STATE_ELEMENTS, {
+          debugId: this.debugId
+        });
       }
 
       // first, update our metadata about the datasets with info from the message
@@ -1123,6 +1142,9 @@ var HashTreeParser = /*#__PURE__*/function () {
       dataSets.forEach(function (dataSet) {
         return _this0.updateDataSetInfo(dataSet);
       });
+      this.cancelPendingSyncsForDataSets(dataSets.map(function (ds) {
+        return ds.name;
+      }));
       var updatedObjects = [];
 
       // when we detect new visible datasets, it may be that the metadata about them is not
@@ -1185,10 +1207,10 @@ var HashTreeParser = /*#__PURE__*/function () {
                   item: object.htMeta.elementId
                 };
               }));
-              (0, _lodash.zip)(appliedChangesList, locusStateElementsForThisSet).forEach(function (_ref5) {
-                var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
-                  changeApplied = _ref6[0],
-                  object = _ref6[1];
+              (0, _lodash.zip)(appliedChangesList, locusStateElementsForThisSet).forEach(function (_ref6) {
+                var _ref7 = (0, _slicedToArray2.default)(_ref6, 2),
+                  changeApplied = _ref7[0],
+                  object = _ref7[1];
                 if (changeApplied) {
                   // add to updatedObjects so that our locus DTO will get updated with the new object
                   updatedObjects.push(object);
@@ -1335,7 +1357,8 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "performSync",
     value: (function () {
       var _performSync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(dataSet, reason, isInitialization) {
-        var hashTree, rootHash, leavesData, receivedHashes, hashesResult, mismatchedLeaveIndexes, syncResponse, _t3, _t4;
+        var _dataSet$syncAbortCon;
+        var abortController, hashTree, rootHash, leavesData, receivedHashes, hashesResult, mismatchedLeaveIndexes, syncResponse, _t3, _t4;
         return _regenerator.default.wrap(function (_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
@@ -1345,6 +1368,8 @@ var HashTreeParser = /*#__PURE__*/function () {
               }
               return _context7.abrupt("return");
             case 1:
+              abortController = (_dataSet$syncAbortCon = dataSet.syncAbortController) !== null && _dataSet$syncAbortCon !== void 0 ? _dataSet$syncAbortCon : new AbortController();
+              dataSet.syncAbortController = abortController;
               hashTree = dataSet.hashTree;
               rootHash = hashTree.getRootHash();
               _context7.prev = 2;
@@ -1398,59 +1423,110 @@ var HashTreeParser = /*#__PURE__*/function () {
                 0: hashTree.getLeafData(0)
               };
             case 10:
+              if (!abortController.signal.aborted) {
+                _context7.next = 11;
+                break;
+              }
+              _loggerProxy.default.logger.info("HashTreeParser#performSync --> ".concat(this.debugId, " abandoning sync for \"").concat(dataSet.name, "\" before /sync - message received during sync"));
+              return _context7.abrupt("return");
+            case 11:
               // request sync for mismatched leaves
               syncResponse = null;
               if (!isInitialization) {
-                _context7.next = 12;
+                _context7.next = 13;
                 break;
               }
-              _context7.next = 11;
+              _context7.next = 12;
               return this.sendSyncRequestToLocus(dataSet, {
                 isInitialization: true
               });
-            case 11:
+            case 12:
               syncResponse = _context7.sent;
-              _context7.next = 14;
+              _context7.next = 15;
               break;
-            case 12:
+            case 13:
               if (!((0, _keys.default)(leavesData).length > 0)) {
-                _context7.next = 14;
+                _context7.next = 15;
                 break;
               }
-              _context7.next = 13;
+              _context7.next = 14;
               return this.sendSyncRequestToLocus(dataSet, {
                 mismatchedLeavesData: leavesData
               });
-            case 13:
-              syncResponse = _context7.sent;
             case 14:
+              syncResponse = _context7.sent;
+            case 15:
               // sync API may return nothing (in that case data will arrive via messages)
               // or it may return a response in the same format as messages
               // We still need to restart the sync timer as a safety net in case the messages don't arrive.
               this.runSyncAlgorithm(dataSet);
               if (syncResponse) {
+                // clear the abort controller before processing the response so that
+                // parseMessage() -> cancelPendingSyncsForDataSets() doesn't log a
+                // misleading "aborting sync" message for this already-completed sync
+                dataSet.syncAbortController = undefined;
                 // the format of sync response is the same as messages, so we can reuse the same handler
                 this.handleMessage(syncResponse, 'via sync API');
               }
-              _context7.next = 16;
+              _context7.next = 17;
               break;
-            case 15:
-              _context7.prev = 15;
+            case 16:
+              _context7.prev = 16;
               _t4 = _context7["catch"](2);
               if (!this.handleSyncErrors(_t4)) {
                 _loggerProxy.default.logger.warn("HashTreeParser#performSync --> ".concat(this.debugId, " error during sync for data set \"").concat(dataSet.name, "\":"), _t4);
               }
-            case 16:
+            case 17:
+              _context7.prev = 17;
+              dataSet.syncAbortController = undefined;
+              return _context7.finish(17);
+            case 18:
             case "end":
               return _context7.stop();
           }
-        }, _callee6, this, [[2, 15], [3, 6]]);
+        }, _callee6, this, [[2, 16, 17, 18], [3, 6]]);
       }));
       function performSync(_x8, _x9, _x0) {
         return _performSync.apply(this, arguments);
       }
       return performSync;
     }()
+    /**
+     * Cancels any pending or in-flight syncs for the specified data sets.
+     * This removes matching entries from the sync queue and aborts any in-flight sync HTTP requests.
+     *
+     * @param {string[]} dataSetNames - The names of the data sets to cancel syncs for
+     * @returns {void}
+     */
+    )
+  }, {
+    key: "cancelPendingSyncsForDataSets",
+    value: function cancelPendingSyncsForDataSets(dataSetNames) {
+      var previousLength = this.syncQueue.length;
+      this.syncQueue = this.syncQueue.filter(function (entry) {
+        return !dataSetNames.includes(entry.dataSetName);
+      });
+      if (previousLength !== this.syncQueue.length) {
+        _loggerProxy.default.logger.info("HashTreeParser#cancelPendingSyncsForDataSets --> ".concat(this.debugId, " removed ").concat(previousLength - this.syncQueue.length, " entries from sync queue for data sets: ").concat(dataSetNames.join(', ')));
+      }
+      var _iterator9 = _createForOfIteratorHelper(dataSetNames),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _this$dataSets$name;
+          var name = _step9.value;
+          if ((_this$dataSets$name = this.dataSets[name]) !== null && _this$dataSets$name !== void 0 && _this$dataSets$name.syncAbortController) {
+            _loggerProxy.default.logger.info("HashTreeParser#cancelPendingSyncsForDataSets --> ".concat(this.debugId, " aborting in-flight sync for data set \"").concat(name, "\""));
+            this.dataSets[name].syncAbortController.abort();
+          }
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+    }
+
     /**
      * Enqueues a sync for the given data set. If the data set is already in the queue, the request is ignored.
      * This ensures that all syncs are executed sequentially and no more than 1 sync runs at a time.
@@ -1460,7 +1536,6 @@ var HashTreeParser = /*#__PURE__*/function () {
      * @param {boolean} [isInitialization=false] - Whether this is an initialization sync (uses empty leaves data instead of hash comparison)
      * @returns {void}
      */
-    )
   }, {
     key: "enqueueSyncForDataset",
     value: function enqueueSyncForDataset(dataSetName, reason) {
@@ -1495,7 +1570,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "processSyncQueue",
     value: (function () {
       var _processSyncQueue = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
-        var _ref7, dataSetName, reason, isInitialization, dataSet;
+        var _ref8, dataSetName, reason, isInitialization, dataSet;
         return _regenerator.default.wrap(function (_context8) {
           while (1) switch (_context8.prev = _context8.next) {
             case 0:
@@ -1513,7 +1588,7 @@ var HashTreeParser = /*#__PURE__*/function () {
                 break;
               }
               // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              _ref7 = this.syncQueue.shift(), dataSetName = _ref7.dataSetName, reason = _ref7.reason, isInitialization = _ref7.isInitialization;
+              _ref8 = this.syncQueue.shift(), dataSetName = _ref8.dataSetName, reason = _ref8.reason, isInitialization = _ref8.isInitialization;
               dataSet = this.dataSets[dataSetName];
               if (dataSet !== null && dataSet !== void 0 && dataSet.hashTree) {
                 _context8.next = 4;
@@ -1553,7 +1628,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     key: "syncAllDatasets",
     value: (function () {
       var _syncAllDatasets = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
-        var dataSetsWithHashTrees, sorted, _iterator9, _step9, ds;
+        var dataSetsWithHashTrees, sorted, _iterator0, _step0, ds;
         return _regenerator.default.wrap(function (_context9) {
           while (1) switch (_context9.prev = _context9.next) {
             case 0:
@@ -1582,16 +1657,16 @@ var HashTreeParser = /*#__PURE__*/function () {
               _loggerProxy.default.logger.info("HashTreeParser#syncAllDatasets --> ".concat(this.debugId, " syncing datasets: ").concat(sorted.map(function (ds) {
                 return ds.name;
               }).join(', ')));
-              _iterator9 = _createForOfIteratorHelper(sorted);
+              _iterator0 = _createForOfIteratorHelper(sorted);
               try {
-                for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-                  ds = _step9.value;
+                for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+                  ds = _step0.value;
                   this.enqueueSyncForDataset(ds.name, 'syncAllDatasets');
                 }
               } catch (err) {
-                _iterator9.e(err);
+                _iterator0.e(err);
               } finally {
-                _iterator9.f();
+                _iterator0.f();
               }
               _context9.next = 4;
               return this.syncQueueProcessingPromise;
@@ -1627,7 +1702,9 @@ var HashTreeParser = /*#__PURE__*/function () {
         return;
       }
       if (!dataSet.hashTree) {
-        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " Data set \"").concat(dataSet.name, "\" has no hash tree, skipping sync algorithm"));
+        // no hash tree, so no need to do any syncing
+        // we fall into this branch often, because Locus sends dataSets in messages that are not visible to us
+
         return;
       }
       dataSet.hashTree.resize(receivedDataSet.leafCount);
@@ -1636,7 +1713,6 @@ var HashTreeParser = /*#__PURE__*/function () {
         if (dataSet.timer) {
           clearTimeout(dataSet.timer);
         }
-        _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " setting \"").concat(dataSet.name, "\" sync timer for ").concat(delay));
         dataSet.timer = setTimeout(function () {
           dataSet.timer = undefined;
           if (!dataSet.hashTree) {
@@ -1646,8 +1722,6 @@ var HashTreeParser = /*#__PURE__*/function () {
           var rootHash = dataSet.hashTree.getRootHash();
           if (dataSet.root !== rootHash) {
             _this10.enqueueSyncForDataset(dataSet.name, "Root hash mismatch: received=".concat(dataSet.root, ", ours=").concat(rootHash));
-          } else {
-            _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this10.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
           }
         }, delay);
       } else {
@@ -1671,11 +1745,11 @@ var HashTreeParser = /*#__PURE__*/function () {
       if (!this.heartbeatIntervalMs) {
         return;
       }
-      var _iterator0 = _createForOfIteratorHelper(receivedDataSets),
-        _step0;
+      var _iterator1 = _createForOfIteratorHelper(receivedDataSets),
+        _step1;
       try {
         var _loop2 = function _loop2() {
-          var receivedDataSet = _step0.value;
+          var receivedDataSet = _step1.value;
           var dataSet = _this11.dataSets[receivedDataSet.name];
           if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree)) {
             // eslint-disable-next-line no-continue
@@ -1690,17 +1764,21 @@ var HashTreeParser = /*#__PURE__*/function () {
           dataSet.heartbeatWatchdogTimer = setTimeout(function () {
             dataSet.heartbeatWatchdogTimer = undefined;
             _loggerProxy.default.logger.warn("HashTreeParser#resetHeartbeatWatchdogs --> ".concat(_this11.debugId, " Heartbeat watchdog fired for data set \"").concat(dataSet.name, "\" - no heartbeat received within expected interval, initiating sync"));
+            _metrics.default.sendBehavioralMetric(_constants.default.HASH_TREE_HEARTBEAT_WATCHDOG_EXPIRED, {
+              debugId: _this11.debugId,
+              dataSetName: dataSet.name
+            });
             _this11.enqueueSyncForDataset(dataSet.name, "heartbeat watchdog expired");
             _this11.resetHeartbeatWatchdogs([dataSet]);
           }, delay);
         };
-        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
           if (_loop2()) continue;
         }
       } catch (err) {
-        _iterator0.e(err);
+        _iterator1.e(err);
       } finally {
-        _iterator0.f();
+        _iterator1.f();
       }
     }
 
@@ -1736,6 +1814,9 @@ var HashTreeParser = /*#__PURE__*/function () {
       this.stopAllTimers();
       this.syncQueue = [];
       (0, _values.default)(this.dataSets).forEach(function (dataSet) {
+        var _dataSet$syncAbortCon2;
+        (_dataSet$syncAbortCon2 = dataSet.syncAbortController) === null || _dataSet$syncAbortCon2 === void 0 ? void 0 : _dataSet$syncAbortCon2.abort();
+        dataSet.syncAbortController = undefined;
         dataSet.hashTree = undefined;
       });
       this.visibleDataSets = [];
@@ -1762,9 +1843,9 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "resumeFromMessage",
     value: function resumeFromMessage(message) {
-      var _message$locusStateEl2, _metadataObject$data;
+      var _message$locusStateEl3, _metadataObject$data;
       // check that message contains metadata with visible data sets - this is essential to be able to resume
-      var metadataObject = (_message$locusStateEl2 = message.locusStateElements) === null || _message$locusStateEl2 === void 0 ? void 0 : _message$locusStateEl2.find(function (el) {
+      var metadataObject = (_message$locusStateEl3 = message.locusStateElements) === null || _message$locusStateEl3 === void 0 ? void 0 : _message$locusStateEl3.find(function (el) {
         return (0, _utils.isMetadata)(el);
       });
       if (!(metadataObject !== null && metadataObject !== void 0 && (_metadataObject$data = metadataObject.data) !== null && _metadataObject$data !== void 0 && _metadataObject$data.visibleDataSets)) {
@@ -1773,11 +1854,11 @@ var HashTreeParser = /*#__PURE__*/function () {
       }
       this.setVisibleDataSets(metadataObject.data.visibleDataSets, message.dataSets);
       this.dataSets = {};
-      var _iterator1 = _createForOfIteratorHelper(message.dataSets),
-        _step1;
+      var _iterator10 = _createForOfIteratorHelper(message.dataSets),
+        _step10;
       try {
-        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
-          var dataSet = _step1.value;
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var dataSet = _step10.value;
           var name = dataSet.name,
             leafCount = dataSet.leafCount;
           this.dataSets[name] = _objectSpread(_objectSpread({}, dataSet), {}, {
@@ -1785,9 +1866,9 @@ var HashTreeParser = /*#__PURE__*/function () {
           });
         }
       } catch (err) {
-        _iterator1.e(err);
+        _iterator10.e(err);
       } finally {
-        _iterator1.f();
+        _iterator10.f();
       }
       _loggerProxy.default.logger.info("HashTreeParser#resumeFromMessage --> ".concat(this.debugId, " Resuming HashTreeParser with data sets: ").concat((0, _keys.default)(this.dataSets).join(', '), ", visible data sets: ").concat(this.visibleDataSets.map(function (ds) {
         return ds.name;
@@ -1940,7 +2021,6 @@ var HashTreeParser = /*#__PURE__*/function () {
         },
         body: body
       }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this13.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
         if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
           _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this13.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
           return null;