@webex/plugin-meetings 3.0.0-beta.259 → 3.0.0-beta.260

package/dist/types/constants.d.ts

@@ -1029,3 +1029,5 @@ export declare const IP_VERSION: {
     readonly ipv4_and_ipv6: 1;
 };
 export type IP_VERSION = (typeof IP_VERSION)[keyof typeof IP_VERSION];
+export declare const MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC = 30;
+export declare const MEETING_PERMISSION_TOKEN_REFRESH_REASON = "ttl-join";

package/dist/types/meeting/index.d.ts

@@ -964,7 +964,10 @@ export default class Meeting extends StatelessWebexPlugin {
     joinWithMedia(options?: {
         joinOptions?: any;
         mediaOptions?: AddMediaOptions;
-    }): any;
+    }): Promise<{
+        join: any;
+        media: any;
+    }>;
     /**
      * Initiates the reconnection of the media in the meeting
      *
@@ -1029,7 +1032,7 @@ export default class Meeting extends StatelessWebexPlugin {
      *             if joining as host on second loop, pass pin and pass moderator if joining as guest on second loop
      * Scenario D: Joining any other way (sip, pstn, conversationUrl, link just need to specify resourceId)
      */
-    join(options?: any): any;
+    join(options?: any): Promise<any>;
     /**
      * Connects to low latency mercury and reconnects if the address has changed
      * It will also disconnect if called when the meeting has ended
@@ -1547,4 +1550,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {number} time left in seconds
      */
     getPermissionTokenTimeLeftInSec(): number | undefined;
+    /**
+     * Check if there is enough time left till the permission token expires
+     * If not - refresh the permission token
+     *
+     * @param {number} threshold - time in seconds
+     * @param {string} reason - reason for refreshing the permission token
+     * @returns {Promise<void>}
+     */
+    checkAndRefreshPermissionToken(threshold: number, reason: string): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.259",
+  "version": "3.0.0-beta.260",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -32,12 +32,12 @@
     "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.259",
-    "@webex/test-helper-chai": "3.0.0-beta.259",
-    "@webex/test-helper-mocha": "3.0.0-beta.259",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.259",
-    "@webex/test-helper-retry": "3.0.0-beta.259",
-    "@webex/test-helper-test-users": "3.0.0-beta.259",
+    "@webex/plugin-meetings": "3.0.0-beta.260",
+    "@webex/test-helper-chai": "3.0.0-beta.260",
+    "@webex/test-helper-mocha": "3.0.0-beta.260",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.260",
+    "@webex/test-helper-retry": "3.0.0-beta.260",
+    "@webex/test-helper-test-users": "3.0.0-beta.260",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -46,19 +46,19 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.259",
+    "@webex/common": "3.0.0-beta.260",
     "@webex/internal-media-core": "2.0.4",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.259",
-    "@webex/internal-plugin-device": "3.0.0-beta.259",
-    "@webex/internal-plugin-llm": "3.0.0-beta.259",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.259",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.259",
-    "@webex/internal-plugin-support": "3.0.0-beta.259",
-    "@webex/internal-plugin-user": "3.0.0-beta.259",
-    "@webex/media-helpers": "3.0.0-beta.259",
-    "@webex/plugin-people": "3.0.0-beta.259",
-    "@webex/plugin-rooms": "3.0.0-beta.259",
-    "@webex/webex-core": "3.0.0-beta.259",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.260",
+    "@webex/internal-plugin-device": "3.0.0-beta.260",
+    "@webex/internal-plugin-llm": "3.0.0-beta.260",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.260",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.260",
+    "@webex/internal-plugin-support": "3.0.0-beta.260",
+    "@webex/internal-plugin-user": "3.0.0-beta.260",
+    "@webex/media-helpers": "3.0.0-beta.260",
+    "@webex/plugin-people": "3.0.0-beta.260",
+    "@webex/plugin-rooms": "3.0.0-beta.260",
+    "@webex/webex-core": "3.0.0-beta.260",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",

package/src/constants.ts

@@ -1249,3 +1249,7 @@ export const IP_VERSION = {
 } as const;
 
 export type IP_VERSION = (typeof IP_VERSION)[keyof typeof IP_VERSION];
+
+// constant for if the permissionToken is about to expire in the next 30 seconds, refresh it
+export const MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC = 30;
+export const MEETING_PERMISSION_TOKEN_REFRESH_REASON = 'ttl-join';

package/src/meeting/index.ts

