@webex/plugin-meetings 3.0.0-beta.34 → 3.0.0-beta.35

package/src/meeting/request.ts

@@ -23,10 +23,10 @@ import {
   PARTICIPANT,
   PROVISIONAL_TYPE_DIAL_IN,
   PROVISIONAL_TYPE_DIAL_OUT,
+  REACHABILITY,
   SEND_DTMF_ENDPOINT,
   _SLIDES_,
 } from '../constants';
-import {Reaction} from '../reactions/reactions.type';
 import {SendReactionOptions, ToggleReactionsOptions} from './request.type';
 
 /**
@@ -35,6 +35,11 @@ import {SendReactionOptions, ToggleReactionsOptions} from './request.type';
 export default class MeetingRequest extends StatelessWebexPlugin {
   changeVideoLayoutDebounced: any;
 
+  /**
+   * Constructor
+   * @param {Object} attrs
+   * @param {Object} options
+   */
   constructor(attrs: any, options: any) {
     super(attrs, options);
     this.changeVideoLayoutDebounced = debounce(this.changeVideoLayout, 2000, {
@@ -43,6 +48,32 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     });
   }
 
+  /**
+   * Returns joinCookie from boundedStorage if present.
+   * @returns {Object} joinCookie
+   */
+  private getJoinCookie = async () => {
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        const joinCookie = JSON.parse(joinCookieRaw);
+        if (joinCookie) {
+          return joinCookie;
+        }
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return null;
+  };
+
   /**
    * Make a network request to join a meeting
    * @param {Object} options
@@ -99,6 +130,8 @@ export default class MeetingRequest extends StatelessWebexPlugin {
 
     let url = '';
 
+    const joinCookie = await this.getJoinCookie();
+
     const body: any = {
       asResourceOccupant,
       device: {
@@ -115,6 +148,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       supportsNativeLobby: 1,
       clientMediaPreferences: {
         preferTranscoding: preferTranscoding ?? true,
+        joinCookie,
       },
     };
 

package/src/reachability/index.ts

@@ -63,11 +63,13 @@ export default class Reachability {
 
     // Remove stored reachability results to ensure no stale data
     // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorage);
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
 
     // Fetch clusters and measure latency
     try {
-      const clusters = await this.reachabilityRequest.getClusters();
+      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters();
 
       // Perform Reachability Check
       const results = await this.performReachabilityCheck(clusters);
@@ -75,9 +77,15 @@ export default class Reachability {
       // @ts-ignore
       await this.webex.boundedStorage.put(
         this.namespace,
-        REACHABILITY.localStorage,
+        REACHABILITY.localStorageResult,
         JSON.stringify(results)
       );
+      // @ts-ignore
+      await this.webex.boundedStorage.put(
+        this.namespace,
+        REACHABILITY.localStorageJoinCookie,
+        JSON.stringify(joinCookie)
+      );
 
       LoggerProxy.logger.log(
         'Reachability:index#gatherReachability --> Reachability checks completed'
@@ -103,7 +111,7 @@ export default class Reachability {
     let reachable = false;
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
-      .get(this.namespace, REACHABILITY.localStorage)
+      .get(this.namespace, REACHABILITY.localStorageResult)
       .catch(() => {});
 
     if (reachabilityData) {

package/src/reachability/request.ts

@@ -28,21 +28,23 @@ class ReachabilityRequest {
   }
 
   /**
-   * gets the cluster information
+   * Gets the cluster information
    *
-   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
    * @returns {Promise}
    */
