@webex/plugin-meetings 2.60.0-next.9 → 2.60.1-next.1

package/package.json

@@ -44,13 +44,13 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "2.60.0-next.9",
-    "@webex/plugin-rooms": "2.60.0-next.6",
-    "@webex/test-helper-chai": "2.60.0-next.6",
-    "@webex/test-helper-mocha": "2.60.0-next.6",
-    "@webex/test-helper-mock-webex": "2.60.0-next.6",
-    "@webex/test-helper-retry": "2.60.0-next.6",
-    "@webex/test-helper-test-users": "2.60.0-next.6",
+    "@webex/plugin-meetings": "2.60.1-next.1",
+    "@webex/plugin-rooms": "2.60.1-next.1",
+    "@webex/test-helper-chai": "2.60.1-next.1",
+    "@webex/test-helper-mocha": "2.60.1-next.1",
+    "@webex/test-helper-mock-webex": "2.60.1-next.1",
+    "@webex/test-helper-retry": "2.60.1-next.1",
+    "@webex/test-helper-test-users": "2.60.1-next.1",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -62,19 +62,19 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "2.60.0-next.6",
-    "@webex/internal-media-core": "2.2.3",
-    "@webex/internal-plugin-conversation": "2.60.0-next.6",
-    "@webex/internal-plugin-device": "2.60.0-next.6",
-    "@webex/internal-plugin-llm": "2.60.0-next.6",
-    "@webex/internal-plugin-mercury": "2.60.0-next.6",
-    "@webex/internal-plugin-metrics": "2.60.0-next.6",
-    "@webex/internal-plugin-support": "2.60.0-next.6",
-    "@webex/internal-plugin-user": "2.60.0-next.6",
-    "@webex/media-helpers": "3.0.0-next.17",
-    "@webex/plugin-people": "2.60.0-next.6",
-    "@webex/plugin-rooms": "2.60.0-next.6",
-    "@webex/webex-core": "2.60.0-next.6",
+    "@webex/common": "2.60.1-next.1",
+    "@webex/internal-media-core": "2.2.6",
+    "@webex/internal-plugin-conversation": "2.60.1-next.1",
+    "@webex/internal-plugin-device": "2.60.1-next.1",
+    "@webex/internal-plugin-llm": "2.60.1-next.1",
+    "@webex/internal-plugin-mercury": "2.60.1-next.1",
+    "@webex/internal-plugin-metrics": "2.60.1-next.1",
+    "@webex/internal-plugin-support": "2.60.1-next.1",
+    "@webex/internal-plugin-user": "2.60.1-next.1",
+    "@webex/media-helpers": "3.0.0-next.20",
+    "@webex/plugin-people": "2.60.1-next.1",
+    "@webex/plugin-rooms": "2.60.1-next.1",
+    "@webex/webex-core": "2.60.1-next.1",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -82,11 +82,14 @@
     "global": "^4.4.0",
     "ip-anonymize": "^0.1.0",
     "javascript-state-machine": "^3.1.0",
-    "jwt-decode": "^4.0.0",
+    "jwt-decode": "3.1.2",
     "lodash": "^4.17.21",
     "sdp-transform": "^2.12.0",
     "uuid": "^3.3.2",
     "webrtc-adapter": "^8.1.2"
   },
-  "version": "2.60.0-next.9"
+  "//": [
+    "TODO: upgrade jwt-decode when moving to node 18"
+  ],
+  "version": "2.60.1-next.1"
 }

package/src/config.ts

