@webex/plugin-meetings 3.7.0-next.57 → 3.7.0-next.59

package/src/meeting/brbState.ts

@@ -0,0 +1,169 @@
+import {MediaType} from '@webex/internal-media-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import type Meeting from '.';
+import SendSlotManager from '../multistream/sendSlotManager';
+
+export const createBrbState = (meeting: Meeting, enabled: boolean) => {
+  LoggerProxy.logger.info(
+    `Meeting:brbState#createBrbState: creating BrbState for meeting id ${meeting?.id}`
+  );
+
+  const brbState = new BrbState(meeting, enabled);
+
+  return brbState;
+};
+
+/** The purpose of this class is to manage the local and remote brb state
+ * and make sure that the server state always matches the last requested state by the client.
+ */
+export class BrbState {
+  state: {
+    client: {
+      enabled: boolean;
+    };
+    server: {
+      enabled: boolean;
+    };
+    syncToServerInProgress: boolean;
+  };
+
+  meeting: Meeting;
+
+  /**
+   * Constructor
+   *
+   * @param {Meeting} meeting - the meeting object
+   * @param {boolean} enabled - whether the client audio/video is enabled at all
+   */
+  constructor(meeting: Meeting, enabled: boolean) {
+    this.meeting = meeting;
+    this.state = {
+      client: {
+        enabled,
+      },
+      server: {
+        enabled: false,
+      },
+      syncToServerInProgress: false,
+    };
+  }
+
+  /**
+   * Enables/disables brb
+   *
+   * @param {boolean} enabled
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  public enable(enabled: boolean, sendSlotManager: SendSlotManager) {
+    this.state.client.enabled = enabled;
+
+    return this.applyClientStateToServer(sendSlotManager);
+  }
+
+  /**
+   * Updates the server local and remote brb values so that they match the current client desired state.
+   *
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  private applyClientStateToServer(sendSlotManager: SendSlotManager) {
+    if (this.state.syncToServerInProgress) {
+      LoggerProxy.logger.info(
+        `Meeting:brbState#applyClientStateToServer: request to server in progress, we need to wait for it to complete`
+      );
+
+      return Promise.resolve();
+    }
+
+    const remoteBrbRequiresSync = this.state.client.enabled !== this.state.server.enabled;
+
+    LoggerProxy.logger.info(
+      `Meeting:brbState#applyClientStateToServer: remoteBrbRequiresSync: ${remoteBrbRequiresSync}`
+    );
+
+    if (!remoteBrbRequiresSync) {
+      LoggerProxy.logger.info(
+        `Meeting:brbState#applyClientStateToServer: client state already matching server state, nothing to do`
+      );
+
+      return Promise.resolve();
+    }
+
+    this.state.syncToServerInProgress = true;
+
+    return this.sendLocalBrbStateToServer(sendSlotManager)
+      .then(() => {
+        this.state.syncToServerInProgress = false;
+        LoggerProxy.logger.info(
+          `Meeting:brbState#applyClientStateToServer: sync with server completed`
+        );
+
+        // need to check if a new sync is required, because this.state.client may have changed while we were doing the current sync
+        this.applyClientStateToServer(sendSlotManager);
+      })
+      .catch((e) => {
+        this.state.syncToServerInProgress = false;
+        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: error: ${e}`);
+      });
+  }
+
+  /**
+   * Send the local brb state to the server
+   *
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  private async sendLocalBrbStateToServer(sendSlotManager: SendSlotManager) {
+    const {enabled} = this.state.client;
+
+    if (!this.meeting.isMultistream) {
+      const errorMessage = 'Meeting:brbState#sendLocalBrbStateToServer: Not a multistream meeting';
+      const error = new Error(errorMessage);
+
+      LoggerProxy.logger.error(error);
+
+      return Promise.reject(error);
+    }
+
+    if (!this.meeting.mediaProperties.webrtcMediaConnection) {
+      const errorMessage =
+        'Meeting:brbState#sendLocalBrbStateToServer: WebRTC media connection is not defined';
+      const error = new Error(errorMessage);
+
+      LoggerProxy.logger.error(error);
+
+      return Promise.reject(error);
+    }
+
+    // this logic should be applied only to multistream meetings
+    return this.meeting.meetingRequest
+      .setBrb({
+        enabled,
+        locusUrl: this.meeting.locusUrl,
+        deviceUrl: this.meeting.deviceUrl,
+        selfId: this.meeting.selfId,
+      })
+      .then(() => {
+        sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:brbState#sendLocalBrbStateToServer: Error ', error);
+
+        return Promise.reject(error);
+      });
+  }
+
+  /**
+   * This method should be called whenever the server brb state is changed
+   *
+   * @param {Boolean} [enabled] true if user has brb enabled, false otherwise
+   * @returns {undefined}
+   */
+  public handleServerBrbUpdate(enabled?: boolean) {
+    LoggerProxy.logger.info(
+      `Meeting:brbState#handleServerBrbUpdate: updating server brb to (${enabled})`
+    );
+    this.state.server.enabled = !!enabled;
+  }
+}

