@webex/plugin-meetings 3.0.0-beta.111 → 3.0.0-beta.113

package/src/roap/request.ts

@@ -3,9 +3,10 @@
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {MEDIA, HTTP_VERBS, REACHABILITY} from '../constants';
+import {REACHABILITY} from '../constants';
 import Metrics from '../metrics';
 import {eventType} from '../metrics/config';
+import {LocusMediaRequest} from '../meeting/locusMediaRequest';
 
 /**
  * @class RoapRequest
@@ -64,69 +65,48 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.locusSelfUrl
    * @param {String} options.mediaId
    * @param {String} options.correlationId
-   * @param {Boolean} options.audioMuted
-   * @param {Boolean} options.videoMuted
    * @param {String} options.meetingId
-   * @param {Boolean} options.preferTranscoding
    * @returns {Promise} returns the response/failure of the request
    */
   async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    correlationId: string;
-    audioMuted: boolean;
-    videoMuted: boolean;
     meetingId: string;
-    preferTranscoding?: boolean;
+    locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
+    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
     }
 
+    if (!locusMediaRequest) {
+      LoggerProxy.logger.warn(
+        'Roap:request#sendRoap --> locusMediaRequest unavailable, not sending roap'
+      );
+
+      return Promise.reject(new Error('sendRoap called when locusMediaRequest is undefined'));
+    }
     const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
       roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
     });
 
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    // @ts-ignore
-    const deviceUrl = this.webex.internal.device.url;
-
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
     Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
