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

package/src/locus-info/infoUtils.ts

@@ -1,4 +1,4 @@
-import {SELF_ROLES, DISPLAY_HINTS, INTERSTITIAL_DISPLAY_HINTS} from '../constants';
+import {SELF_ROLES, DISPLAY_HINTS} from '../constants';
 
 const InfoUtils: any = {};
 
@@ -9,15 +9,7 @@ InfoUtils.parse = (info, roles, isJoined = true) => {
     coHost: InfoUtils.parseCoHost(info),
   };
 
-  let userDisplayHints = isJoined
-    ? {...parsed.policy}
-    : {
-        ...Object.fromEntries(
-          Object.entries(parsed.policy).filter(([hint]) =>
-            INTERSTITIAL_DISPLAY_HINTS.includes(hint)
-          )
-        ),
-      };
+  let userDisplayHints = isJoined ? {...parsed.policy} : {};
 
   if (roles.includes(SELF_ROLES.COHOST)) {
     userDisplayHints = {...userDisplayHints, ...parsed.coHost};
@@ -37,10 +29,6 @@ InfoUtils.parse = (info, roles, isJoined = true) => {
     parsed.meetingNumber = info.meetingId;
   }
 
-  if (info.datachannelUrl) {
-    parsed.datachannelUrl = info.datachannelUrl;
-  }
-
   return parsed;
 };
 

package/src/locus-info/mediaSharesUtils.ts