-  getClusters = (): Promise<ClusterList> =>
+  getClusters = (): Promise<{clusters: ClusterList; joinCookie: any}> =>
     this.webex
       .request({
         method: HTTP_VERBS.GET,
         shouldRefreshAccessToken: false,
         api: API.CALLIOPEDISCOVERY,
         resource: RESOURCE.CLUSTERS,
+        qs: {
+          JCSupport: 1,
+        },
       })
       .then((res) => {
-        const {clusters} = res.body;
+        const {clusters, joinCookie} = res.body;
 
         Object.keys(clusters).forEach((key) => {
           clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
@@ -52,7 +54,10 @@ class ReachabilityRequest {
           `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
         );
 
-        return clusters;
+        return {
+          clusters,
+          joinCookie,
+        };
       });
 
   /**

package/src/roap/request.ts

@@ -12,14 +12,16 @@ import {eventType} from '../metrics/config';
  */
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
-   * Joins a meeting via ROAP
+   * Returns reachability data.
    * @param {Object} localSdp
-   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
+   * @returns {Object}
    */
-  async attachRechabilityData(localSdp) {
+  async attachReachabilityData(localSdp) {
+    let joinCookie;
+
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorage)
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
       .catch(() => {});
 
     if (reachabilityData) {
@@ -37,7 +39,22 @@ export default class RoapRequest extends StatelessWebexPlugin {
       }
     }
 
-    return localSdp;
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        joinCookie = JSON.parse(joinCookieRaw);
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return {localSdp, joinCookie};
   }
 
   /**
@@ -53,7 +70,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {Boolean} options.preferTranscoding
    * @returns {Promise} returns the response/failure of the request
    */
-  sendRoap(options: {
+  async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
@@ -69,6 +86,14 @@ export default class RoapRequest extends StatelessWebexPlugin {
       LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
     }
 
+    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;
@@ -79,79 +104,69 @@ export default class RoapRequest extends StatelessWebexPlugin {
 
     Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
 
-    return this.attachRechabilityData({
-      roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
-    }).then((sdpWithReachability) => {
-      // @ts-ignore
-      return this.webex
-        .request({
-          uri: mediaUrl,
-          method: HTTP_VERBS.PUT,
-          body: {
-            device: {
-              url: deviceUrl,
-              // @ts-ignore
-              deviceType: this.config.meetings.deviceType,
-            },
-            correlationId,
-            localMedias: [
-              {
-                localSdp: JSON.stringify(sdpWithReachability),
-                mediaId: options.mediaId,
-              },
-            ],
-            clientMediaPreferences: {
-              preferTranscoding: options.preferTranscoding ?? true,
-            },
+    // @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,
           },
-        })
-        .then((res) => {
-          Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
-          // always it will be the first mediaConnection Object
-          const mediaConnections =
-            res.body.mediaConnections &&
-            res.body.mediaConnections.length > 0 &&
-            res.body.mediaConnections[0];
-
-          LoggerProxy.logger.debug(
-            `Roap:request#sendRoap --> response:${JSON.stringify(
-              mediaConnections,
-              null,
-              2
-            )}'\n StatusCode:'${res.statusCode}`
-          );
-          const {locus} = res.body;
-
-          locus.roapSeq = options.roapMessage.seq;
-
-          return {
-            locus,
-            ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
-          };
-        })
-        .catch((err) => {
-          Metrics.postEvent({
-            event: eventType.MEDIA_RESPONSE,
-            meetingId,
-            data: {error: Metrics.parseLocusError(err, true)},
-          });
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`
-          );
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
-              roapMessage,
-              null,
-              2
-            )} + '\\n mediaId:'${options.mediaId}`
-          );
-          throw err;
+        ],
+        clientMediaPreferences: {
+          preferTranscoding: options.preferTranscoding ?? true,
+          joinCookie,
+        },
+      },
+    })
+      .then((res) => {
+        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
+
+        // always it will be the first mediaConnection Object
+        const mediaConnections =
+          res.body.mediaConnections &&
+          res.body.mediaConnections.length > 0 &&
+          res.body.mediaConnections[0];
+
+        LoggerProxy.logger.debug(
+          `Roap:request#sendRoap --> response:${JSON.stringify(
+            mediaConnections,
+            null,
+            2
+          )}'\n StatusCode:'${res.statusCode}`
+        );
+        const {locus} = res.body;
+
+        locus.roapSeq = options.roapMessage.seq;
+
+        return {
+          locus,
+          ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
+        };
+      })
+      .catch((err) => {
+        Metrics.postEvent({
+          event: eventType.MEDIA_RESPONSE,
+          meetingId,
+          data: {error: Metrics.parseLocusError(err, true)},
         });
-    });
+        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
+        LoggerProxy.logger.error(
+          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+            roapMessage,
+            null,
+            2
+          )} + '\\n mediaId:'${options.mediaId}`
+        );
+        throw err;
+      });
   }
 }

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