package/src/meeting/index.ts

@@ -163,6 +163,7 @@ import {LocusMediaRequest} from './locusMediaRequest';
 import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
 import JoinWebinarError from '../common/errors/join-webinar-error';
 import Member from '../member';
+import {BrbState, createBrbState} from './brbState';
 import MultistreamNotSupportedError from '../common/errors/multistream-not-supported-error';
 import JoinForbiddenError from '../common/errors/join-forbidden-error';
 
@@ -649,6 +650,7 @@ export default class Meeting extends StatelessWebexPlugin {
   turnServerUsed: boolean;
   areVoiceaEventsSetup = false;
   isMoveToInProgress = false;
+  brbState: BrbState;
 
   voiceaListenerCallbacks: object = {
     [VOICEAEVENTS.VOICEA_ANNOUNCEMENT]: (payload: Transcription['languageOptions']) => {
@@ -3407,6 +3409,7 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED, (payload) => {
+      this.brbState?.handleServerBrbUpdate(payload?.brb?.enabled);
       Trigger.trigger(
         this,
         {
@@ -3650,22 +3653,7 @@ export default class Meeting extends StatelessWebexPlugin {
       return Promise.reject(error);
     }
 
-    // this logic should be applied only to multistream meetings
-    return this.meetingRequest
-      .setBrb({
-        enabled,
-        locusUrl: this.locusUrl,
-        deviceUrl: this.deviceUrl,
-        selfId: this.selfId,
-      })
-      .then(() => {
-        this.sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
-      })
-      .catch((error) => {
-        LoggerProxy.logger.error('Meeting:index#beRightBack --> Error ', error);
-
-        return Promise.reject(error);
-      });
+    return this.brbState.enable(enabled, this.sendSlotManager);
   }
 
   /**
@@ -6719,6 +6707,9 @@ export default class Meeting extends StatelessWebexPlugin {
         new RtcMetrics(this.webex, {meetingId: this.id}, this.correlationId)
       : undefined;
 
+    // ongoing reachability checks slow down new media connections especially on Firefox, so we stop them
+    this.getWebexObject().meetings.reachability.stopReachability();
+
     const mc = Media.createMediaConnection(
       this.isMultistream,
       this.getMediaConnectionDebugId(),
@@ -7435,6 +7426,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.audio = createMuteState(AUDIO, this, audioEnabled);
     this.video = createMuteState(VIDEO, this, videoEnabled);
+    this.brbState = createBrbState(this, false);
 
     try {
       await this.setUpLocalStreamReferences(localStreams);

package/src/reachability/index.ts

@@ -259,6 +259,32 @@ export default class Reachability extends EventsScope {
     }
   }
 
+  /**
+   * Stops all reachability checks that are in progress
+   * @public
+   * @memberof Reachability
+   * @returns {void}
+   */
+  public stopReachability() {
+    // overallTimer is always there only if there is reachability in progress
+    if (this.overallTimer) {
+      LoggerProxy.logger.log(
+        'Reachability:index#stopReachability --> stopping reachability checks'
+      );
+      this.abortCurrentChecks();
+      this.emit(
+        {
+          file: 'reachability',
+          function: 'stopReachability',
+        },
+        'reachability:stopped',
+        {}
+      );
+      this.sendMetric(true);
+      this.resolveReachabilityPromise();
+    }
+  }
+
   /**
    * Returns statistics about last reachability results. The returned value is an object
    * with a flat list of properties so that it can be easily sent with metrics
@@ -637,9 +663,10 @@ export default class Reachability extends EventsScope {
   /**
    * Sends a metric with all the statistics about how long reachability took
    *
+   * @param {boolean} aborted true if the reachability checks were aborted
    * @returns {void}
    */
-  protected async sendMetric() {
+  protected async sendMetric(aborted = false) {
     const results = [];
 
     Object.values(this.clusterReachability).forEach((clusterReachability) => {
@@ -650,6 +677,7 @@ export default class Reachability extends EventsScope {
     });
 
     const stats = {
+      aborted,
       vmn: {
         udp: this.getStatistics(results, 'udp', true),
       },

package/test/unit/spec/meeting/brbState.ts

@@ -0,0 +1,114 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+
+import testUtils from '../../../utils/testUtils';
+import {BrbState, createBrbState} from '@webex/plugin-meetings/src/meeting/brbState';
+
+describe('plugin-meetings', () => {
+  let meeting: any;
+  let brbState: BrbState;
+
+  beforeEach(async () => {
+    meeting = {
+      isMultistream: true,
+      locusUrl: 'locus url',
+      deviceUrl: 'device url',
+      selfId: 'self id',
+      mediaProperties: {
+        webrtcMediaConnection: true,
+      },
+      sendSlotManager: {
+        setSourceStateOverride: sinon.stub(),
+      },
+      meetingRequest: {
+        setBrb: sinon.stub().resolves(),
+      },
+    };
+
+    brbState = new BrbState(meeting, false);
+    await testUtils.flushPromises();
+  });
+
+  describe('brbState library', () => {
+    it('takes into account current status when instantiated', async () => {
+      // create a new BrbState instance
+      brbState = createBrbState(meeting, true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+
+      // now check the opposite case
+      brbState = createBrbState(meeting, false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+    });
+
+    it('can be enabled', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+      assert.isTrue(brbState.state.server.enabled);
+    });
+
+    it('can be disabled', async () => {
+      brbState.enable(false, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+      assert.isFalse(brbState.state.server.enabled);
+    });
+
+    it('does not send local brb state to server if it is not a multistream meeting', async () => {
+      meeting.isMultistream = false;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send local brb state to server if webrtc media connection is not defined', async () => {
+      meeting.mediaProperties.webrtcMediaConnection = undefined;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send request twice when in progress', async () => {
+      brbState.state.syncToServerInProgress = true;
+      brbState.enable(true, meeting.sendSlotManager);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('syncs with server when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.calledOnce);
+    });
+
+    it('sets source state override when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.sendSlotManager.setSourceStateOverride.calledOnce);
+    });
+
+    it('handles server update', async () => {
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.server.enabled);
+    });
+  });
+});

package/test/unit/spec/meeting/index.js

@@ -114,6 +114,7 @@ import {ERROR_DESCRIPTIONS} from '@webex/internal-plugin-metrics/src/call-diagno
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 
 import {EVENT_TRIGGERS as VOICEAEVENTS} from '@webex/internal-plugin-voicea';
+import { createBrbState } from '@webex/plugin-meetings/src/meeting/brbState';
 import JoinForbiddenError               from '../../../../src/common/errors/join-forbidden-error';
 
 describe('plugin-meetings', () => {
@@ -246,6 +247,7 @@ describe('plugin-meetings', () => {
       isAnyPublicClusterReachable: sinon.stub().resolves(true),
       getReachabilityResults: sinon.stub().resolves(undefined),
       getReachabilityMetrics: sinon.stub().resolves({}),
+      stopReachability: sinon.stub(),
     };
     webex.internal.llm.on = sinon.stub();
     webex.internal.newMetrics.callDiagnosticLatencies = new CallDiagnosticLatencies(
@@ -2095,6 +2097,7 @@ describe('plugin-meetings', () => {
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
             }),
+            stopReachability: sinon.stub(),
           };
 
           const forceRtcMetricsSend = sinon.stub().resolves();
@@ -2514,6 +2517,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.setMercuryListener);
           assert.calledOnce(fakeMediaConnection.initiateOffer);
           assert.equal(meeting.allowMediaInLobby, allowMediaInLobby);
+          assert.calledOnce(webex.meetings.reachability.stopReachability);
         };
 
         it('should attach the media and return promise', async () => {
@@ -2709,6 +2713,7 @@ describe('plugin-meetings', () => {
           webex.meetings.reachability = {
             isWebexMediaBackendUnreachable: sinon.stub().resolves(false),
             getReachabilityMetrics: sinon.stub().resolves(),
+            stopReachability: sinon.stub(),
           };
           const MOCK_CLIENT_ERROR_CODE = 2004;
           const generateClientErrorCodeForIceFailureStub = sinon
@@ -2917,6 +2922,7 @@ describe('plugin-meetings', () => {
               .onCall(2)
               .resolves(false),
             getReachabilityMetrics: sinon.stub().resolves({}),
+            stopReachability: sinon.stub(),
           };
           const getErrorPayloadForClientErrorCodeStub =
             (webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
@@ -3211,6 +3217,7 @@ describe('plugin-meetings', () => {
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
             }),
+            stopReachability: sinon.stub(),
           };
           meeting.iceCandidatesCount = 3;
           meeting.iceCandidateErrors.set('701_error', 3);
@@ -3715,6 +3722,7 @@ describe('plugin-meetings', () => {
 
               webex.meetings.reachability = {
                 isWebexMediaBackendUnreachable: sinon.stub().resolves(unreachable || false),
+                stopReachability: sinon.stub(),
               };
 
               const generateClientErrorCodeForIceFailureStub = sinon
@@ -3812,7 +3820,6 @@ describe('plugin-meetings', () => {
         };
 
         beforeEach(() => {
-          meeting.meetingRequest.setBrb = sinon.stub().resolves({body: 'test'});
           meeting.mediaProperties.webrtcMediaConnection = {createSendSlot: sinon.stub()};
           meeting.sendSlotManager.createSlot(
             fakeMultistreamRoapMediaConnection,
@@ -3822,6 +3829,8 @@ describe('plugin-meetings', () => {
           meeting.locusUrl = 'locus url';
           meeting.deviceUrl = 'device url';
           meeting.selfId = 'self id';
+          meeting.brbState = createBrbState(meeting, false);
+          meeting.brbState.enable = sinon.stub().resolves();
         });
 
         afterEach(() => {
@@ -3843,7 +3852,7 @@ describe('plugin-meetings', () => {
 
             await brbResult;
             assert.exists(brbResult.then);
-            assert.calledOnce(meeting.meetingRequest.setBrb);
+            assert.calledOnce(meeting.brbState.enable);
           })
 
           it('should disable #beRightBack and return a promise', async () => {
@@ -3851,12 +3860,12 @@ describe('plugin-meetings', () => {
 
             await brbResult;
             assert.exists(brbResult.then);
-            assert.calledOnce(meeting.meetingRequest.setBrb);
+            assert.calledOnce(meeting.brbState.enable);
           })
 
           it('should throw an error and reject the promise if setBrb fails', async () => {
             const error = new Error('setBrb failed');
-            meeting.meetingRequest.setBrb.rejects(error);
+            meeting.brbState.enable.rejects(error);
 
             try {
               await meeting.beRightBack(true);
@@ -3867,27 +3876,6 @@ describe('plugin-meetings', () => {
             }
           })
         });
-
-        describe('when in a transcoded meeting', () => {
-
-          beforeEach(() => {
-            meeting.isMultistream = false;
-          });
-
-          it('should ignore enabling #beRightBack', async () => {
-            meeting.beRightBack(true);
-
-            assert.isRejected((Promise.reject()));
-            assert.notCalled(meeting.meetingRequest.setBrb);
-          })
-
-          it('should ignore disabling #beRightBack', async () => {
-            meeting.beRightBack(false);
-
-            assert.isRejected((Promise.reject()));
-            assert.notCalled(meeting.meetingRequest.setBrb);
-          })
-        });
       });
 
       /* This set of tests are like semi-integration tests, they use real MuteState, Media, LocusMediaRequest and Roap classes.
@@ -9230,6 +9218,7 @@ describe('plugin-meetings', () => {
 
         it('listens to the brb state changed event', () => {
           const assertBrb = (enabled) => {
+            meeting.brbState = createBrbState(meeting, false);
             meeting.locusInfo.emit(
               { function: 'test', file: 'test' },
               LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,