@webex/plugin-meetings 3.1.0-next.2 → 3.1.0-next.21

package/src/meeting/voicea-meeting.ts

@@ -1,3 +1,5 @@
+import {type MeetingTranscriptPayload} from '@webex/internal-plugin-voicea';
+
 export const getSpeaker = (members, csis = []) =>
   Object.values(members).find((member: any) => {
     const memberCSIs = member.participant.status.csis ?? [];
@@ -31,43 +33,16 @@ export const getSpeakerFromProxyOrStore = ({csisKey, meetingMembers, transcriptD
   return {speaker, needsCaching};
 };
 
-export const processNewCaptions = ({data, meeting}) => {
+export const processNewCaptions = ({
+  data,
+  meeting,
+}: {
+  data: MeetingTranscriptPayload;
+  meeting: any;
+}) => {
   const {transcriptId} = data;
   const transcriptData = meeting.transcription;
 
-  if (data.isFinal) {
-    transcriptData.interimCaptions[transcriptId].forEach((interimId) => {
-      const interimTranscriptIndex = transcriptData.captions.findIndex(
-        (transcript) => transcript.id === interimId
-      );
-
-      if (interimTranscriptIndex !== -1) {
-        transcriptData.captions.splice(interimTranscriptIndex, 1);
-      }
-    });
-    delete transcriptData.interimCaptions[transcriptId];
-    const csisKey = data.transcript?.csis[0];
-
-    const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
-      meetingMembers: meeting.members.membersCollection.members,
-      transcriptData,
-      csisKey,
-    });
-
-    if (needsCaching) {
-      transcriptData.speakerProxy[csisKey] = speaker;
-    }
-    const captionData = {
-      id: transcriptId,
-      isFinal: data.isFinal,
-      translations: data.translations,
-      text: data.transcript?.text,
-      currentSpokenLanguage: data.transcript?.transcript_language_code,
-      timestamp: data.timestamp,
-      speaker,
-    };
-    transcriptData.captions.push(captionData);
-  }
   const {transcripts = []} = data;
   const transcriptsPerCsis = new Map();
 
@@ -80,8 +55,11 @@ export const processNewCaptions = ({data, meeting}) => {
 
     const newCaption = `${transcriptsPerCsis.get(csisMember)?.text ?? ''} ${text}`.trim();
 
-    // eslint-disable-next-line camelcase
-    transcriptsPerCsis.set(csisMember, {text: newCaption, currentSpokenLanguage});
+    transcriptsPerCsis.set(csisMember, {
+      ...transcript,
+      text: newCaption,
+      currentSpokenLanguage,
+    });
   }
   const interimTranscriptionIds = [];
 
@@ -91,31 +69,51 @@ export const processNewCaptions = ({data, meeting}) => {
       transcriptData,
       csisKey: key,
     });
+    const {speakerId} = speaker;
+    const interimId = `${transcriptId}_${speakerId}`;
 
     if (needsCaching) {
       transcriptData.speakerProxy[key] = speaker;
     }
-    const {speakerId} = speaker;
-    const interimId = `${transcriptId}_${speakerId}`;
+
     const captionData = {
       id: interimId,
       isFinal: data.isFinal,
       translations: value.translations,
       text: value.text,
-      currentCaptionLanguage: value.currentSpokenLanguage,
+      currentCaptionLanguage:
+        meeting.transcription?.languageOptions?.currentCaptionLanguage ||
+        value.currentSpokenLanguage,
+      currentSpokenLanguage:
+        meeting.transcription?.languageOptions?.currentSpokenLanguage ||
+        data.transcripts[0]?.transcript_language_code,
       timestamp: value?.timestamp,
       speaker,
     };
 
-    const interimTranscriptIndex = transcriptData.captions.findIndex(
-      (transcript) => transcript.id === interimId
-    );
+    if (!data.isFinal) {
+      const interimTranscriptIndex = transcriptData.captions.findIndex(
+        (transcript) => transcript.id === interimId
+      );
 
-    if (interimTranscriptIndex !== -1) {
-      transcriptData.captions.splice(interimTranscriptIndex, 1);
-    }
+      if (interimTranscriptIndex !== -1) {
+        transcriptData.captions.splice(interimTranscriptIndex, 1);
+      }
 
-    interimTranscriptionIds.push(interimId);
+      interimTranscriptionIds.push(interimId);
+    } else {
+      transcriptData.interimCaptions[transcriptId].forEach((innerInterimId) => {
+        const interimTranscriptIndex = transcriptData.captions.findIndex(
+          (transcript) => transcript.id === innerInterimId
+        );
+
+        if (interimTranscriptIndex !== -1) {
+          transcriptData.captions.splice(interimTranscriptIndex, 1);
+        }
+      });
+      delete transcriptData.interimCaptions[transcriptId];
+      captionData.id = transcriptId;
+    }
     transcriptData.captions.push(captionData);
   }
   transcriptData.interimCaptions[transcriptId] = interimTranscriptionIds;

package/src/meetings/index.ts

@@ -1,5 +1,5 @@
 /* eslint no-shadow: ["error", { "allow": ["eventType"] }] */
-
+import {union} from 'lodash';
 import '@webex/internal-plugin-mercury';
 import '@webex/internal-plugin-conversation';
 import '@webex/internal-plugin-metrics';
@@ -45,6 +45,8 @@ import {
   MEETINGNUMBER,
   _JOINED_,
   _MOVED_,
+  _ON_HOLD_LOBBY_,
+  _WAIT_,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import MeetingInfo from '../meeting-info';
@@ -340,6 +342,9 @@ export default class Meetings extends WebexPlugin {
     if (newLocus) {
       const isNewLocusAsBreakout = MeetingsUtil.isBreakoutLocusDTO(newLocus);
       const isSelfMoved = newLocus?.self?.state === _LEFT_ && newLocus?.self?.reason === _MOVED_;
+      const isSelfMovedToLobby =
+        newLocus?.self?.devices[0]?.intent?.reason === _ON_HOLD_LOBBY_ &&
+        newLocus?.self?.devices[0]?.intent?.type === _WAIT_;
       if (!meeting) {
         if (isNewLocusAsBreakout) {
           LoggerProxy.logger.log(
@@ -352,7 +357,7 @@ export default class Meetings extends WebexPlugin {
         return this.isNeedHandleMainLocus(meeting, newLocus);
       }
       if (!isNewLocusAsBreakout) {
-        return this.isNeedHandleMainLocus(meeting, newLocus);
+        return isSelfMovedToLobby || this.isNeedHandleMainLocus(meeting, newLocus);
       }
 
       return !isSelfMoved;
@@ -996,7 +1001,10 @@ export default class Meetings extends WebexPlugin {
   fetchUserPreferredWebexSite() {
     return this.request.getMeetingPreferences().then((res) => {
       if (res) {
-        this.preferredWebexSite = MeetingsUtil.parseDefaultSiteFromMeetingPreferences(res);
+        const preferredWebexSite = MeetingsUtil.parseDefaultSiteFromMeetingPreferences(res);
+        this.preferredWebexSite = preferredWebexSite;
+        // @ts-ignore
+        this.webex.internal.services._getCatalog().addAllowedDomains([preferredWebexSite]);
       }
 
       // fall back to getting the preferred site from the user information
@@ -1009,6 +1017,8 @@ export default class Meetings extends WebexPlugin {
               user?.userPreferences?.userPreferencesItems?.preferredWebExSite;
             if (preferredWebexSite) {
               this.preferredWebexSite = preferredWebexSite;
+              // @ts-ignore
+              this.webex.internal.services._getCatalog().addAllowedDomains([preferredWebexSite]);
             } else {
               throw new Error('site not found');
             }
@@ -1383,22 +1393,12 @@ export default class Meetings extends WebexPlugin {
 
   /**
    * Get all meetings.
-   * @param {object} options
-   * @param {object} options.startDate - get meetings after this start date
-   * @param {object} options.endDate - get meetings before this end date
    * @returns {Object} All currently active meetings.
    * @public
    * @memberof Meetings
    */
-  public getAllMeetings(
-    options: {
-      startDate: object;
-      endDate: object;
-    } = {} as any
-  ) {
-    // Options may include other parameters to filter this collection
-    // of meetings.
-    return this.meetingCollection.getAll(options);
+  public getAllMeetings() {
+    return this.meetingCollection.getAll();
   }
 
   /**
@@ -1524,18 +1524,6 @@ export default class Meetings extends WebexPlugin {
     this.breakoutLocusForHandleLater.splice(existIndex, 1);
   }
 
-  /**
-   * Get all scheduled meetings.
-   * @param {object} options
-   * @param {object} options.startDate - get meetings after this start date
-   * @param {object} options.endDate - get meetings before this end date
-   * @returns {Object} All scheduled meetings.
-   * @memberof Meetings
-   */
-  getScheduledMeetings() {
-    return this.meetingCollection.getAll({scheduled: true});
-  }
-
   /**
    * Get the logger instance for plugin-meetings
    * @returns {Logger}

package/src/reachability/index.ts

@@ -296,6 +296,63 @@ export default class Reachability {
     return reachable;
   }
 
+  /**
+   * Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none
+   * of the media clusters where reachable with any of the protocols. This is done
+   * irrespective of the config, so for example:
+   * if config.meetings.experimental.enableTlsReachability === false,
+   * it will return false, because TLS reachability won't be tested,
+   * so we can't say for sure that media backend is unreachable over TLS.
+   *
+   * @returns {boolean}
+   */
+  async isWebexMediaBackendUnreachable() {
+    let unreachable = false;
+
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
+
+    if (reachabilityData) {
+      try {
+        const reachabilityResults: ReachabilityResults = JSON.parse(reachabilityData);
+
+        const protocols = {
+          udp: {tested: false, reachable: undefined},
+          tcp: {tested: false, reachable: undefined},
+          xtls: {tested: false, reachable: undefined},
+        };
+
+        Object.values(reachabilityResults).forEach((result) => {
+          Object.keys(protocols).forEach((protocol) => {
+            if (
+              result[protocol]?.result === 'reachable' ||
+              result[protocol]?.result === 'unreachable'
+            ) {
+              protocols[protocol].tested = true;
+
+              // we need at least 1 'reachable' result to mark the whole protocol as reachable
+              if (result[protocol].result === 'reachable') {
+                protocols[protocol].reachable = true;
+              }
+            }
+          });
+        });
+
+        unreachable = Object.values(protocols).every(
+          (protocol) => protocol.tested && !protocol.reachable
+        );
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+        );
+      }
+    }
+
+    return unreachable;
+  }
+
   /**
    * Get list of all unreachable clusters
    * @returns {array} Unreachable clusters
@@ -314,6 +371,9 @@ export default class Reachability {
       if (result.tcp.result === 'unreachable') {
         unreachableList.push({name: key, protocol: 'tcp'});
       }
+      if (result.xtls.result === 'unreachable') {
+        unreachableList.push({name: key, protocol: 'xtls'});
+      }
     });
 
     return unreachableList;

package/src/reconnection-manager/index.ts

@@ -17,11 +17,11 @@ import {
   RECONNECTION_STATE,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
-import ReconnectInProgress from '../common/errors/reconnection-in-progress';
+import ReconnectionError from '../common/errors/reconnection';
+import ReconnectionNotStartedError from '../common/errors/reconnection-not-started';
 import Metrics from '../metrics';
 import Meeting from '../meeting';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
-import ReconnectionError from '../common/errors/reconnection';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -73,7 +73,6 @@ export default class ReconnectionManager {
   rejoinAttempts: any;
   shareStatus: any;
   status: any;
-  tryCount: any;
   webex: any;
   /**
    * @param {Meeting} meeting
@@ -102,13 +101,6 @@ export default class ReconnectionManager {
      * @memberof ReconnectionManager
      */
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
-    /**
-     * @instance
-     * @type {Number}
-     * @private
-     * @memberof ReconnectionManager
-     */
-    this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
     /**
      * @instance
      * @type {Object}
@@ -131,7 +123,7 @@ export default class ReconnectionManager {
 
     // @ts-ignore
     this.maxRejoinAttempts = meeting.config.reconnection.maxRejoinAttempts;
-    this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
+    this.rejoinAttempts = 0;
     // @ts-ignore
     this.autoRejoinEnabled = meeting.config.reconnection.autoRejoin;
 
@@ -217,8 +209,7 @@ export default class ReconnectionManager {
    */
   public reset() {
     this.status = RECONNECTION.STATE.DEFAULT_STATUS;
-    this.tryCount = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
-    this.rejoinAttempts = RECONNECTION.STATE.DEFAULT_TRY_COUNT;
+    this.rejoinAttempts = 0;
   }
 
   /**
@@ -265,43 +256,30 @@ export default class ReconnectionManager {
     return this.status === RECONNECTION.STATE.IN_PROGRESS;
   }
 
-  /**
-   * Sets the reconnection status
-   *
-   * @public
-   * @param {RECONNECTION_STATE} status
-   * @memberof ReconnectionManager
-   * @returns {undefined}
-   */
-  public setStatus(status: RECONNECTION_STATE) {
-    this.status = status;
-  }
-
   /**
    * @returns {Boolean}
-   * @throws {ReconnectionError}
+   * @throws {ReconnectInProgress, ReconnectionDisabled}
    * @private
    * @memberof ReconnectionManager
    */
-  private validate() {
+  private canStartReconnection() {
     if (this.meeting.config.reconnection.enabled) {
-      if (
-        this.status === RECONNECTION.STATE.DEFAULT_STATUS ||
-        this.status === RECONNECTION.STATE.COMPLETE
-      ) {
+      if (this.status === RECONNECTION.STATE.DEFAULT_STATUS) {
         return true;
       }
 
       LoggerProxy.logger.info(
-        'ReconnectionManager:index#validate --> Reconnection already in progress.'
+        'ReconnectionManager:index#canStartReconnection --> Reconnection already in progress.'
       );
 
-      throw new ReconnectInProgress('Reconnection already in progress.');
+      return false;
     }
 
-    LoggerProxy.logger.info('ReconnectionManager:index#validate --> Reconnection is not enabled.');
+    LoggerProxy.logger.info(
+      'ReconnectionManager:index#canStartReconnection --> Reconnection is not enabled.'
+    );
 
-    throw new ReconnectionError('Reconnection is not enabled.');
+    return false;
   }
 
   /**
@@ -309,105 +287,152 @@ export default class ReconnectionManager {
    * @param {Object} reconnectOptions
    * @param {boolean} [reconnectOptions.networkDisconnect=false] indicates if a network disconnect event happened
    * @param {boolean} [reconnectOptions.networkRetry=false] indicates if we are retrying the reconnect
+   * @param {Function} [completionCallback] callback that gets called when reconnection is started successfully
    * @returns {Promise}
    * @public
    * @memberof ReconnectionManager
    */
-  public async reconnect({
-    networkDisconnect = false,
-    networkRetry = false,
-  }: {
-    networkDisconnect?: boolean;
-    networkRetry?: boolean;
-  } = {}) {
+  public async reconnect(
+    {
+      networkDisconnect = false,
+      networkRetry = false,
+    }: {
+      networkDisconnect?: boolean;
+      networkRetry?: boolean;
+    } = {},
+    completionCallback: (() => Promise<void>) | undefined = undefined
+  ) {
     LoggerProxy.logger.info(
       `ReconnectionManager:index#reconnect --> Reconnection start for meeting ${this.meeting.id}.`
     );
-    // First, validate that we can reconnect, if not, it will throw an error
-    try {
-      this.validate();
-    } catch (error) {
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Reconnection unable to begin.',
-        error
-      );
-      throw error;
-    }
 
-    if (!networkRetry) {
-      // Only log START metrics on the initial reconnect
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
+    const triggerEvent = (event, payload = undefined) =>
+      Trigger.trigger(
+        this.meeting,
+        {
+          file: 'reconnection-manager/index',
+          function: 'reconnect',
+        },
+        event,
+        payload
       );
 
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.media.reconnecting',
-        options: {
-          meetingId: this.meeting.id,
-        },
-      });
+    if (!this.canStartReconnection()) {
+      throw new ReconnectionNotStartedError();
     }
 
     try {
-      await this.webex.meetings.startReachability();
-    } catch (err) {
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
-        err
-      );
-    }
+      this.status = RECONNECTION.STATE.IN_PROGRESS;
 
-    try {
-      const media = await this.executeReconnection({networkDisconnect});
+      triggerEvent(EVENT_TRIGGERS.MEETING_RECONNECTION_STARTING);
 
-      return media;
-    } catch (reconnectError) {
-      if (reconnectError instanceof NeedsRetryError) {
+      if (!networkRetry) {
+        // Only log START metrics on the initial reconnect
         LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
         );
-        // Reset our reconnect status since we are looping back to the beginning
-        this.status = RECONNECTION.STATE.DEFAULT_STATUS;
 
-        // This is a network retry, so we should not log START metrics again
-        return this.reconnect({networkDisconnect: true, networkRetry: true});
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.reconnecting',
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
       }
 
-      // Reconnect has failed
-      LoggerProxy.logger.error(
-        'ReconnectionManager:index#reconnect --> Reconnection failed.',
-        reconnectError.message
-      );
-      LoggerProxy.logger.info(
-        'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
-      );
+      try {
+        await this.webex.meetings.startReachability();
+      } catch (err) {
+        LoggerProxy.logger.info(
+          'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
+          err
+        );
+      }
+
+      try {
+        await this.executeReconnection({networkDisconnect});
+      } catch (reconnectError) {
+        if (reconnectError instanceof NeedsRetryError) {
+          LoggerProxy.logger.info(
+            'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
+          );
+          // Reset our reconnect status since we are looping back to the beginning
+          this.status = RECONNECTION.STATE.DEFAULT_STATUS;
+
+          // This is a network retry, so we should not log START metrics again
+          await this.reconnect({networkDisconnect: true, networkRetry: true}, completionCallback);
+
+          return;
+        }
+
+        // Reconnect has failed
+        LoggerProxy.logger.error(
+          'ReconnectionManager:index#reconnect --> Reconnection failed.',
+          reconnectError.message
+        );
+
+        // send call aborted event with category as expected as we are trying to rejoin
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.aborted',
+          payload: {
+            errors: [
+              {
+                category: 'expected',
+                errorCode: 2008,
+                fatal: true,
+                name: 'media-engine',
+                shownToUser: false,
+              },
+            ],
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
+
+        if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
+          await this.rejoinMeeting(reconnectError.wasSharing);
+
+          return;
+        }
+
+        throw reconnectError;
+      }
+
+      // finalize the reconnection process by calling the completionCallback
+      if (completionCallback) {
+        await completionCallback();
+      }
+
+      triggerEvent(EVENT_TRIGGERS.MEETING_RECONNECTION_SUCCESS);
 
-      // send call aborted event with catogery as expected as we are trying to rejoin
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.call.aborted',
+        name: 'client.media.recovered',
         payload: {
-          errors: [
-            {
-              category: 'expected',
-              errorCode: 2008,
-              fatal: true,
-              name: 'media-engine',
-              shownToUser: false,
-            },
-          ],
+          recoveredBy: 'new',
         },
         options: {
           meetingId: this.meeting.id,
         },
       });
+    } catch (error) {
+      triggerEvent(EVENT_TRIGGERS.MEETING_RECONNECTION_FAILURE, {
+        error: new ReconnectionError('Reconnection failure event', error),
+      });
 
-      if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
-        return this.rejoinMeeting(reconnectError.wasSharing);
-      }
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_RECONNECT_FAILURE, {
+        correlation_id: this.meeting.correlationId,
+        locus_id: this.meeting.locusUrl.split('/').pop(),
+        reason: error.message,
+        stack: error.stack,
+      });
 
-      throw reconnectError;
+      throw new ReconnectionError('Reconnection failure event', error);
+    } finally {
+      this.reset();
     }
   }
 
@@ -420,8 +445,6 @@ export default class ReconnectionManager {
    * @memberof ReconnectionManager
    */
   private async executeReconnection({networkDisconnect = false}: {networkDisconnect?: boolean}) {
-    this.status = RECONNECTION.STATE.IN_PROGRESS;
-
     LoggerProxy.logger.info(
       'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.'
     );

package/src/roap/request.ts

@@ -61,7 +61,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
     ipVersion?: IP_VERSION;
     locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
+    const {roapMessage, locusSelfUrl, mediaId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
       LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
@@ -82,14 +82,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
       `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    // @ts-ignore
-    this.webex.internal.newMetrics.submitClientEvent({
-      name: 'client.locus.media.request',
-      options: {
-        meetingId,
-      },
-    });
-
     return locusMediaRequest
       .send({
         type: 'RoapMessage',
@@ -101,13 +93,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
         ipVersion,
       })
       .then((res) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-          },
-        });
         // always it will be the first mediaConnection Object
         const mediaConnections =
           res.body.mediaConnections &&
@@ -131,14 +116,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-            rawError: err,
-          },
-        });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:`, err);
         LoggerProxy.logger.error(
           `Roap:request#sendRoapRequest --> roapMessage that caused error:${JSON.stringify(