@@ -97,6 +97,8 @@ import {
   SELF_ROLES,
   INTERPRETATION,
   SELF_POLICY,
+  MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC,
+  MEETING_PERMISSION_TOKEN_REFRESH_REASON,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -4437,7 +4439,7 @@ export default class Meeting extends StatelessWebexPlugin {
    *             if joining as host on second loop, pass pin and pass moderator if joining as guest on second loop
    * Scenario D: Joining any other way (sip, pstn, conversationUrl, link just need to specify resourceId)
    */
-  public join(options: any = {}) {
+  public async join(options: any = {}) {
     // @ts-ignore - fix type
     if (!this.webex.meetings.registered) {
       const errorMessage = 'Meeting:index#join --> Device not registered';
@@ -4548,6 +4550,43 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.isMultistream = !!options.enableMultistream;
 
+    try {
+      // refresh the permission token if its about to expire in 10sec
+      await this.checkAndRefreshPermissionToken(
+        MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC,
+        MEETING_PERMISSION_TOKEN_REFRESH_REASON
+      );
+    } catch (error) {
+      LoggerProxy.logger.error('Meeting:index#join --> Failed to refresh permission token:', error);
+
+      if (
+        error instanceof CaptchaError ||
+        error instanceof PasswordError ||
+        error instanceof PermissionError
+      ) {
+        this.meetingFiniteStateMachine.fail(error);
+
+        // Upload logs on refreshpermissionToken refresh Failure
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'join',
+          },
+          EVENTS.REQUEST_UPLOAD_LOGS,
+          this
+        );
+
+        joinFailed(error);
+
+        this.deferJoin = undefined;
+
+        // if refresh permission token requires captcha, password or permission, we are throwing the errors
+        // and bubble it up to client
+        return Promise.reject(error);
+      }
+    }
+
     return MeetingUtil.joinMeetingOptions(this, options)
       .then((join) => {
         this.meetingFiniteStateMachine.join();
@@ -7401,4 +7440,22 @@ export default class Meeting extends StatelessWebexPlugin {
     // (permissionTokenExp is a epoch timestamp, not a time to live duration)
     return (permissionTokenExpValue - now) / 1000;
   }
+
+  /**
+   * Check if there is enough time left till the permission token expires
+   * If not - refresh the permission token
+   *
+   * @param {number} threshold - time in seconds
+   * @param {string} reason - reason for refreshing the permission token
+   * @returns {Promise<void>}
+   */
+  public checkAndRefreshPermissionToken(threshold: number, reason: string): Promise<void> {
+    const permissionTokenTimeLeft = this.getPermissionTokenTimeLeftInSec();
+
+    if (permissionTokenTimeLeft !== undefined && permissionTokenTimeLeft <= threshold) {
+      return this.refreshPermissionToken(reason);
+    }
+
+    return Promise.resolve();
+  }
 }

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

@@ -29,6 +29,7 @@ import {
   DISPLAY_HINTS,
   SELF_POLICY,
   IP_VERSION,
+  ERROR_DICTIONARY,
 } from '@webex/plugin-meetings/src/constants';
 import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import {
@@ -798,6 +799,7 @@ describe('plugin-meetings', () => {
           webex.meetings.registered = true;
           meeting.updateLLMConnection = sinon.stub();
         });
+
         describe('successful', () => {
           beforeEach(() => {
             sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
@@ -918,7 +920,7 @@ describe('plugin-meetings', () => {
             });
           });
         });
-        describe('lmm and transcription decoupling', () => {
+        describe('lmm, transcription & permissionTokenRefresh decoupling', () => {
           beforeEach(() => {
             sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
           });
@@ -1021,7 +1023,6 @@ describe('plugin-meetings', () => {
               try {
                 await defer.promise;
               } catch (err) {
-                console.log(Metrics.sendBehavioralMetric.getCalls())
                 assert.deepEqual(Metrics.sendBehavioralMetric.getCalls()[0].args, [
                   BEHAVIORAL_METRICS.JOIN_SUCCESS, {correlation_id: meeting.correlationId}
                 ])
@@ -1036,6 +1037,76 @@ describe('plugin-meetings', () => {
               }
             })
           })
+
+          describe('refreshPermissionToken', () => { 
+            it('should continue if permissionTokenRefresh fails with a generic error', async () => { 
+              meeting.checkAndRefreshPermissionToken = sinon.stub().rejects(new Error('bad day'));
+              const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+
+              try {
+                const result = await meeting.join();
+                assert.notCalled(stateMachineFailSpy);
+                assert.equal(result, joinMeetingResult);
+                assert.calledOnceWithExactly(meeting.checkAndRefreshPermissionToken, 30, 'ttl-join');
+              } catch (error) {
+                assert.fail('join should not throw an Error');
+              }
+            })
+
+            it('should throw if permissionTokenRefresh fails with a captcha error', async () => { 
+              meeting.checkAndRefreshPermissionToken = sinon.stub().rejects(new CaptchaError('bad captcha'));
+              const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+              const joinMeetingOptionsSpy = sinon.spy(MeetingUtil, 'joinMeetingOptions');
+
+              try {
+                await meeting.join();
+                assert.fail('join should have thrown a Captcha Error.');
+              } catch (error) {
+                assert.calledOnce(stateMachineFailSpy);
+                assert.calledOnceWithExactly(meeting.checkAndRefreshPermissionToken, 30, 'ttl-join');
+                assert.instanceOf(error, CaptchaError);
+                assert.equal(error.message, 'bad captcha');
+                // should not get to the end promise chain, which does do the join
+                assert.notCalled(joinMeetingOptionsSpy);
+              }
+            })
+
+            it('should throw if permissionTokenRefresh fails with a password error', async () => { 
+              meeting.checkAndRefreshPermissionToken = sinon.stub().rejects(new PasswordError('bad password'));
+              const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+              const joinMeetingOptionsSpy = sinon.spy(MeetingUtil.joinMeetingOptions);
+
+              try {
+                await meeting.join();
+                assert.fail('join should have thrown a Password Error.');
+              } catch (error) {
+                assert.calledOnce(stateMachineFailSpy);
+                assert.calledOnceWithExactly(meeting.checkAndRefreshPermissionToken, 30, 'ttl-join');
+                assert.instanceOf(error, PasswordError);
+                assert.equal(error.message, 'bad password');
+                // should not get to the end promise chain, which does do the join
+                assert.notCalled(joinMeetingOptionsSpy);
+              }
+            })
+
+            it('should throw if permissionTokenRefresh fails with a permission error', async () => { 
+              meeting.checkAndRefreshPermissionToken = sinon.stub().rejects(new PermissionError('bad permission'));
+              const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+              const joinMeetingOptionsSpy = sinon.spy(MeetingUtil.joinMeetingOptions);
+
+              try {
+                await meeting.join();
+                assert.fail('join should have thrown a Permission Error.');
+              } catch (error) {
+                assert.calledOnce(stateMachineFailSpy);
+                assert.calledOnceWithExactly(meeting.checkAndRefreshPermissionToken, 30, 'ttl-join');
+                assert.instanceOf(error, PermissionError);
+                assert.equal(error.message, 'bad permission');
+                // should not get to the end promise chain, which does do the join
+                assert.notCalled(joinMeetingOptionsSpy);
+              }
+            })
+          })
         })
       });
 
@@ -8309,4 +8380,50 @@ describe('plugin-meetings', () => {
       assert.equal(meeting.getPermissionTokenTimeLeftInSec(), -1);
     });
   });
+
+  describe('#checkAndRefreshPermissionToken', () => {
+    it('should not fire refreshPermissionToken if permissionToken is not defined', async() => { 
+      meeting.getPermissionTokenTimeLeftInSec = sinon.stub().returns(undefined)
+      meeting.refreshPermissionToken = sinon.stub().returns(Promise.resolve('test return value'));
+
+      const returnValue = await meeting.checkAndRefreshPermissionToken(10, 'ttl-join');
+
+      assert.calledOnce(meeting.getPermissionTokenTimeLeftInSec);
+      assert.notCalled(meeting.refreshPermissionToken);
+      assert.equal(returnValue, undefined);
+    });
+
+    it('should fire refreshPermissionToken if time left is below 10sec', async() => { 
+      meeting.getPermissionTokenTimeLeftInSec = sinon.stub().returns(9)
+      meeting.refreshPermissionToken = sinon.stub().returns(Promise.resolve('test return value'));
+
+      const returnValue = await meeting.checkAndRefreshPermissionToken(10, 'ttl-join');
+
+      assert.calledOnce(meeting.getPermissionTokenTimeLeftInSec);
+      assert.calledOnceWithExactly(meeting.refreshPermissionToken, 'ttl-join');
+      assert.equal(returnValue, 'test return value');
+    });
+
+    it('should fire refreshPermissionToken if time left is equal 10sec', async () => { 
+      meeting.getPermissionTokenTimeLeftInSec = sinon.stub().returns(10)
+      meeting.refreshPermissionToken = sinon.stub().returns(Promise.resolve('test return value'));
+
+      const returnValue = await meeting.checkAndRefreshPermissionToken(10, 'ttl-join');
+
+      assert.calledOnce(meeting.getPermissionTokenTimeLeftInSec);
+      assert.calledOnceWithExactly(meeting.refreshPermissionToken, 'ttl-join');
+      assert.equal(returnValue, 'test return value');
+    });
+
+    it('should not fire refreshPermissionToken if time left is higher than 10sec', async () => { 
+      meeting.getPermissionTokenTimeLeftInSec = sinon.stub().returns(11)
+      meeting.refreshPermissionToken = sinon.stub().returns(Promise.resolve('test return value'));
+
+      const returnValue = await meeting.checkAndRefreshPermissionToken(10, 'ttl-join');
+      
+      assert.calledOnce(meeting.getPermissionTokenTimeLeftInSec);
+      assert.notCalled(meeting.refreshPermissionToken);
+      assert.equal(returnValue, undefined);
+    });
+  });
 });