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

package/dist/locus-info/parser.js

@@ -10,43 +10,93 @@ var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime-cor
 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 _difference2 = _interopRequireDefault(require("lodash/difference"));
+var _lodash = require("lodash");
 var _queue = _interopRequireDefault(require("../common/queue"));
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
+var _metrics = _interopRequireDefault(require("../metrics"));
+var _constants = _interopRequireDefault(require("../metrics/constants"));
 var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10;
+var MAX_OOO_DELTA_COUNT = 5; // when we receive an out-of-order delta and the queue builds up to MAX_OOO_DELTA_COUNT, we do a sync with Locus
+var OOO_DELTA_WAIT_TIME = 10000; // [ms] minimum wait time before we do a sync if we get out-of-order deltas
+var OOO_DELTA_WAIT_TIME_RANDOM_DELAY = 5000; // [ms] max random delay added to OOO_DELTA_WAIT_TIME
 /**
  * Locus Delta Parser
  * @private
  * https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Delta-Events
  */
-var Parser = /*#__PURE__*/function () {
-  // processing status
-
-  // loci comparison states
-
+var Parser = exports.default = /*#__PURE__*/function () {
   /**
    * @constructs Parser
    */
   function Parser() {
     (0, _classCallCheck2.default)(this, Parser);
+    // processing status
+    (0, _defineProperty2.default)(this, "status", void 0);
     (0, _defineProperty2.default)(this, "queue", void 0);
     (0, _defineProperty2.default)(this, "workingCopy", void 0);
-    this.queue = new _queue.default();
-    // @ts-ignore - This is declared as static class member and again being initialized here from same
-    this.status = Parser.status.IDLE;
+    (0, _defineProperty2.default)(this, "syncTimer", void 0);
+    var deltaCompareFunc = function deltaCompareFunc(left, right) {
+      var _Parser$loci = Parser.loci,
+        LT = _Parser$loci.LT,
+        GT = _Parser$loci.GT;
+      var extract = Parser.extractComparisonState;
+      if (Parser.isSequenceEmpty(left)) {
+        return -1;
+      }
+      if (Parser.isSequenceEmpty(right)) {
+        return 1;
+      }
+      var result = extract(Parser.compareSequence(left.baseSequence, right.baseSequence));
+      if (result === LT) {
+        return -1;
+      }
+      if (result === GT) {
+        return 1;
+      }
+      return 0;
+    };
+    this.queue = new _queue.default(deltaCompareFunc);
+    this.status = 'IDLE';
     this.onDeltaAction = null;
     this.workingCopy = null;
+    this.syncTimer = undefined;
   }
 
   /**
-   * Checks if two sequences overlap in time,
-   * the sequence with the higher minimum value is greater.
-   * Chooses sequence with most recent data.
-   * @param {Types~Locus} current
-   * @param {Types~Locus} incoming
-   * @returns {string} loci comparison state
+   * Returns a debug string representing a locus delta - useful for logging
+   *
+   * @param {LocusDeltaDto} locus Locus delta
+   * @returns {string}
    */
   (0, _createClass2.default)(Parser, [{
+    key: "isNewFullLocus",
+    value:
+    /**
+     * Returns true if the incoming full locus DTO is newer than the current working copy
+     *
+     * @param {Types~Locus} incomingFullDto New Full Locus DTO
+     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
+     */
+    function isNewFullLocus(incomingFullDto) {
+      if (!Parser.isLoci(incomingFullDto)) {
+        _loggerProxy.default.logger.info('Locus-info:parser#isNewFullLocus --> Ignoring non-locus object.');
+        return false;
+      }
+      if (!this.workingCopy) {
+        // we don't have a working copy yet, so any full locus is better than nothing
+        return true;
+      }
+      var comparisonResult = Parser.compareFullDtoSequence(this.workingCopy, incomingFullDto);
+      return comparisonResult === Parser.loci.USE_INCOMING;
+    }
+
+    /**
+     * Compares Locus sequences
+     * @param {Types~Locus} current Current working copy
+     * @param {Types~Locus} incoming New Locus delta
+     * @returns {string}
+     */
+  }, {
     key: "isValidLocus",
     value:
     /**
@@ -55,19 +105,11 @@ var Parser = /*#__PURE__*/function () {
      * @returns {boolean}
      */
     function isValidLocus(newLoci) {
-      var _this = this;
       var isValid = false;
-      var IDLE = Parser.status.IDLE;
       var isLoci = Parser.isLoci;
-      // @ts-ignore
-      var setStatus = function setStatus(status) {
-        // @ts-ignore
-        _this.status = status;
-      };
 
       // one or both objects are not locus delta events
       if (!isLoci(this.workingCopy) || !isLoci(newLoci)) {
-        setStatus(IDLE);
         _loggerProxy.default.logger.info('Locus-info:parser#processDeltaEvent --> Ignoring non-locus object. workingCopy:', this.workingCopy, 'newLoci:', newLoci);
       } else {
         isValid = true;
@@ -89,18 +131,20 @@ var Parser = /*#__PURE__*/function () {
      * @returns {undefined}
      */
     function nextEvent() {
-      // @ts-ignore
-      if (this.status === Parser.status.PAUSED) {
+      if (this.status === 'PAUSED') {
         _loggerProxy.default.logger.info('Locus-info:parser#nextEvent --> Locus parser paused.');
         return;
       }
+      if (this.status === 'BLOCKED') {
+        _loggerProxy.default.logger.info('Locus-info:parser#nextEvent --> Locus parser blocked by out-of-order delta.');
+        return;
+      }
 
       // continue processing until queue is empty
       if (this.queue.size() > 0) {
         this.processDeltaEvent();
       } else {
-        // @ts-ignore
-        this.status = Parser.status.IDLE;
+        this.status = 'IDLE';
       }
     }
 
@@ -111,7 +155,7 @@ var Parser = /*#__PURE__*/function () {
      * @param {Types~Locus} locus Locus delta
      * @returns {undefined}
      */
-    // eslint-disable-next-line no-unused-vars
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   }, {
     key: "onDeltaAction",
     value: function onDeltaAction(action, locus) {}
@@ -126,14 +170,18 @@ var Parser = /*#__PURE__*/function () {
     value: function onDeltaEvent(loci) {
       // enqueue the new loci
       this.queue.enqueue(loci);
-      // start processing events in the queue if idle
-      // and a function handler is defined
-      // @ts-ignore
-      if (this.status === Parser.status.IDLE && this.onDeltaAction) {
-        // Update status, ensure we only process one event at a time.
-        // @ts-ignore
-        this.status = Parser.status.WORKING;
-        this.processDeltaEvent();
+      if (this.onDeltaAction) {
+        if (this.status === 'BLOCKED') {
+          if (this.queue.size() > MAX_OOO_DELTA_COUNT) {
+            this.triggerSync('queue too big, blocked on out-of-order delta');
+          } else {
+            this.processDeltaEvent();
+          }
+        } else if (this.status === 'IDLE') {
+          // Update status, ensure we only process one event at a time.
+          this.status = 'WORKING';
+          this.processDeltaEvent();
+        }
       }
     }
 
@@ -151,11 +199,61 @@ var Parser = /*#__PURE__*/function () {
      * @returns {undefined}
      */
     function pause() {
-      // @ts-ignore
-      this.status = Parser.status.PAUSED;
+      this.status = 'PAUSED';
       _loggerProxy.default.logger.info('Locus-info:parser#pause --> Locus parser paused.');
     }
 
+    /**
+     * Triggers a sync with Locus
+     *
+     * @param {string} reason used just for logging
+     * @returns {undefined}
+     */
+  }, {
+    key: "triggerSync",
+    value: function triggerSync(reason) {
+      _loggerProxy.default.logger.info("Locus-info:parser#triggerSync --> doing sync, reason: ".concat(reason));
+      this.stopSyncTimer();
+      this.pause();
+      this.onDeltaAction(Parser.loci.DESYNC, this.workingCopy);
+    }
+
+    /**
+     * Starts a timer with a random delay. When that timer expires we will do a sync.
+     *
+     * The main purpose of this timer is to handle a case when we get some out-of-order deltas,
+     * so we start waiting to receive the missing delta. If that delta never arrives, this timer
+     * will trigger a sync with Locus.
+     *
+     * @returns {undefined}
+     */
+  }, {
+    key: "startSyncTimer",
+    value: function startSyncTimer() {
+      var _this = this;
+      if (this.syncTimer === undefined) {
+        var timeout = OOO_DELTA_WAIT_TIME + Math.random() * OOO_DELTA_WAIT_TIME_RANDOM_DELAY;
+        this.syncTimer = setTimeout(function () {
+          _this.syncTimer = undefined;
+          _this.triggerSync('timer expired, blocked on out-of-order delta');
+        }, timeout);
+      }
+    }
+
+    /**
+     * Stops the timer for triggering a sync
+     *
+     * @returns {undefined}
+     */
+  }, {
+    key: "stopSyncTimer",
+    value: function stopSyncTimer() {
+      if (this.syncTimer !== undefined) {
+        clearTimeout(this.syncTimer);
+        this.syncTimer = undefined;
+      }
+    }
+
     /**
      * Processes next locus delta in the queue,
      * continues until the queue is empty
@@ -165,12 +263,15 @@ var Parser = /*#__PURE__*/function () {
   }, {
     key: "processDeltaEvent",
     value: function processDeltaEvent() {
-      var _Parser$loci = Parser.loci,
-        DESYNC = _Parser$loci.DESYNC,
-        USE_INCOMING = _Parser$loci.USE_INCOMING;
+      var _Parser$loci2 = Parser.loci,
+        DESYNC = _Parser$loci2.DESYNC,
+        USE_INCOMING = _Parser$loci2.USE_INCOMING,
+        WAIT = _Parser$loci2.WAIT,
+        LOCUS_URL_CHANGED = _Parser$loci2.LOCUS_URL_CHANGED;
       var extract = Parser.extractComparisonState;
       var newLoci = this.queue.dequeue();
       if (!this.isValidLocus(newLoci)) {
+        this.nextEvent();
         return;
       }
       var result = Parser.compare(this.workingCopy, newLoci);
@@ -179,20 +280,42 @@ var Parser = /*#__PURE__*/function () {
       // limited debugging, use chrome extension
       // for full debugging.
       _loggerProxy.default.logger.debug("Locus-info:parser#processDeltaEvent --> Locus Debug: ".concat(result));
-      if (lociComparison === DESYNC) {
-        // wait for desync response
-        this.pause();
-      } else if (lociComparison === USE_INCOMING) {
-        // update working copy for future comparisons.
-        // Note: The working copy of parser gets updated in .onFullLocus()
-        // and here when USE_INCOMING locus.
-        this.workingCopy = newLoci;
+      var needToWait = false;
+      switch (lociComparison) {
+        case DESYNC:
+          // wait for desync response
+          this.pause();
+          break;
+        case USE_INCOMING:
+        case LOCUS_URL_CHANGED:
+          // update working copy for future comparisons.
+          // Note: The working copy of parser gets updated in .onFullLocus()
+          // and here when USE_INCOMING or LOCUS_URL_CHANGED locus.
+          this.workingCopy = newLoci;
+          break;
+        case WAIT:
+          // we've taken newLoci from the front of the queue, so put it back there as we have to wait
+          // for the one that should be in front of it, before we can process it
+          this.queue.enqueue(newLoci);
+          needToWait = true;
+          break;
+        default:
+          break;
+      }
+      if (needToWait) {
+        this.status = 'BLOCKED';
+        this.startSyncTimer();
+      } else {
+        this.stopSyncTimer();
+        if (this.status === 'BLOCKED') {
+          // we are not blocked anymore
+          this.status = 'WORKING';
+          _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> received delta that we were waiting for ".concat(Parser.locus2string(newLoci), ", not blocked anymore"));
+        }
       }
       if (this.onDeltaAction) {
-        _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> Locus Delta Action: ".concat(lociComparison));
-
-        // eslint-disable-next-line no-useless-call
-        this.onDeltaAction.call(this, lociComparison, newLoci);
+        _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> Locus Delta ".concat(Parser.locus2string(newLoci), ", Action: ").concat(lociComparison));
+        this.onDeltaAction(lociComparison, newLoci);
       }
       this.nextEvent();
     }
@@ -205,8 +328,7 @@ var Parser = /*#__PURE__*/function () {
     key: "resume",
     value: function resume() {
       _loggerProxy.default.logger.info('Locus-info:parser#resume --> Locus parser resumed.');
-      // @ts-ignore
-      this.status = Parser.status.WORKING;
+      this.status = 'WORKING';
       this.nextEvent();
     }
 
@@ -217,6 +339,24 @@ var Parser = /*#__PURE__*/function () {
      * @returns {object} Debug message
      */
   }], [{
+    key: "locus2string",
+    value: function locus2string(locus) {
+      var _locus$sequence;
+      if (!((_locus$sequence = locus.sequence) !== null && _locus$sequence !== void 0 && _locus$sequence.entries)) {
+        return 'invalid';
+      }
+      return locus.sequence.entries.length ? "seq=".concat(locus.sequence.entries.at(-1)) : 'empty';
+    }
+
+    /**
+     * Checks if two sequences overlap in time,
+     * the sequence with the higher minimum value is greater.
+     * Chooses sequence with most recent data.
+     * @param {Types~Locus} current
+     * @param {Types~Locus} incoming
+     * @returns {string} loci comparison state
+     */
+  }, {
     key: "checkSequenceOverlap",
     value: function checkSequenceOverlap(current, incoming) {
       var comparison = null;
@@ -381,12 +521,14 @@ var Parser = /*#__PURE__*/function () {
   }, {
     key: "compareDelta",
     value: function compareDelta(current, incoming) {
-      var _Parser$loci2 = Parser.loci,
-        LT = _Parser$loci2.LT,
-        GT = _Parser$loci2.GT,
-        EQ = _Parser$loci2.EQ,
-        DESYNC = _Parser$loci2.DESYNC,
-        USE_INCOMING = _Parser$loci2.USE_INCOMING;
+      var _Parser$loci3 = Parser.loci,
+        LT = _Parser$loci3.LT,
+        GT = _Parser$loci3.GT,
+        EQ = _Parser$loci3.EQ,
+        DESYNC = _Parser$loci3.DESYNC,
+        USE_INCOMING = _Parser$loci3.USE_INCOMING,
+        WAIT = _Parser$loci3.WAIT,
+        LOCUS_URL_CHANGED = _Parser$loci3.LOCUS_URL_CHANGED;
       var extract = Parser.extractComparisonState;
       var pack = Parser.packComparisonResult;
       var result = Parser.compareSequence(current.sequence, incoming.sequence);
@@ -394,12 +536,32 @@ var Parser = /*#__PURE__*/function () {
       if (comparison !== LT) {
         return pack(Parser.compareToAction(comparison), result);
       }
+      if (incoming.url !== current.url) {
+        // when moving to/from a breakout session, the locus URL will change and also
+        // the baseSequence, making incoming and current incomparable, so use a
+        // unique comparison state
+        return pack(LOCUS_URL_CHANGED, result);
+      }
       comparison = Parser.compareSequence(current.sequence, incoming.baseSequence);
       switch (extract(comparison)) {
         case GT:
         case EQ:
           comparison = USE_INCOMING;
           break;
+        case LT:
+          if (extract(Parser.compareSequence(incoming.baseSequence, incoming.sequence)) === EQ) {
+            // special case where Locus sends a delta with baseSequence === sequence to trigger a sync,
+            // because the delta event is too large to be sent over mercury connection
+            comparison = DESYNC;
+          } else {
+            // the incoming locus has baseSequence from the future, so it is out-of-order,
+            // we are missing 1 or more locus that should be in front of it, we need to wait for it
+            comparison = WAIT;
+            _metrics.default.sendBehavioralMetric(_constants.default.LOCUS_DELTA_OUT_OF_ORDER, {
+              stack: new Error().stack
+            });
+          }
+          break;
         default:
           comparison = DESYNC;
       }
@@ -407,11 +569,24 @@ var Parser = /*#__PURE__*/function () {
     }
 
     /**
-     * Compares Locus sequences
+     * Compares Locus sequences - it should be called only for full Locus DTOs, not deltas
+     *
      * @param {Types~Locus} current Current working copy
-     * @param {Types~Locus} incoming New Locus delta
-     * @returns {string}
+     * @param {Types~Locus} incomingFullDto New Full Locus DTO
+     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
      */
+  }, {
+    key: "compareFullDtoSequence",
+    value: function compareFullDtoSequence(current, incomingFullDto) {
+      if (Parser.isSequenceEmpty(current) || Parser.isSequenceEmpty(incomingFullDto)) {
+        return Parser.loci.USE_INCOMING;
+      }
+
+      // the sequence.entries list will always contain at least 1 entry
+      // https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Sequence-Comparison-Algorithm
+
+      return incomingFullDto.sequence.entries.slice(-1)[0] > current.sequence.entries.slice(-1)[0] ? Parser.loci.USE_INCOMING : Parser.loci.USE_CURRENT;
+    }
   }, {
     key: "compareSequence",
     value: function compareSequence(current, incoming) {
@@ -452,14 +627,14 @@ var Parser = /*#__PURE__*/function () {
   }, {
     key: "compareToAction",
     value: function compareToAction(result) {
-      var _Parser$loci3 = Parser.loci,
-        DESYNC = _Parser$loci3.DESYNC,
-        EQ = _Parser$loci3.EQ,
-        ERROR = _Parser$loci3.ERROR,
-        GT = _Parser$loci3.GT,
-        LT = _Parser$loci3.LT,
-        USE_CURRENT = _Parser$loci3.USE_CURRENT,
-        USE_INCOMING = _Parser$loci3.USE_INCOMING;
+      var _Parser$loci4 = Parser.loci,
+        DESYNC = _Parser$loci4.DESYNC,
+        EQ = _Parser$loci4.EQ,
+        ERROR = _Parser$loci4.ERROR,
+        GT = _Parser$loci4.GT,
+        LT = _Parser$loci4.LT,
+        USE_CURRENT = _Parser$loci4.USE_CURRENT,
+        USE_INCOMING = _Parser$loci4.USE_INCOMING;
       var action = ERROR;
       switch (result) {
         case EQ:
@@ -541,7 +716,7 @@ var Parser = /*#__PURE__*/function () {
   }, {
     key: "getUniqueSequences",
     value: function getUniqueSequences(baseLoci, otherLoci) {
-      var diff = (0, _difference2.default)(baseLoci.entries, otherLoci.entries);
+      var diff = (0, _lodash.difference)(baseLoci.entries, otherLoci.entries);
       var start = otherLoci.start,
         end = otherLoci.end;
       return Parser.getNumbersOutOfRange(diff, start, end);
@@ -674,12 +849,8 @@ var Parser = /*#__PURE__*/function () {
   }]);
   return Parser;
 }();
-exports.default = Parser;
-(0, _defineProperty2.default)(Parser, "status", {
-  IDLE: 'IDLE',
-  PAUSED: 'PAUSED',
-  WORKING: 'WORKING'
-});
+// received an out-of-order delta, so waiting for the missing one
+// loci comparison states
 (0, _defineProperty2.default)(Parser, "loci", {
   EQ: 'EQUAL',
   GT: 'GREATER_THAN',
@@ -687,6 +858,8 @@ exports.default = Parser;
   DESYNC: 'DESYNC',
   USE_INCOMING: 'USE_INCOMING',
   USE_CURRENT: 'USE_CURRENT',
-  ERROR: 'ERROR'
+  WAIT: 'WAIT',
+  ERROR: 'ERROR',
+  LOCUS_URL_CHANGED: 'LOCUS_URL_CHANGED'
 });
 //# sourceMappingURL=parser.js.map