-    // @ts-ignore
-    return this.request({
-      uri: mediaUrl,
-      method: HTTP_VERBS.PUT,
-      body: {
-        device: {
-          url: deviceUrl,
-          // @ts-ignore
-          deviceType: this.config.meetings.deviceType,
-        },
-        correlationId,
-        localMedias: [
-          {
-            localSdp: JSON.stringify(localSdpWithReachabilityData),
-            mediaId: options.mediaId,
-          },
-        ],
-        clientMediaPreferences: {
-          preferTranscoding: options.preferTranscoding ?? true,
-          joinCookie,
-        },
-      },
-    })
+    return locusMediaRequest
+      .send({
+        type: 'RoapMessage',
+        selfUrl: locusSelfUrl,
+        joinCookie,
+        mediaId,
+        roapMessage,
+        reachability: localSdpWithReachabilityData.reachability,
+      })
       .then((res) => {
         Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
 

package/src/roap/turnDiscovery.ts

@@ -176,15 +176,12 @@ export default class TurnDiscovery {
     return this.roapRequest
       .sendRoap({
         roapMessage,
-        correlationId: meeting.correlationId,
         // @ts-ignore - Fix missing type
         locusSelfUrl: meeting.selfUrl,
         // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
-        audioMuted: meeting.audio?.isLocallyMuted(),
-        videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
       })
       .then(({mediaConnections}) => {
         if (mediaConnections) {
@@ -213,11 +210,8 @@ export default class TurnDiscovery {
       locusSelfUrl: meeting.selfUrl,
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId,
-      audioMuted: meeting.audio?.isLocallyMuted(),
-      videoMuted: meeting.video?.isLocallyMuted(),
       meetingId: meeting.id,
-      preferTranscoding: !meeting.isMultistream,
+      locusMediaRequest: meeting.locusMediaRequest,
     });
   }
 

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

@@ -0,0 +1,414 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import { cloneDeep, defer } from 'lodash';
+
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import { LocalMuteRequest, LocusMediaRequest, RoapRequest } from "@webex/plugin-meetings/src/meeting/locusMediaRequest";
+import testUtils from '../../../utils/testUtils';
+import { Defer } from '@webex/common';
+
+describe('LocusMediaRequest.send()', () => {
+  let locusMediaRequest: LocusMediaRequest;
+  let webexRequestStub;
+  let mockWebex;
+
+  const fakeLocusResponse = {
+    locus: { something: 'whatever'}
+  };
+
+  const exampleRoapRequestBody:RoapRequest = {
+    type: 'RoapMessage',
+    mediaId: 'mediaId',
+    selfUrl: 'fakeMeetingSelfUrl',
+    roapMessage: {
+      messageType: 'OFFER',
+      sdps: ['sdp'],
+      version: '2',
+      seq: 1,
+      tieBreaker: 0xfffffffe,
+    },
+    reachability: {
+      'wjfkm.wjfkm.*': {udp:{reachable: true}, tcp:{reachable:false}},
+      '1eb65fdf-9643-417f-9974-ad72cae0e10f.59268c12-7a04-4b23-a1a1-4c74be03019a.*': {udp:{reachable: false}, tcp:{reachable:true}},
+    },
+    joinCookie: {
+      anycastEntryPoint: 'aws-eu-west-1',
+      clientIpAddress: 'some ip',
+      timeShot: '2023-05-23T08:03:49Z',
+    },
+  };
+
+  const createExpectedRoapBody = (expectedMessageType, expectedMute:{audioMuted: boolean, videoMuted: boolean}) => {
+    return {
+      device: { url: 'deviceUrl', deviceType: 'deviceType' },
+      correlationId: 'correlationId',
+      localMedias: [
+        {
+          localSdp: `{"audioMuted":${expectedMute.audioMuted},"videoMuted":${expectedMute.videoMuted},"roapMessage":{"messageType":"${expectedMessageType}","sdps":["sdp"],"version":"2","seq":1,"tieBreaker":4294967294},"reachability":{"wjfkm.wjfkm.*":{"udp":{"reachable":true},"tcp":{"reachable":false}},"1eb65fdf-9643-417f-9974-ad72cae0e10f.59268c12-7a04-4b23-a1a1-4c74be03019a.*":{"udp":{"reachable":false},"tcp":{"reachable":true}}}}`,
+          mediaId: 'mediaId'
+        }
+      ],
+      clientMediaPreferences: {
+        preferTranscoding: true,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+          clientIpAddress: 'some ip',
+          timeShot: '2023-05-23T08:03:49Z'
+        }
+      }
+    };
+  };
+
+  const exampleLocalMuteRequestBody:LocalMuteRequest = {
+    type: 'LocalMute',
+    mediaId: 'mediaId',
+    selfUrl: 'fakeMeetingSelfUrl',
+    muteOptions: {},
+  };
+
+  const createExpectedLocalMuteBody = (expectedMute:{audioMuted: boolean, videoMuted: boolean}) => {
+    return {
+      device: {
+        url: 'deviceUrl',
+        deviceType: 'deviceType',
+      },
+      correlationId: 'correlationId',
+      usingResource: null,
+      respOnlySdp: true,
+      localMedias: [
+        {
+          mediaId: 'mediaId',
+          localSdp: `{"audioMuted":${expectedMute.audioMuted},"videoMuted":${expectedMute.videoMuted}}`,
+        },
+      ],
+      clientMediaPreferences: {
+        preferTranscoding: true,
+      },
+    }
+  };
+
+  beforeEach(() => {
+    mockWebex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    locusMediaRequest = new LocusMediaRequest({
+      device: {
+        url: 'deviceUrl',
+        deviceType: 'deviceType',
+      },
+      correlationId: 'correlationId',
+      preferTranscoding: true,
+    }, {
+      parent: mockWebex,
+    });
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request').resolves(fakeLocusResponse);
+  })
+
+  const sendLocalMute = (muteOptions) => locusMediaRequest.send({...exampleLocalMuteRequestBody, muteOptions});
+
+  const sendRoapMessage = (messageType) => {
+    const request = cloneDeep(exampleRoapRequestBody);
+
+    request.roapMessage.messageType = messageType;
+    return locusMediaRequest.send(request);
+  }
+
+  /** Helper function that makes sure the LocusMediaRequest.confluenceState is 'created' */
+  const ensureConfluenceCreated = async () => {
+    await sendRoapMessage('OFFER');
+
+    webexRequestStub.resetHistory();
+  }
+
+  it('sends a roap message', async () => {
+    const result = await sendRoapMessage('OFFER');
+
+    assert.equal(result, fakeLocusResponse);
+
+    assert.calledOnceWithExactly(webexRequestStub, {
+      method: 'PUT',
+      uri: 'fakeMeetingSelfUrl/media',
+      body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
+    });
+  });
+
+  it('sends a local mute request', async () => {
+    await ensureConfluenceCreated();
+
+    const result = await sendLocalMute({audioMuted: false, videoMuted: false});
+
+    assert.equal(result, fakeLocusResponse);
+
+    assert.calledOnceWithExactly(webexRequestStub, {
+      method: 'PUT',
+      uri: 'fakeMeetingSelfUrl/media',
+      body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: false}),
+    });
+  });
+
+  it('sends a local mute request with the last audio/video mute values when called multiple times in same processing cycle', async () => {
+    await ensureConfluenceCreated();
+
+    let result1;
+    let result2;
+
+    const promise1 = sendLocalMute({audioMuted: true, videoMuted: false})
+      .then((result) => {
+        result1 = result;
+      });
+
+    const promise2 = sendLocalMute({audioMuted: false, videoMuted: true})
+      .then((result) => {
+        result2 = result;
+      });
+
+    await testUtils.flushPromises();
+
+    await promise1;
+    await promise2;
+    assert.equal(result1, fakeLocusResponse);
+    assert.equal(result2, fakeLocusResponse);
+
+    assert.calledOnceWithExactly(webexRequestStub, {
+      method: 'PUT',
+      uri: 'fakeMeetingSelfUrl/media',
+      body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
+    });
+
+  });
+
+  it('sends a local mute request with the last audio/video mute values', async () => {
+    await ensureConfluenceCreated();
+
+    await Promise.all([
+      sendLocalMute({audioMuted: undefined, videoMuted: false}),
+      sendLocalMute({audioMuted: true, videoMuted: undefined}),
+      sendLocalMute({audioMuted: false, videoMuted: true}),
+      sendLocalMute({audioMuted: true, videoMuted: false}),
+    ]);
+
+    assert.calledOnceWithExactly(webexRequestStub, {
+      method: 'PUT',
+      uri: 'fakeMeetingSelfUrl/media',
+      body: createExpectedLocalMuteBody({audioMuted: true, videoMuted: false}),
+    });
+
+  });
+
+  it('sends only roap when roap and local mute are requested', async () => {
+    await Promise.all([
+      sendLocalMute({audioMuted: false, videoMuted: undefined}),
+      sendRoapMessage('OFFER'),
+      sendLocalMute({audioMuted: true, videoMuted: false}),
+    ]);
+
+    /* check that only the roap message was sent and it had the last
+       values for audio and video mute
+    */
+    assert.calledOnceWithExactly(webexRequestStub, {
+      method: 'PUT',
+      uri: 'fakeMeetingSelfUrl/media',
+      body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: false}),
+    });
+  });
+
+  describe('queueing', () => {
+    let clock;
+    let requestsToLocus;
+    let results;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+      requestsToLocus = [];
+      results = [];
+
+      // setup the mock so that each new request that we send to Locus,
+      // returns a promise that we control from this test
+      webexRequestStub.callsFake(() => {
+        const defer = new Defer();
+        requestsToLocus.push(defer);
+        return defer.promise;
+      });
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
+    /** LocusMediaRequest.send() uses Lodash.defer(), so it only starts sending any requests
+     * after the processing cycle from which it was called is finished.
+     * This helper function waits for this to happen - it's needed, because we're using
+     * fake timers in these tests
+    */
+    const ensureQueueProcessingIsStarted = () => {
+      clock.tick(1);
+    }
+    it('queues requests if there is one already in progress', async () => {
+      results.push(sendRoapMessage('OFFER'));
+
+      ensureQueueProcessingIsStarted();
+
+      // check that OFFER has been sent out
+      assert.calledWith(webexRequestStub, {
+        method: 'PUT',
+        uri: 'fakeMeetingSelfUrl/media',
+        body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
+      });
+
+      webexRequestStub.resetHistory();
+
+      // at this point the request should be sent out and "in progress",
+      // so any further calls should be queued
+      results.push(sendRoapMessage('OK'));
+
+      // OK should not be sent out yet, only queued
+      assert.notCalled(webexRequestStub);
+
+      // now simulate the first locus request (offer) to resolve,
+      // so that the next request from the queue (ok) can be sent out
+      requestsToLocus[0].resolve();
+      await testUtils.flushPromises();
+      ensureQueueProcessingIsStarted();
+
+      // verify OK was sent out
+      assert.calledWith(webexRequestStub, {
+        method: 'PUT',
+        uri: 'fakeMeetingSelfUrl/media',
+        body: createExpectedRoapBody('OK', {audioMuted: true, videoMuted: true}),
+      });
+
+      // promise returned by the first call to send OFFER should be resolved by now
+      await results[0];
+
+      // simulate Locus sending http response to OK
+      requestsToLocus[1].resolve();
+      await results[1];
+    });
+
+    it('combines local mute requests into a single /media request to Locus when queueing', async () => {
+      results.push(sendRoapMessage('OFFER'));
+      results.push(sendLocalMute({audioMuted: false, videoMuted: false}));
+
+      ensureQueueProcessingIsStarted();
+
+      // check that OFFER and local mute have been combined into
+      // a single OFFER request with the right mute values
+      assert.calledOnceWithExactly(webexRequestStub, {
+        method: 'PUT',
+        uri: 'fakeMeetingSelfUrl/media',
+        body: createExpectedRoapBody('OFFER', {audioMuted: false, videoMuted: false}),
+      });
+
+      webexRequestStub.resetHistory();
+
+      // at this point the request should be sent out and "in progress",
+      // so any further calls should be queued
+      results.push(sendLocalMute({audioMuted: true, videoMuted: false}));
+      results.push(sendRoapMessage('OK'));
+      results.push(sendLocalMute({audioMuted: false, videoMuted: true}));
+
+      // nothing should be sent out yet, only queued
+      assert.notCalled(webexRequestStub);
+
+      // now simulate the first locus request (offer) to resolve,
+      // so that the next request from the queue (ok) can be sent out
+      requestsToLocus[0].resolve();
+      await testUtils.flushPromises();
+      ensureQueueProcessingIsStarted();
+
+      // verify OK was sent out
+      assert.calledOnceWithExactly(webexRequestStub, {
+        method: 'PUT',
+        uri: 'fakeMeetingSelfUrl/media',
+        body: createExpectedRoapBody('OK', {audioMuted: false, videoMuted: true}),
+      });
+
+      // promise returned by the first call to send OFFER should be resolved by now
+      await results[0];
+
+      // simulate Locus sending http response to OK
+      requestsToLocus[1].resolve();
+      await results[1];
+    });
+
+    describe('confluence creation', () => {
+      it('resolves without sending the request if LocalMute is requested before Roap Offer is sent (confluence state is "not created")', async () => {
+        const result = await sendLocalMute({audioMuted: false, videoMuted: true});
+
+        assert.notCalled(webexRequestStub);
+        assert.deepEqual(result, {});
+      });
+
+      it('queues LocalMute if requested after first Roap Offer was sent but before it got http response (confluence state is "creation in progress")', async () => {
+        let result;
+
+        // send roap offer so that confluence state is "creation in progress"
+        sendRoapMessage('OFFER');
+
+        ensureQueueProcessingIsStarted();
+
+        sendLocalMute({audioMuted: false, videoMuted: true})
+          .then((response) => {
+            result = response;
+          });
+
+        // only roap offer should have been sent so far
+        assert.calledOnceWithExactly(webexRequestStub, {
+          method: 'PUT',
+          uri: 'fakeMeetingSelfUrl/media',
+          body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
+        });
+        assert.equal(result, undefined); // sendLocalMute shouldn't resolve yet, as the request should be queued
+
+        // now let the Offer be completed - so confluence state will be "complete"
+        webexRequestStub.resetHistory();
+        requestsToLocus[0].resolve({});
+        await testUtils.flushPromises();
+
+        // now the queued up local mute request should have been sent out
+        assert.calledOnceWithExactly(webexRequestStub, {
+          method: 'PUT',
+          uri: 'fakeMeetingSelfUrl/media',
+          body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
+        });
+
+        // check also the result once Locus replies to local mute
+        const fakeLocusResponse = { response: 'ok'};
+        requestsToLocus[1].resolve(fakeLocusResponse);
+        await testUtils.flushPromises();
+        assert.deepEqual(result, fakeLocusResponse);
+      });
+    });
+
+    it('sends LocalMute request if Offer was already sent and Locus replied (confluence state is "completed")', async () => {
+      let result;
+
+      // send roap offer and ensure it's completed
+      sendRoapMessage('OFFER');
+      ensureQueueProcessingIsStarted();
+      requestsToLocus[0].resolve({});
+      await testUtils.flushPromises();
+      webexRequestStub.resetHistory();
+
+      // now send local mute
+      sendLocalMute({audioMuted: false, videoMuted: true})
+        .then((response) => {
+          result = response;
+        });
+
+      ensureQueueProcessingIsStarted();
+
+      // it should be sent out
+      assert.calledOnceWithExactly(webexRequestStub, {
+        method: 'PUT',
+        uri: 'fakeMeetingSelfUrl/media',
+        body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
+      });
+    });
+
+  });
+})