@@ -13,10 +13,6 @@ MediaSharesUtils.parse = (mediaShares: object) => {
       content: {
         beneficiaryId: MediaSharesUtils.getContentBeneficiaryId(mediaShares),
         disposition: MediaSharesUtils.getContentDisposition(mediaShares),
-        annotation: MediaSharesUtils.getContentAnnotation(mediaShares),
-        url: MediaSharesUtils.getContentUrl(mediaShares),
-        shareInstanceId: MediaSharesUtils.getShareInstanceId(mediaShares),
-        deviceUrlSharing: MediaSharesUtils.getContentBeneficiaryDeviceUrl(mediaShares),
       },
       whiteboard: {
         beneficiaryId: MediaSharesUtils.getWhiteboardBeneficiaryId(mediaShares),
@@ -144,66 +140,6 @@ MediaSharesUtils.getContentBeneficiaryId = (mediaShares: object) => {
   return contentFloor.beneficiary.id;
 };
 
-/**
- * get live annotation is sharing from media shares (content)
- * @param {Object} mediaShares
- * @returns {Object}
- */
-MediaSharesUtils.getContentAnnotation = (mediaShares: object) => {
-  const extractContent = MediaSharesUtils.extractContent(mediaShares);
-
-  if (!extractContent || !extractContent.annotation) {
-    return undefined;
-  }
-
-  return extractContent.annotation;
-};
-
-/**
- * get url is sharing from media shares (content)
- * @param {Object} mediaShares
- * @returns {Object}
- */
-MediaSharesUtils.getContentUrl = (mediaShares: object) => {
-  const extractContent = MediaSharesUtils.extractContent(mediaShares);
-
-  if (!extractContent || !extractContent.url) {
-    return undefined;
-  }
-
-  return extractContent.url;
-};
-
-/**
- * get shareInstanceId is sharing from media shares (content)
- * @param {Object} mediaShares
- * @returns {Object}
- */
-MediaSharesUtils.getShareInstanceId = (mediaShares: object) => {
-  const extractContent = MediaSharesUtils.extractContent(mediaShares);
-
-  if (!extractContent || !extractContent.floor || !extractContent.floor.shareInstanceId) {
-    return undefined;
-  }
-
-  return extractContent.floor.shareInstanceId;
-};
-
-/**
- * get deviceUrl that is requesting the floor for media shares (content)
- * @param {Object} mediaShares
- * @returns {Object}
- */
-MediaSharesUtils.getContentBeneficiaryDeviceUrl = (mediaShares: object) => {
-  const contentFloor = MediaSharesUtils.extractContentFloor(mediaShares);
-
-  if (!contentFloor || !contentFloor.beneficiary || !contentFloor.beneficiary.deviceUrl) {
-    return null;
-  }
-
-  return contentFloor.beneficiary.deviceUrl;
-};
-
 /**
  * get who is sharing from media shares (whiteboard)
  * @param {Object} mediaShares

package/src/locus-info/parser.ts

@@ -1,30 +1,8 @@
 import {difference} from 'lodash';
 
-import SortedQueue from '../common/queue';
+import SimpleQueue from '../common/queue';
 import LoggerProxy from '../common/logs/logger-proxy';
 
-import Metrics from '../metrics';
-import BEHAVIORAL_METRICS from '../metrics/constants';
-
-const 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
-const OOO_DELTA_WAIT_TIME = 10000; // [ms] minimum wait time before we do a sync if we get out-of-order deltas
-const OOO_DELTA_WAIT_TIME_RANDOM_DELAY = 5000; // [ms] max random delay added to OOO_DELTA_WAIT_TIME
-
-type LocusDeltaDto = {
-  url: string;
-  baseSequence: {
-    rangeStart: number;
-    rangeEnd: number;
-    entries: number[];
-  };
-  sequence: {
-    rangeStart: number;
-    rangeEnd: number;
-    entries: number[];
-  };
-  syncUrl: string;
-};
-
 /**
  * Locus Delta Parser
  * @private
@@ -32,11 +10,11 @@ type LocusDeltaDto = {
  */
 export default class Parser {
   // processing status
-  status:
-    | 'IDLE' // not doing anything
-    | 'PAUSED' // paused, because we are doing a sync
-    | 'WORKING' // processing a delta event
-    | 'BLOCKED'; // received an out-of-order delta, so waiting for the missing one
+  static status = {
+    IDLE: 'IDLE',
+    PAUSED: 'PAUSED',
+    WORKING: 'WORKING',
+  };
 
   // loci comparison states
   static loci = {
@@ -46,60 +24,21 @@ export default class Parser {
     DESYNC: 'DESYNC',
     USE_INCOMING: 'USE_INCOMING',
     USE_CURRENT: 'USE_CURRENT',
-    WAIT: 'WAIT',
     ERROR: 'ERROR',
-    LOCUS_URL_CHANGED: 'LOCUS_URL_CHANGED',
   };
 
-  queue: SortedQueue<LocusDeltaDto>;
+  queue: any;
   workingCopy: any;
-  syncTimer?: ReturnType<typeof setTimeout>;
 
   /**
    * @constructs Parser
    */
   constructor() {
-    const deltaCompareFunc = (left: LocusDeltaDto, right: LocusDeltaDto) => {
-      const {LT, GT} = Parser.loci;
-      const {extractComparisonState: extract} = Parser;
-
-      if (Parser.isSequenceEmpty(left)) {
-        return -1;
-      }
-      if (Parser.isSequenceEmpty(right)) {
-        return 1;
-      }
-      const result = extract(Parser.compareSequence(left.baseSequence, right.baseSequence));
-
-      if (result === LT) {
-        return -1;
-      }
-      if (result === GT) {
-        return 1;
-      }
-
-      return 0;
-    };
-
-    this.queue = new SortedQueue<LocusDeltaDto>(deltaCompareFunc);
-    this.status = 'IDLE';
+    this.queue = new SimpleQueue();
+    // @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}
-   */
-  static locus2string(locus: LocusDeltaDto) {
-    if (!locus.sequence?.entries) {
-      return 'invalid';
-    }
-
-    return locus.sequence.entries.length ? `seq=${locus.sequence.entries.at(-1)}` : 'empty';
   }
 
   /**
@@ -269,7 +208,7 @@ export default class Parser {
    * @returns {string} loci comparison state
    */
   private static compareDelta(current, incoming) {
-    const {LT, GT, EQ, DESYNC, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = Parser.loci;
+    const {LT, GT, EQ, DESYNC, USE_INCOMING} = Parser.loci;
 
     const {extractComparisonState: extract} = Parser;
     const {packComparisonResult: pack} = Parser;
@@ -281,13 +220,6 @@ export default class Parser {
       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)) {
@@ -296,21 +228,6 @@ export default class Parser {
         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.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_DELTA_OUT_OF_ORDER, {
-            stack: new Error().stack,
-          });
-        }
-        break;
       default:
         comparison = DESYNC;
     }
@@ -318,49 +235,6 @@ export default class Parser {
     return pack(comparison, result);
   }
 
-  /**
-   * Compares Locus sequences - it should be called only for full Locus DTOs, not deltas
-   *
-   * @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
-   */
-  static 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;
-  }
-
-  /**
-   * 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
-   */
-  isNewFullLocus(incomingFullDto) {
-    if (!Parser.isLoci(incomingFullDto)) {
-      LoggerProxy.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;
-    }
-
-    const comparisonResult = Parser.compareFullDtoSequence(this.workingCopy, incomingFullDto);
-
-    return comparisonResult === Parser.loci.USE_INCOMING;
-  }
-
   /**
    * Compares Locus sequences
    * @param {Types~Locus} current Current working copy
@@ -519,10 +393,17 @@ export default class Parser {
    */
   isValidLocus(newLoci) {
     let isValid = false;
+    const {IDLE} = Parser.status;
     const {isLoci} = Parser;
+    // @ts-ignore
+    const 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.logger.info(
         'Locus-info:parser#processDeltaEvent --> Ignoring non-locus object. workingCopy:',
         this.workingCopy,
@@ -574,25 +455,19 @@ export default class Parser {
    * @returns {undefined}
    */
   nextEvent() {
-    if (this.status === 'PAUSED') {
+    // @ts-ignore
+    if (this.status === Parser.status.PAUSED) {
       LoggerProxy.logger.info('Locus-info:parser#nextEvent --> Locus parser paused.');
 
       return;
     }
 
-    if (this.status === 'BLOCKED') {
-      LoggerProxy.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;
     }
   }
 
@@ -603,7 +478,7 @@ export default class Parser {
    * @param {Types~Locus} locus Locus delta
    * @returns {undefined}
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  // eslint-disable-next-line no-unused-vars
   onDeltaAction(action: string, locus) {}
 
   /**
@@ -614,20 +489,15 @@ export default class Parser {
   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;
 
-    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();
-      }
+      this.processDeltaEvent();
     }
   }
 
@@ -646,55 +516,11 @@ export default class Parser {
    * @returns {undefined}
    */
   pause() {
-    this.status = 'PAUSED';
+    // @ts-ignore
+    this.status = Parser.status.PAUSED;
     LoggerProxy.logger.info('Locus-info:parser#pause --> Locus parser paused.');
   }
 
-  /**
-   * Triggers a sync with Locus
-   *
-   * @param {string} reason used just for logging
-   * @returns {undefined}
-   */
-  private triggerSync(reason: string) {
-    LoggerProxy.logger.info(`Locus-info:parser#triggerSync --> doing sync, reason: ${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}
-   */
-  private startSyncTimer() {
-    if (this.syncTimer === undefined) {
-      const timeout = OOO_DELTA_WAIT_TIME + Math.random() * OOO_DELTA_WAIT_TIME_RANDOM_DELAY;
-
-      this.syncTimer = setTimeout(() => {
-        this.syncTimer = undefined;
-        this.triggerSync('timer expired, blocked on out-of-order delta');
-      }, timeout);
-    }
-  }
-
-  /**
-   * Stops the timer for triggering a sync
-   *
-   * @returns {undefined}
-   */
-  private stopSyncTimer() {
-    if (this.syncTimer !== undefined) {
-      clearTimeout(this.syncTimer);
-      this.syncTimer = undefined;
-    }
-  }
-
   /**
    * Processes next locus delta in the queue,
    * continues until the queue is empty
@@ -702,13 +528,11 @@ export default class Parser {
    * @returns {undefined}
    */
   processDeltaEvent() {
-    const {DESYNC, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = Parser.loci;
+    const {DESYNC, USE_INCOMING} = Parser.loci;
     const {extractComparisonState: extract} = Parser;
     const newLoci = this.queue.dequeue();
 
     if (!this.isValidLocus(newLoci)) {
-      this.nextEvent();
-
       return;
     }
 
@@ -719,59 +543,23 @@ export default class Parser {
     // for full debugging.
     LoggerProxy.logger.debug(`Locus-info:parser#processDeltaEvent --> Locus Debug: ${result}`);
 
-    let 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.logger.info(
-          `Locus-info:parser#processDeltaEvent --> received delta that we were waiting for ${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.logger.info(
-        `Locus-info:parser#processDeltaEvent --> Locus Delta ${Parser.locus2string(
-          newLoci
-        )}, Action: ${lociComparison}`
+        `Locus-info:parser#processDeltaEvent --> Locus Delta Action: ${lociComparison}`
       );
 
-      this.onDeltaAction(lociComparison, newLoci);
+      // eslint-disable-next-line no-useless-call
+      this.onDeltaAction.call(this, lociComparison, newLoci);
     }
 
     this.nextEvent();
@@ -783,7 +571,8 @@ export default class Parser {
    */
   resume() {
     LoggerProxy.logger.info('Locus-info:parser#resume --> Locus parser resumed.');
-    this.status = 'WORKING';
+    // @ts-ignore
+    this.status = Parser.status.WORKING;
     this.nextEvent();
   }