@webex/plugin-meetings 3.11.0-next.24 → 3.11.0-next.25

package/dist/breakouts/breakout.js

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

package/dist/breakouts/index.js

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

package/dist/hashTree/hashTreeParser.js

@@ -87,6 +87,7 @@ var HashTreeParser = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "locusInfoUpdateCallback", void 0);
     (0, _defineProperty2.default)(this, "visibleDataSets", void 0);
     (0, _defineProperty2.default)(this, "debugId", void 0);
+    (0, _defineProperty2.default)(this, "heartbeatIntervalMs", void 0);
     var _options$initialLocus = options.initialLocus,
       dataSets = _options$initialLocus.dataSets,
       locus = _options$initialLocus.locus; // extract dataSets from initialLocus
@@ -763,11 +764,15 @@ var HashTreeParser = /*#__PURE__*/function () {
     value: function deleteHashTree(dataSetName) {
       this.dataSets[dataSetName].hashTree = undefined;
 
-      // we also need to stop the timer as there is no hash tree anymore to sync
+      // we also need to stop the timers as there is no hash tree anymore to sync
       if (this.dataSets[dataSetName].timer) {
         clearTimeout(this.dataSets[dataSetName].timer);
         this.dataSets[dataSetName].timer = undefined;
       }
+      if (this.dataSets[dataSetName].heartbeatWatchdogTimer) {
+        clearTimeout(this.dataSets[dataSetName].heartbeatWatchdogTimer);
+        this.dataSets[dataSetName].heartbeatWatchdogTimer = undefined;
+      }
     }
 
     /**
@@ -1103,11 +1108,15 @@ var HashTreeParser = /*#__PURE__*/function () {
         return _regenerator.default.wrap(function (_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
+              if (message.heartbeatIntervalMs) {
+                this.heartbeatIntervalMs = message.heartbeatIntervalMs;
+              }
               if (!(message.locusStateElements === undefined)) {
                 _context7.next = 1;
                 break;
               }
               this.handleRootHashHeartBeatMessage(message);
+              this.resetHeartbeatWatchdogs(message.dataSets);
               _context7.next = 3;
               break;
             case 1:
@@ -1115,6 +1124,10 @@ var HashTreeParser = /*#__PURE__*/function () {
               return this.parseMessage(message, debugText);
             case 2:
               updates = _context7.sent;
+              // Only reset watchdogs if the meeting hasn't ended
+              if (updates.updateType !== LocusInfoUpdateType.MEETING_ENDED) {
+                this.resetHeartbeatWatchdogs(message.dataSets);
+              }
               this.callLocusInfoUpdateCallback(updates);
             case 3:
             case "end":
@@ -1201,12 +1214,99 @@ var HashTreeParser = /*#__PURE__*/function () {
       return Math.round(Math.pow(randomValue, exponent) * maxMs);
     }
 
+    /**
+     * Performs a sync for the given data set.
+     *
+     * @param {InternalDataSet} dataSet - The data set to sync
+     * @param {string} rootHash - Our current root hash for this data set
+     * @param {string} reason - The reason for the sync (used for logging)
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "performSync",
+    value: (function () {
+      var _performSync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7(dataSet, rootHash, reason) {
+        var mismatchedLeavesData, receivedHashes, _yield$this$getHashes, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3;
+        return _regenerator.default.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              if (dataSet.hashTree) {
+                _context8.next = 1;
+                break;
+              }
+              return _context8.abrupt("return");
+            case 1:
+              _loggerProxy.default.logger.info("HashTreeParser#performSync --> ".concat(this.debugId, " ").concat(reason, ", syncing data set \"").concat(dataSet.name, "\""));
+              mismatchedLeavesData = {};
+              if (!(dataSet.leafCount !== 1)) {
+                _context8.next = 7;
+                break;
+              }
+              _context8.prev = 2;
+              _context8.next = 3;
+              return this.getHashesFromLocus(dataSet.name, rootHash);
+            case 3:
+              _yield$this$getHashes = _context8.sent;
+              hashes = _yield$this$getHashes.hashes;
+              latestDataSetInfo = _yield$this$getHashes.dataSet;
+              receivedHashes = hashes;
+              dataSet.hashTree.resize(latestDataSetInfo.leafCount);
+              _context8.next = 6;
+              break;
+            case 4:
+              _context8.prev = 4;
+              _t3 = _context8["catch"](2);
+              if (!(_t3.statusCode === 409)) {
+                _context8.next = 5;
+                break;
+              }
+              // this is a leaf count mismatch, we should do nothing, just wait for another heartbeat message from Locus
+              _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(this.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
+              return _context8.abrupt("return");
+            case 5:
+              throw _t3;
+            case 6:
+              // identify mismatched leaves
+              mismatchedLeaveIndexes = dataSet.hashTree.diffHashes(receivedHashes);
+              mismatchedLeaveIndexes.forEach(function (index) {
+                mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
+              });
+              _context8.next = 8;
+              break;
+            case 7:
+              mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
+            case 8:
+              if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
+                _context8.next = 10;
+                break;
+              }
+              _context8.next = 9;
+              return this.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
+            case 9:
+              syncResponse = _context8.sent;
+              // 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
+              if (syncResponse) {
+                this.handleMessage(syncResponse, 'via sync API');
+              }
+            case 10:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee7, this, [[2, 4]]);
+      }));
+      function performSync(_x0, _x1, _x10) {
+        return _performSync.apply(this, arguments);
+      }
+      return performSync;
+    }()
     /**
      * Runs the sync algorithm for the given data set.
      *
      * @param {DataSet} receivedDataSet - The data set to run the sync algorithm for.
      * @returns {void}
      */
+    )
   }, {
     key: "runSyncAlgorithm",
     value: function runSyncAlgorithm(receivedDataSet) {
@@ -1231,93 +1331,99 @@ var HashTreeParser = /*#__PURE__*/function () {
           clearTimeout(dataSet.timer);
         }
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " setting \"").concat(dataSet.name, "\" sync timer for ").concat(delay));
-        dataSet.timer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
-          var rootHash, mismatchedLeavesData, receivedHashes, _yield$_this0$getHash, hashes, latestDataSetInfo, mismatchedLeaveIndexes, syncResponse, _t3;
-          return _regenerator.default.wrap(function (_context8) {
-            while (1) switch (_context8.prev = _context8.next) {
+        dataSet.timer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+          var rootHash;
+          return _regenerator.default.wrap(function (_context9) {
+            while (1) switch (_context9.prev = _context9.next) {
               case 0:
                 dataSet.timer = undefined;
                 if (dataSet.hashTree) {
-                  _context8.next = 1;
+                  _context9.next = 1;
                   break;
                 }
                 _loggerProxy.default.logger.warn("HashTreeParser#runSyncAlgorithm --> ".concat(_this0.debugId, " Data set \"").concat(dataSet.name, "\" no longer has a hash tree, cannot run sync algorithm"));
-                return _context8.abrupt("return");
+                return _context9.abrupt("return");
               case 1:
                 rootHash = dataSet.hashTree.getRootHash();
                 if (!(dataSet.root !== rootHash)) {
-                  _context8.next = 11;
+                  _context9.next = 3;
                   break;
                 }
-                _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this0.debugId, " Root hash mismatch: received=").concat(dataSet.root, ", ours=").concat(rootHash, ", syncing data set \"").concat(dataSet.name, "\""));
-                mismatchedLeavesData = {};
-                if (!(dataSet.leafCount !== 1)) {
-                  _context8.next = 7;
-                  break;
-                }
-                _context8.prev = 2;
-                _context8.next = 3;
-                return _this0.getHashesFromLocus(dataSet.name, rootHash);
-              case 3:
-                _yield$_this0$getHash = _context8.sent;
-                hashes = _yield$_this0$getHash.hashes;
-                latestDataSetInfo = _yield$_this0$getHash.dataSet;
-                receivedHashes = hashes;
-                dataSet.hashTree.resize(latestDataSetInfo.leafCount);
-                _context8.next = 6;
-                break;
-              case 4:
-                _context8.prev = 4;
-                _t3 = _context8["catch"](2);
-                if (!(_t3.statusCode === 409)) {
-                  _context8.next = 5;
-                  break;
-                }
-                // this is a leaf count mismatch, we should do nothing, just wait for another heartbeat message from Locus
-                _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this0.debugId, " Got 409 when fetching hashes for data set \"").concat(dataSet.name, "\": ").concat(_t3.message));
-                return _context8.abrupt("return");
-              case 5:
-                throw _t3;
-              case 6:
-                // identify mismatched leaves
-                mismatchedLeaveIndexes = dataSet.hashTree.diffHashes(receivedHashes);
-                mismatchedLeaveIndexes.forEach(function (index) {
-                  mismatchedLeavesData[index] = dataSet.hashTree.getLeafData(index);
-                });
-                _context8.next = 8;
+                _context9.next = 2;
+                return _this0.performSync(dataSet, rootHash, "Root hash mismatch: received=".concat(dataSet.root, ", ours=").concat(rootHash));
+              case 2:
+                _context9.next = 4;
                 break;
-              case 7:
-                mismatchedLeavesData[0] = dataSet.hashTree.getLeafData(0);
-              case 8:
-                if (!((0, _keys.default)(mismatchedLeavesData).length > 0)) {
-                  _context8.next = 10;
-                  break;
-                }
-                _context8.next = 9;
-                return _this0.sendSyncRequestToLocus(dataSet, mismatchedLeavesData);
-              case 9:
-                syncResponse = _context8.sent;
-                // 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
-                if (syncResponse) {
-                  _this0.handleMessage(syncResponse, 'via sync API');
-                }
-              case 10:
-                _context8.next = 12;
-                break;
-              case 11:
+              case 3:
                 _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(_this0.debugId, " \"").concat(dataSet.name, "\" root hash matching: ").concat(rootHash, ", version=").concat(dataSet.version));
-              case 12:
+              case 4:
               case "end":
-                return _context8.stop();
+                return _context9.stop();
             }
-          }, _callee7, null, [[2, 4]]);
+          }, _callee8);
         })), delay);
       } else {
         _loggerProxy.default.logger.info("HashTreeParser#runSyncAlgorithm --> ".concat(this.debugId, " No delay for \"").concat(dataSet.name, "\" data set, skipping sync timer reset/setup"));
       }
     }
 
