@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/multistream/sendSlotManager.ts

@@ -1,170 +0,0 @@
-import {
-  SendSlot,
-  MediaType,
-  LocalStream,
-  MultistreamRoapMediaConnection,
-} from '@webex/internal-media-core';
-
-export default class SendSlotManager {
-  private readonly slots: Map<MediaType, SendSlot> = new Map();
-  private readonly LoggerProxy: any;
-
-  constructor(LoggerProxy: any) {
-    this.LoggerProxy = LoggerProxy;
-  }
-
-  /**
-   * This method is used to create a sendSlot for the given mediaType and returns the created sendSlot
-   * @param {MultistreamRoapMediaConnection} mediaConnection MultistreamRoapMediaConnection for which a sendSlot needs to be created
-   * @param {MediaType} mediaType MediaType for which a sendSlot needs to be created (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
-   * @param {boolean} active This is optional boolean to set the active state of the sendSlot. Default is true
-   * @returns {SendSlot} slot The created sendSlot
-   */
-  public createSlot(
-    mediaConnection: MultistreamRoapMediaConnection,
-    mediaType: MediaType,
-    active = true
-  ): SendSlot {
-    if (this.slots.has(mediaType)) {
-      throw new Error(`Slot for ${mediaType} already exists`);
-    }
-
-    const slot: SendSlot = mediaConnection.createSendSlot(mediaType, active);
-
-    this.slots.set(mediaType, slot);
-
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->createSlot#Created slot for ${mediaType} with active ${active}`
-    );
-
-    return slot;
-  }
-
-  /**
-   * This method is used to retrieve the sendSlot for the given mediaType
-   * @param {MediaType} mediaType of which the slot needs to be retrieved
-   * @returns {SendSlot}
-   */
-  public getSlot(mediaType: MediaType): SendSlot {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    return slot;
-  }
-
-  /**
-   * This method publishes the given stream to the sendSlot for the given mediaType
-   * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
-   * @param {LocalStream} stream LocalStream to be published
-   * @returns {Promise<void>}
-   */
-  public async publishStream(mediaType: MediaType, stream: LocalStream): Promise<void> {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    await slot.publishStream(stream);
-
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->publishStream#Published stream for ${mediaType} and stream with label ${stream.label} and muted ${stream.muted}`
-    );
-  }
-
-  /**
-   * This method unpublishes the stream from the sendSlot of the given mediaType
-   * @param {MediaType} mediaType MediaType of the sendSlot from which a stream needs to be unpublished (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
-   * @returns {Promise<void>}
-   */
-  public async unpublishStream(mediaType: MediaType): Promise<void> {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    await slot.unpublishStream();
-
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->unpublishStream#Unpublished stream for ${mediaType}`
-    );
-  }
-
-  /**
-   * This method is used to set the active state of the sendSlot for the given mediaType
-   * @param {MediaType} mediaType The MediaType of the sendSlot for which the active state needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
-   * @param {boolean} active The boolean to set the active state of the sendSlot. Default is true
-   * @returns {void}
-   */
-  public setActive(mediaType: MediaType, active = true): void {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    slot.active = active;
-
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->setActive#Set active for ${mediaType} to ${active}`
-    );
-  }
-
-  /**
-   * This method is used to set the codec parameters for the sendSlot of the given mediaType
-   * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
-   * @param {Object} codecParameters
-   * @returns {Promise<void>}
-   */
-  public async setCodecParameters(
-    mediaType: MediaType,
-    codecParameters: {
-      [key: string]: string | undefined; // As per ts-sdp undefined is considered as a valid value to be used for codec parameters
-    }
-  ): Promise<void> {
-    // These codec parameter changes underneath are SDP value changes that are taken care by WCME automatically. So no need for any change in streams from the web sdk side
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    await slot.setCodecParameters(codecParameters);
-
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->setCodecParameters#Set codec parameters for ${mediaType} to ${codecParameters}`
-    );
-  }
-
-  /**
-   * This method is used to delete the codec parameters for the sendSlot of the given mediaType
-   * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
-   * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
-   * @returns {Promise<void>}
-   */
-  public async deleteCodecParameters(mediaType: MediaType, parameters: string[]): Promise<void> {
-    const slot = this.slots.get(mediaType);
-
-    if (!slot) {
-      throw new Error(`Slot for ${mediaType} does not exist`);
-    }
-
-    await slot.deleteCodecParameters(parameters);
-
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->deleteCodecParameters#Deleted the following codec parameters -> ${parameters} for ${mediaType}`
-    );
-  }
-
-  /**
-   * This method is used to reset the SendSlotsManager by deleting all the sendSlots
-   * @returns {undefined}
-   */
-  public reset(): void {
-    this.slots.clear();
-  }
-}

package/src/reachability/clusterReachability.ts

@@ -1,320 +0,0 @@
-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;
-  }
-}

package/src/reachability/util.ts

