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

package/dist/locus-info/parser.js

@@ -10,93 +10,43 @@ 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 _lodash = require("lodash");
+var _difference2 = _interopRequireDefault(require("lodash/difference"));
 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 = exports.default = /*#__PURE__*/function () {
+var Parser = /*#__PURE__*/function () {
+  // processing status
+
+  // loci comparison states
+
   /**
    * @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);
-    (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.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;
     this.onDeltaAction = null;
     this.workingCopy = null;
-    this.syncTimer = undefined;
   }
 
   /**
-   * Returns a debug string representing a locus delta - useful for logging
-   *
-   * @param {LocusDeltaDto} locus Locus delta
-   * @returns {string}
+   * 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
    */
   (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:
     /**
@@ -105,11 +55,19 @@ var Parser = exports.default = /*#__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;
@@ -131,20 +89,18 @@ var Parser = exports.default = /*#__PURE__*/function () {
      * @returns {undefined}
      */
     function nextEvent() {
-      if (this.status === 'PAUSED') {
+      // @ts-ignore
+      if (this.status === Parser.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 {
-        this.status = 'IDLE';
+        // @ts-ignore
+        this.status = Parser.status.IDLE;
       }
     }
 
@@ -155,7 +111,7 @@ var Parser = exports.default = /*#__PURE__*/function () {
      * @param {Types~Locus} locus Locus delta
      * @returns {undefined}
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // eslint-disable-next-line no-unused-vars
   }, {
     key: "onDeltaAction",
     value: function onDeltaAction(action, locus) {}
@@ -170,18 +126,14 @@ var Parser = exports.default = /*#__PURE__*/function () {
     value: function onDeltaEvent(loci) {
       // enqueue the new loci
       this.queue.enqueue(loci);
-      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();
-        }
+      // 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();
       }
     }
 
@@ -199,61 +151,11 @@ var Parser = exports.default = /*#__PURE__*/function () {
      * @returns {undefined}
      */
     function pause() {
-      this.status = 'PAUSED';
+      // @ts-ignore
+      this.status = Parser.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
@@ -263,15 +165,12 @@ var Parser = exports.default = /*#__PURE__*/function () {
   }, {
     key: "processDeltaEvent",
     value: function processDeltaEvent() {
-      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 _Parser$loci = Parser.loci,
+        DESYNC = _Parser$loci.DESYNC,
+        USE_INCOMING = _Parser$loci.USE_INCOMING;
       var extract = Parser.extractComparisonState;
       var newLoci = this.queue.dequeue();
       if (!this.isValidLocus(newLoci)) {
-        this.nextEvent();
         return;
       }
       var result = Parser.compare(this.workingCopy, newLoci);
@@ -280,42 +179,20 @@ var Parser = exports.default = /*#__PURE__*/function () {
       // limited debugging, use chrome extension
       // for full debugging.
       _loggerProxy.default.logger.debug("Locus-info:parser#processDeltaEvent --> Locus Debug: ".concat(result));
-      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 (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;
       }
       if (this.onDeltaAction) {
-        _loggerProxy.default.logger.info("Locus-info:parser#processDeltaEvent --> Locus Delta ".concat(Parser.locus2string(newLoci), ", Action: ").concat(lociComparison));
-        this.onDeltaAction(lociComparison, newLoci);
+        _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);
       }
       this.nextEvent();
     }
@@ -328,7 +205,8 @@ var Parser = exports.default = /*#__PURE__*/function () {
     key: "resume",
     value: function resume() {
       _loggerProxy.default.logger.info('Locus-info:parser#resume --> Locus parser resumed.');
-      this.status = 'WORKING';
+      // @ts-ignore
+      this.status = Parser.status.WORKING;
       this.nextEvent();
     }
 
@@ -339,24 +217,6 @@ var Parser = exports.default = /*#__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;
@@ -521,14 +381,12 @@ var Parser = exports.default = /*#__PURE__*/function () {
   }, {
     key: "compareDelta",
     value: function compareDelta(current, 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 _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 extract = Parser.extractComparisonState;
       var pack = Parser.packComparisonResult;
       var result = Parser.compareSequence(current.sequence, incoming.sequence);
@@ -536,32 +394,12 @@ var Parser = exports.default = /*#__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;
       }
@@ -569,24 +407,11 @@ var Parser = exports.default = /*#__PURE__*/function () {
     }
 
     /**
-     * Compares Locus sequences - it should be called only for full Locus DTOs, not deltas
-     *
+     * Compares Locus sequences
      * @param {Types~Locus} current Current working copy
-     * @param {Types~Locus} incomingFullDto New Full Locus DTO
-     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
+     * @param {Types~Locus} incoming New Locus delta
+     * @returns {string}
      */
-  }, {
-    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) {
@@ -627,14 +452,14 @@ var Parser = exports.default = /*#__PURE__*/function () {
   }, {
     key: "compareToAction",
     value: function compareToAction(result) {
-      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 _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 action = ERROR;
       switch (result) {
         case EQ:
@@ -716,7 +541,7 @@ var Parser = exports.default = /*#__PURE__*/function () {
   }, {
     key: "getUniqueSequences",
     value: function getUniqueSequences(baseLoci, otherLoci) {
-      var diff = (0, _lodash.difference)(baseLoci.entries, otherLoci.entries);
+      var diff = (0, _difference2.default)(baseLoci.entries, otherLoci.entries);
       var start = otherLoci.start,
         end = otherLoci.end;
       return Parser.getNumbersOutOfRange(diff, start, end);
@@ -849,8 +674,12 @@ var Parser = exports.default = /*#__PURE__*/function () {
   }]);
   return Parser;
 }();
-// received an out-of-order delta, so waiting for the missing one
-// loci comparison states
+exports.default = Parser;
+(0, _defineProperty2.default)(Parser, "status", {
+  IDLE: 'IDLE',
+  PAUSED: 'PAUSED',
+  WORKING: 'WORKING'
+});
 (0, _defineProperty2.default)(Parser, "loci", {
   EQ: 'EQUAL',
   GT: 'GREATER_THAN',
@@ -858,8 +687,6 @@ var Parser = exports.default = /*#__PURE__*/function () {
   DESYNC: 'DESYNC',
   USE_INCOMING: 'USE_INCOMING',
   USE_CURRENT: 'USE_CURRENT',
-  WAIT: 'WAIT',
-  ERROR: 'ERROR',
-  LOCUS_URL_CHANGED: 'LOCUS_URL_CHANGED'
+  ERROR: 'ERROR'
 });
 //# sourceMappingURL=parser.js.map