+    /**
+     * Resets the heartbeat watchdog timers for the specified data sets. Each data set has its own
+     * watchdog timer that monitors whether heartbeats are being received within the expected interval.
+     * If a heartbeat is not received for a specific data set within heartbeatIntervalMs plus
+     * a backoff-calculated time, the sync algorithm is initiated for that data set
+     *
+     * @param {Array<DataSet>} receivedDataSets - The data sets from the received message for which watchdog timers should be reset
+     * @returns {void}
+     */
+  }, {
+    key: "resetHeartbeatWatchdogs",
+    value: function resetHeartbeatWatchdogs(receivedDataSets) {
+      var _this1 = this;
+      if (!this.heartbeatIntervalMs) {
+        return;
+      }
+      var _iterator9 = _createForOfIteratorHelper(receivedDataSets),
+        _step9;
+      try {
+        var _loop2 = function _loop2() {
+          var receivedDataSet = _step9.value;
+          var dataSet = _this1.dataSets[receivedDataSet.name];
+          if (!(dataSet !== null && dataSet !== void 0 && dataSet.hashTree)) {
+            // eslint-disable-next-line no-continue
+            return 1; // continue
+          }
+          if (dataSet.heartbeatWatchdogTimer) {
+            clearTimeout(dataSet.heartbeatWatchdogTimer);
+            dataSet.heartbeatWatchdogTimer = undefined;
+          }
+          var backoffTime = _this1.getWeightedBackoffTime(dataSet.backoff);
+          var delay = _this1.heartbeatIntervalMs + backoffTime;
+          dataSet.heartbeatWatchdogTimer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+            return _regenerator.default.wrap(function (_context0) {
+              while (1) switch (_context0.prev = _context0.next) {
+                case 0:
+                  dataSet.heartbeatWatchdogTimer = undefined;
+                  _loggerProxy.default.logger.warn("HashTreeParser#resetHeartbeatWatchdogs --> ".concat(_this1.debugId, " Heartbeat watchdog fired for data set \"").concat(dataSet.name, "\" - no heartbeat received within expected interval, initiating sync"));
+                  _context0.next = 1;
+                  return _this1.performSync(dataSet, dataSet.hashTree.getRootHash(), "heartbeat watchdog expired");
+                case 1:
+                case "end":
+                  return _context0.stop();
+              }
+            }, _callee9);
+          })), delay);
+        };
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          if (_loop2()) continue;
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+    }
+
     /**
      * Stops all timers for the data sets to prevent any further sync attempts.
      * @returns {void}
@@ -1330,6 +1436,10 @@ var HashTreeParser = /*#__PURE__*/function () {
           clearTimeout(dataSet.timer);
           dataSet.timer = undefined;
         }