@@ -86,6 +86,7 @@ export default {
       enableMediaNegotiatedEvent: false,
       enableUnifiedMeetings: true,
       enableAdhocMeetings: true,
+      enableTcpReachability: false,
     },
     degradationPreferences: {
       maxMacroblocksLimit: 8192,

package/src/index.ts

@@ -3,9 +3,13 @@ import {registerPlugin} from '@webex/webex-core';
 
 import Meetings from './meetings';
 import config from './config';
+import {LocusRetryStatusInterceptor} from './interceptors';
 
 registerPlugin('meetings', Meetings, {
   config,
+  interceptors: {
+    LocusRetryStatusInterceptor: LocusRetryStatusInterceptor.create,
+  },
 });
 
 export {

package/src/interceptors/index.ts

@@ -0,0 +1,3 @@
+import LocusRetryStatusInterceptor from './locusRetry';
+
+export {LocusRetryStatusInterceptor};

package/src/interceptors/locusRetry.ts

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+
+const rateLimitExpiryTime = new WeakMap();
+/**
+ * @class
+ */
+export default class LocusRetryStatusInterceptor extends Interceptor {
+  /**
+   * @returns {LocusRetryStatusInterceptor}
+   */
+  static create() {
+    // @ts-ignore
+    return new LocusRetryStatusInterceptor({webex: this});
+  }
+
+  /**
+   * Handle response errors
+   * @param {Object} options
+   * @param {WebexHttpError} reason
+   * @returns {Promise<WebexHttpError>}
+   */
+  onResponseError(options, reason) {
+    if ((reason.statusCode === 503 || reason.statusCode === 429) && options.uri.includes('locus')) {
+      const hasRetriedLocusRequest = rateLimitExpiryTime.get(this);
+      const retryAfterTime = options.headers['retry-after'] || 2000;
+
+      if (hasRetriedLocusRequest) {
+        rateLimitExpiryTime.set(this, false);
+
+        return Promise.reject(options);
+      }
+      rateLimitExpiryTime.set(this, true);
+
+      return this.handleRetryRequestLocusServiceError(options, retryAfterTime);
+    }
+
+    return Promise.reject(reason);
+  }
+
+  /**
+   * Handle retries for locus service unavailable errors
+   * @param {Object} options associated with the request
+   * @param {number} retryAfterTime retry after time in milliseconds
+   * @returns {Promise}
+   */
+  handleRetryRequestLocusServiceError(options, retryAfterTime) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        clearTimeout(timeout);
+
+        // @ts-ignore
+        this.webex
+          .request({
+            method: options.method,
+            uri: options.uri,
+            body: options.body,
+          })
+          .then(resolve)
+          .catch(reject);
+      }, retryAfterTime);
+    });
+  }
+}

package/src/meeting/index.ts

@@ -1,6 +1,6 @@
 import uuid from 'uuid';
 import {cloneDeep, isEqual, isEmpty} from 'lodash';
-import {jwtDecode as decode} from 'jwt-decode';
+import jwtDecode from 'jwt-decode';
 // @ts-ignore - Fix this
 import {StatelessWebexPlugin} from '@webex/webex-core';
 // @ts-ignore - Types not available for @webex/common
@@ -3549,7 +3549,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {void}
    */
   public setPermissionTokenPayload(permissionToken: string) {
-    this.permissionTokenPayload = decode(permissionToken);
+    this.permissionTokenPayload = jwtDecode(permissionToken);
     this.permissionTokenReceivedLocalTime = new Date().getTime();
   }
 