@@ -26,6 +26,8 @@ describe('plugin-meetings', () => {
       },
     };
 
+    webex.boundedStorage.get = sinon.mock().returns(Promise.resolve(JSON.stringify({anycastEntryPoint: "aws-eu-west-1"})))
+
     meetingsRequest = new MeetingRequest(
       {},
       {
@@ -206,6 +208,31 @@ describe('plugin-meetings', () => {
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
         assert.deepEqual(requestParams.body.deviceCapabilities, undefined);
+
+      });
+
+      it('includes joinCookie correctly', async () => {
+        const locusUrl = 'locusURL';
+        const deviceUrl = 'deviceUrl';
+        const correlationId = 'random-uuid';
+        const roapMessage = 'roap-message';
+        const permissionToken = 'permission-token';
+
+        await meetingsRequest.joinMeeting({
+          locusUrl,
+          deviceUrl,
+          correlationId,
+          roapMessage,
+          permissionToken,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
+        assert.deepEqual(requestParams.body.clientMediaPreferences, {
+          "joinCookie": {anycastEntryPoint: "aws-eu-west-1"},
+          "preferTranscoding": true
+        });
       });
     });
 

package/test/unit/spec/reachability/index.ts

@@ -22,8 +22,8 @@ describe('isAnyClusterReachable', () => {
 
     const result = await reachability.isAnyClusterReachable();
 
-    assert.equal(result, expectedValue);
-  };
+      assert.equal(result, expectedValue);
+    };
 
   it('returns true when udp is reachable', async () => {
     await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
@@ -66,19 +66,30 @@ describe('gatherReachability', () => {
   it('stores the reachability', async () => {
     const reachability = new Reachability(webex);
 
-    const clusters = {some: 'clusters'};
-    const reachabilityResults = {some: 'results'};
+    const reachabilityResults = {
+      clusters: {
+        clusterId: {
+          udp: 'testUDP',
+        },
+      },
+    }
+    const getClustersResult = {
+      clusters: {clusterId: 'cluster'},
+      joinCookie: {id: 'id'}
+    };
 
-    reachability.reachabilityRequest.getClusters = sinon.stub().returns(clusters);
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
     (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults)
 
     const result = await reachability.gatherReachability();
 
     assert.equal(result, reachabilityResults);
 
-    const storedResult = await webex.boundedStorage.get('Reachability', 'reachability.result');
+    const storedResultForReachabilityResult = await webex.boundedStorage.get('Reachability', 'reachability.result');
+    const storedResultForJoinCookie = await webex.boundedStorage.get('Reachability', 'reachability.joinCookie');
 
-    assert.equal(JSON.stringify(result), storedResult);
+    assert.equal(JSON.stringify(result), storedResultForReachabilityResult);
+    assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
   });
 
 });

package/test/unit/spec/reachability/request.js

@@ -0,0 +1,66 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
+
+
+describe('plugin-meetings/reachability', () => {
+  let reachabilityRequest;
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns('locusUrl'),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+    };
+
+
+    reachabilityRequest = new ReachabilityRequest(webex);
+
+  });
+
+  describe('#getClusters', () => {
+    it('sends a GET request with the correct params', async () => {
+      webex.request = sinon.mock().returns(Promise.resolve({
+        body: {
+          clusterClasses: {
+            hybridMedia: ["clusterId"]
+          },
+          clusters: {"clusterId": {
+            udp: "testUDP"
+          }},
+          joinCookie: {anycastEntryPoint: "aws-eu-west-1"}
+        }
+      }));
+
+      const res = await reachabilityRequest.getClusters();
+
+      const requestParams = webex.request.getCall(0).args[0];
+
+      assert.equal(requestParams.method, 'GET');
+      assert.equal(requestParams.resource, `clusters`);
+      assert.equal(requestParams.api, 'calliopeDiscovery');
+      assert.equal(requestParams.shouldRefreshAccessToken, false);
+
+      assert.deepEqual(requestParams.qs, {
+        JCSupport: 1,
+      });
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+    });
+  });
+});