+        if (dataSet.heartbeatWatchdogTimer) {
+          clearTimeout(dataSet.heartbeatWatchdogTimer);
+          dataSet.heartbeatWatchdogTimer = undefined;
+        }
       });
     }
 
@@ -1342,7 +1452,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "getHashesFromLocus",
     value: function getHashesFromLocus(dataSetName, currentRootHash) {
-      var _this1 = this;
+      var _this10 = this;
       _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(this.debugId, " Requesting hashes for data set \"").concat(dataSetName, "\""));
       var dataSet = this.dataSets[dataSetName];
       var url = "".concat(dataSet.url, "/hashtree");
@@ -1357,16 +1467,16 @@ var HashTreeParser = /*#__PURE__*/function () {
         var hashes = (_response$body = response.body) === null || _response$body === void 0 ? void 0 : _response$body.hashes;
         var dataSetFromResponse = (_response$body2 = response.body) === null || _response$body2 === void 0 ? void 0 : _response$body2.dataSet;
         if (!hashes || !(0, _isArray.default)(hashes)) {
-          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this1.debugId, " Locus returned invalid hashes, response body="), response.body);
+          _loggerProxy.default.logger.warn("HashTreeParser#getHashesFromLocus --> ".concat(_this10.debugId, " Locus returned invalid hashes, response body="), response.body);
           throw new Error("Locus returned invalid hashes: ".concat(hashes));
         }