@@ -1,24 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-/**
- * Converts a stun url to a turn url
- *
- * @param {string} stunUrl url of a stun server
- * @param {'tcp'|'udp'} protocol what protocol to use for the turn server
- * @returns {string} url of a turn server
- */
-export function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp') {
-  // stunUrl looks like this: "stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004"
-  // and we need it to be like this: "turn:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004?transport=tcp"
-  const url = new URL(stunUrl);
-
-  if (url.protocol !== 'stun:') {
-    throw new Error(`Not a STUN URL: ${stunUrl}`);
-  }
-
-  url.protocol = 'turn:';
-  if (protocol === 'tcp') {
-    url.searchParams.append('transport', 'tcp');
-  }
-
-  return url.toString();
-}

package/src/reactions/constants.ts

@@ -1,4 +0,0 @@
-// eslint-disable-next-line import/prefer-default-export
-export const REACTION_RELAY_TYPES = {
-  REACTION: 'react',
-} as const;

package/src/rtcMetrics/constants.ts

@@ -1,3 +0,0 @@
-const RTC_METRICS = {APP_ID: 'FFB51ED5-4319-4C55-8303-B1F2FCCDE231'};
-
-export {RTC_METRICS as default};

package/src/rtcMetrics/index.ts

@@ -1,124 +0,0 @@
-/* eslint-disable class-methods-use-this */
-import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
-import RTC_METRICS from './constants';
-
-/**
- * Rtc Metrics
- */
-export default class RtcMetrics {
-  /**
-   * Array of MetricData items to be sent to the metrics service.
-   */
-  metricsQueue = [];
-
-  intervalId: number;
-
-  webex: any;
-
-  meetingId: string;
-
-  correlationId: string;
-
-  /**
-   * Initialize the interval.
-   *
-   * @param {object} webex - The main `webex` object.
-   * @param {string} meetingId - The meeting id.
-   * @param {string} correlationId - The correlation id.
-   */
-  constructor(webex, meetingId, correlationId) {
-    // `window` is used to prevent typescript from returning a NodeJS.Timer.
-    this.intervalId = window.setInterval(this.sendMetricsInQueue.bind(this), 30 * 1000);
-    this.meetingId = meetingId;
-    this.webex = webex;
-    this.correlationId = correlationId;
-    // Send the first set of metrics at 5 seconds in the case of a user leaving the call shortly after joining.
-    setTimeout(this.sendMetricsInQueue.bind(this), 5 * 1000);
-  }
-
-  /**
-   * Check to see if the metrics queue has any items.
-   *
-   * @returns {void}
-   */
-  public sendMetricsInQueue() {
-    if (this.metricsQueue.length) {
-      this.sendMetrics();
-      this.metricsQueue = [];
-    }
-  }
-
-  /**
-   * Add metrics items to the metrics queue.
-   *
-   * @param {object} data - An object with a payload array of metrics items.
-   *
-   * @returns {void}
-   */
-  addMetrics(data) {
-    if (data.payload.length) {
-      if (data.name === 'stats-report') {
-        data.payload = data.payload.map(this.anonymizeIp);
-      }
-      this.metricsQueue.push(data);
-    }
-  }
-
-  /**
-   * Clear the metrics interval.
-   *
-   * @returns {void}
-   */
-  closeMetrics() {
-    this.sendMetricsInQueue();
-    clearInterval(this.intervalId);
-  }
-
-  /**
-   * Anonymize IP addresses.
-   *
-   * @param {array} stats - An RTCStatsReport organized into an array of strings.
-   * @returns {string}
-   */
-  anonymizeIp(stats: string): string {
-    const data = JSON.parse(stats);
-    // on local and remote candidates, anonymize the last 4 bits.
-    if (data.type === 'local-candidate' || data.type === 'remote-candidate') {
-      data.ip = CallDiagnosticUtils.anonymizeIPAddress(data.ip) || undefined;
-      data.address = CallDiagnosticUtils.anonymizeIPAddress(data.address) || undefined;
-      data.relatedAddress =
-        CallDiagnosticUtils.anonymizeIPAddress(data.relatedAddress) || undefined;
-    }
-
-    return JSON.stringify(data);
-  }
-
-  /**
-   * Send metrics to the metrics service.
-   *
-   * @returns {void}
-   */
-  private sendMetrics() {
-    this.webex.request({
-      method: 'POST',
-      service: 'unifiedTelemetry',
-      resource: 'metric/v2',
-      headers: {
-        type: 'webrtcMedia',
-        appId: RTC_METRICS.APP_ID,
-      },
-      body: {
-        metrics: [
-          {
-            type: 'webrtc',
-            version: '1.0.1',
-            userId: this.webex.internal.device.userId,
-            meetingId: this.meetingId,
-            correlationId: this.correlationId,
-            data: this.metricsQueue,
-          },
-        ],
-      },
-    });
-  }
-}

package/src/webinar/collection.ts

@@ -1,31 +0,0 @@
-/*!
- * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
- */
-
-import {MEETINGS} from '../constants';
-
-class WebinarCollection {
-  webinarInfo: any;
-
-  namespace = MEETINGS;
-
-  mainIndex = 'sessionId';
-
-  constructor() {
-    this.webinarInfo = {};
-  }
-
-  set(id, info) {
-    this.webinarInfo[id] = info;
-  }
-
-  /**
-   * @param {String} id
-   * @returns {Member}
-   */
-  get(id: string) {
-    return this.webinarInfo[id];
-  }
-}
-
-export default WebinarCollection;