@@ -4260,6 +4260,14 @@ export default class Meeting extends StatelessWebexPlugin {
   ) {
     const {mediaOptions, joinOptions} = options;
 
+    if (!mediaOptions?.allowMediaInLobby) {
+      return Promise.reject(
+        new ParameterError('joinWithMedia() can only be used with allowMediaInLobby set to true')
+      );
+    }
+
+    LoggerProxy.logger.info('Meeting:index#joinWithMedia called');
+
     return this.join(joinOptions)
       .then((joinResponse) =>
         this.addMedia(mediaOptions).then((mediaResponse) => ({

package/src/meetings/index.ts

@@ -1369,11 +1369,12 @@ export default class Meetings extends WebexPlugin {
         const meetingsCollection = this.meetingCollection.getAll();
 
         if (Object.keys(meetingsCollection).length > 0) {
-          // Some time the mercury event is missed after mercury reconnect
-          // if sync returns no locus then clear all the meetings
+          // Sometimes the mercury events are lost after mercury reconnect
+          // Remove any Locus meetings that are not returned by Locus
+          // (they had a locusUrl previously but are no longer active) in the sync
           for (const meeting of Object.values(meetingsCollection)) {
             // @ts-ignore
-            if (!activeLocusUrl.includes(meeting.locusUrl)) {
+            if (meeting.locusUrl && !activeLocusUrl.includes(meeting.locusUrl)) {
               // destroy function also uploads logs
               // @ts-ignore
               this.destroy(meeting, MEETING_REMOVED_REASON.NO_MEETINGS_TO_SYNC);

package/src/reachability/clusterReachability.ts

@@ -0,0 +1,320 @@
+import {Defer} from '@webex/common';
+
+import LoggerProxy from '../common/logs/logger-proxy';
+import {ClusterNode} from './request';
+import {convertStunUrlToTurn} from './util';
+
+import {ICE_GATHERING_STATE, CONNECTION_STATE} from '../constants';
+
+const DEFAULT_TIMEOUT = 3000;
+const VIDEO_MESH_TIMEOUT = 1000;
+
+// result for a specific transport protocol (like udp or tcp)
+export type TransportResult = {
+  result: 'reachable' | 'unreachable' | 'untested';
+  latencyInMilliseconds?: number; // amount of time it took to get the first ICE candidate
+  clientMediaIPs?: string[];
+};
+
+// reachability result for a specific media cluster
+export type ClusterReachabilityResult = {
+  udp: TransportResult;
+  tcp: TransportResult;
+  xtls: TransportResult;
+};
+
+/**
+ * A class that handles reachability checks for a single cluster.
+ */
+export class ClusterReachability {
+  private numUdpUrls: number;
+  private numTcpUrls: number;
+  private result: ClusterReachabilityResult;
+  private pc?: RTCPeerConnection;
+  private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
+  private startTimestamp: number;
+  public readonly isVideoMesh: boolean;
+  public readonly name;
+
+  /**
+   * Constructor for ClusterReachability
+   * @param {string} name cluster name
+   * @param {ClusterNode} clusterInfo information about the media cluster
+   */
+  constructor(name: string, clusterInfo: ClusterNode) {
+    this.name = name;
+    this.isVideoMesh = clusterInfo.isVideoMesh;
+    this.numUdpUrls = clusterInfo.udp.length;
+    this.numTcpUrls = clusterInfo.tcp.length;
+
+    this.pc = this.createPeerConnection(clusterInfo);
+
+    this.defer = new Defer();
+    this.result = {
+      udp: {
+        result: 'untested',
+      },
+      tcp: {
+        result: 'untested',
+      },
+      xtls: {
+        result: 'untested',
+      },
+    };
+  }
+
+  /**
+   * Gets total elapsed time, can be called only after start() is called
+   * @returns {Number} Milliseconds
+   */
+  private getElapsedTime() {
+    return Math.round(performance.now() - this.startTimestamp);
+  }
+
+  /**
+   * Generate peerConnection config settings
+   * @param {ClusterNode} cluster
+   * @returns {RTCConfiguration} peerConnectionConfig
+   */
+  private buildPeerConnectionConfig(cluster: ClusterNode): RTCConfiguration {
+    const udpIceServers = cluster.udp.map((url) => ({
+      username: '',
+      credential: '',
+      urls: [url],
+    }));
+
+    // STUN servers are contacted only using UDP, so in order to test TCP reachability
+    // we pretend that Linus is a TURN server, because we can explicitly say "transport=tcp" in TURN urls.
+    // We then check for relay candidates to know if TURN-TCP worked (see registerIceCandidateListener()).
+    const tcpIceServers = cluster.tcp.map((urlString: string) => {
+      return {
+        username: 'webexturnreachuser',
+        credential: 'webexturnreachpwd',
+        urls: [convertStunUrlToTurn(urlString, 'tcp')],
+      };
+    });
+
+    return {
+      iceServers: [...udpIceServers, ...tcpIceServers],
+      iceCandidatePoolSize: 0,
+      iceTransportPolicy: 'all',
+    };
+  }
+
+  /**
+   * Creates an RTCPeerConnection
+   * @param {ClusterNode} clusterInfo information about the media cluster
+   * @returns {RTCPeerConnection} peerConnection
+   */
+  private createPeerConnection(clusterInfo: ClusterNode) {
+    try {
+      const config = this.buildPeerConnectionConfig(clusterInfo);
+
+      const peerConnection = new RTCPeerConnection(config);
+
+      return peerConnection;
+    } catch (peerConnectionError) {
+      LoggerProxy.logger.warn(
+        `Reachability:index#createPeerConnection --> Error creating peerConnection:`,
+        peerConnectionError
+      );
+
+      return undefined;
+    }
+  }
+
+  /**
+   * @returns {ClusterReachabilityResult} reachability result for this cluster
+   */
+  getResult() {
+    return this.result;
+  }
+
+  /**
+   * Closes the peerConnection
+   *
+   * @returns {void}
+   */
+  private closePeerConnection() {
+    if (this.pc) {
+      this.pc.onicecandidate = null;
+      this.pc.onicegatheringstatechange = null;
+      this.pc.close();
+    }
+  }
+
+  /**
+   * Resolves the defer, indicating that reachability checks for this cluster are completed
+   *
+   * @returns {void}
+   */
+  private finishReachabilityCheck() {
+    this.defer.resolve();
+  }
+
+  /**
+   * Adds public IP (client media IPs)
+   * @param {string} protocol
+   * @param {string} publicIP
+   * @returns {void}
+   */
+  private addPublicIP(protocol: 'udp' | 'tcp', publicIP?: string | null) {
+    const result = this.result[protocol];
+
+    if (publicIP) {
+      if (result.clientMediaIPs) {
+        if (!result.clientMediaIPs.includes(publicIP)) {
+          result.clientMediaIPs.push(publicIP);
+        }
+      } else {
+        result.clientMediaIPs = [publicIP];
+      }
+    }
+  }
+
+  /**
+   * Registers a listener for the iceGatheringStateChange event
+   *
+   * @returns {void}
+   */
+  private registerIceGatheringStateChangeListener() {
+    this.pc.onicegatheringstatechange = () => {
+      const {COMPLETE} = ICE_GATHERING_STATE;
+
+      if (this.pc.iceConnectionState === COMPLETE) {
+        this.closePeerConnection();
+        this.finishReachabilityCheck();
+      }
+    };
+  }
+
+  /**
+   * Checks if we have the results for all the protocols (UDP and TCP)
+   *
+   * @returns {boolean} true if we have all results, false otherwise
+   */
+  private haveWeGotAllResults(): boolean {
+    return ['udp', 'tcp'].every(
+      (protocol) =>
+        this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
+    );
+  }
+
+  /**
+   * Stores the latency in the result for the given protocol and marks it as reachable
+   *
+   * @param {string} protocol
+   * @param {number} latency
+   * @returns {void}
+   */
+  private storeLatencyResult(protocol: 'udp' | 'tcp', latency: number) {
+    const result = this.result[protocol];
+
+    if (result.latencyInMilliseconds === undefined) {
+      LoggerProxy.logger.log(
+        // @ts-ignore
+        `Reachability:index#storeLatencyResult --> Successfully reached ${this.name} over ${protocol}: ${latency}ms`
+      );
+      result.latencyInMilliseconds = latency;
+      result.result = 'reachable';
+    }
+  }
+
+  /**
+   * Registers a listener for the icecandidate event
+   *
+   * @returns {void}
+   */
+  private registerIceCandidateListener() {
+    this.pc.onicecandidate = (e) => {
+      const CANDIDATE_TYPES = {
+        SERVER_REFLEXIVE: 'srflx',
+        RELAY: 'relay',
+      };
+
+      if (e.candidate) {
+        if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
+          this.storeLatencyResult('udp', this.getElapsedTime());
+          this.addPublicIP('udp', e.candidate.address);
+        }
+
+        if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
+          this.storeLatencyResult('tcp', this.getElapsedTime());
+          // we don't add public IP for TCP, because in the case of relay candidates
+          // e.candidate.address is the TURN server address, not the client's public IP
+        }
+
+        if (this.haveWeGotAllResults()) {
+          this.closePeerConnection();
+          this.finishReachabilityCheck();
+        }
+      }
+    };
+  }
+
+  /**
+   * Starts the process of doing UDP and TCP reachability checks on the media cluster.
+   * XTLS reachability checking is not supported.
+   *
+   * @returns {Promise}
+   */
+  async start(): Promise<ClusterReachabilityResult> {
+    if (!this.pc) {
+      LoggerProxy.logger.warn(
+        `Reachability:ClusterReachability#start --> Error: peerConnection is undefined`
+      );
+
+      return this.result;
+    }
+
+    // Initialize this.result as saying that nothing is reachable.
+    // It will get updated as we go along and successfully gather ICE candidates.
+    this.result.udp = {
+      result: this.numUdpUrls > 0 ? 'unreachable' : 'untested',
+    };
+    this.result.tcp = {
+      result: this.numTcpUrls > 0 ? 'unreachable' : 'untested',
+    };
+
+    try {
+      const offer = await this.pc.createOffer({offerToReceiveAudio: true});
+
+      this.startTimestamp = performance.now();
+
+      // not awaiting the next call on purpose, because we're not sending the offer anywhere and there won't be any answer
+      // we just need to make this call to trigger the ICE gathering process
+      this.pc.setLocalDescription(offer);
+
+      await this.gatherIceCandidates();
+    } catch (error) {
+      LoggerProxy.logger.warn(`Reachability:ClusterReachability#start --> Error: `, error);
+    }
+
+    return this.result;
+  }
+
+  /**
+   * Starts the process of gathering ICE candidates
+   *
+   * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
+   */
+  private gatherIceCandidates() {
+    const timeout = this.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT;
+
+    this.registerIceGatheringStateChangeListener();
+    this.registerIceCandidateListener();
+
+    // Set maximum timeout
+    setTimeout(() => {
+      const {CLOSED} = CONNECTION_STATE;
+
+      // Close any open peerConnections
+      if (this.pc.connectionState !== CLOSED) {
+        this.closePeerConnection();
+        this.finishReachabilityCheck();
+      }
+    }, timeout);
+
+    return this.defer.promise;
+  }
+}