-        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this1.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
+        _loggerProxy.default.logger.info("HashTreeParser#getHashesFromLocus --> ".concat(_this10.debugId, " Received hashes for data set \"").concat(dataSetName, "\": ").concat((0, _stringify.default)(hashes)));
         return {
           hashes: hashes,
           dataSet: dataSetFromResponse
         };
       }).catch(function (error) {
-        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this1.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
+        _loggerProxy.default.logger.error("HashTreeParser#getHashesFromLocus --> ".concat(_this10.debugId, " Error ").concat(error.statusCode, " fetching hashes for data set \"").concat(dataSetName, "\":"), error);
         throw error;
       });
     }
@@ -1381,7 +1491,7 @@ var HashTreeParser = /*#__PURE__*/function () {
   }, {
     key: "sendSyncRequestToLocus",
     value: function sendSyncRequestToLocus(dataSet, mismatchedLeavesData) {
-      var _this10 = this;
+      var _this11 = this;
       _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(this.debugId, " Sending sync request for data set \"").concat(dataSet.name, "\""));
       var url = "".concat(dataSet.url, "/sync");
       var body = {
@@ -1403,14 +1513,14 @@ var HashTreeParser = /*#__PURE__*/function () {
         },
         body: body
       }).then(function (resp) {
-        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this10.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
+        _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this11.debugId, " Sync request succeeded for \"").concat(dataSet.name, "\""));
         if (!resp.body || (0, _lodash.isEmpty)(resp.body)) {
-          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this10.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
+          _loggerProxy.default.logger.info("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this11.debugId, " Got ").concat(resp.statusCode, " with empty body for sync request for data set \"").concat(dataSet.name, "\", data should arrive via messages"));
           return null;
         }
         return resp.body;
       }).catch(function (error) {
-        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this10.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
+        _loggerProxy.default.logger.error("HashTreeParser#sendSyncRequestToLocus --> ".concat(_this11.debugId, " Error ").concat(error.statusCode, " sending sync request for data set \"").concat(dataSet.name, "\":"), error);
         throw error;
       });
     }