@webex/plugin-meetings 3.7.0 → 3.8.0-next.2

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

@@ -2,42 +2,11 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import { Defer } from '@webex/common';
+import { IP_VERSION } from '../constants';
 import ReachabilityRequest, { ClusterList } from './request';
-import { ClusterReachability, ClusterReachabilityResult } from './clusterReachability';
+import { ClusterReachabilityResult, ClientMediaPreferences, ReachabilityMetrics, ReachabilityReportV0, ReachabilityReportV1, ReachabilityResults, ReachabilityResultsForBackend, GetClustersTrigger } from './reachability.types';
+import { ClusterReachability } from './clusterReachability';
 import EventsScope from '../common/events/events-scope';
-export type ReachabilityMetrics = {
-    reachability_public_udp_success: number;
-    reachability_public_udp_failed: number;
-    reachability_public_tcp_success: number;
-    reachability_public_tcp_failed: number;
-    reachability_public_xtls_success: number;
-    reachability_public_xtls_failed: number;
-    reachability_vmn_udp_success: number;
-    reachability_vmn_udp_failed: number;
-    reachability_vmn_tcp_success: number;
-    reachability_vmn_tcp_failed: number;
-    reachability_vmn_xtls_success: number;
-    reachability_vmn_xtls_failed: number;
-};
-/**
- * This is the type that matches what backend expects us to send to them. It is a bit weird, because
- * it uses strings instead of booleans and numbers, but that's what they require.
- */
-export type TransportResultForBackend = {
-    reachable?: 'true' | 'false';
-    latencyInMilliseconds?: string;
-    clientMediaIPs?: string[];
-    untested?: 'true';
-};
-export type ReachabilityResultForBackend = {
-    udp: TransportResultForBackend;
-    tcp: TransportResultForBackend;
-    xtls: TransportResultForBackend;
-};
-export type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;
-export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
-    isVideoMesh?: boolean;
-}>;
 /**
  * @class Reachability
  * @export
@@ -49,6 +18,8 @@ export default class Reachability extends EventsScope {
     clusterReachability: {
         [key: string]: ClusterReachability;
     };
+    minRequiredClusters?: number;
+    orpheusApiVersion?: number;
     reachabilityDefer?: Defer;
     vmnTimer?: ReturnType<typeof setTimeout>;
     publicCloudTimer?: ReturnType<typeof setTimeout>;
@@ -73,6 +44,8 @@ export default class Reachability extends EventsScope {
             xtls: number;
         };
     };
+    startTime: any;
+    totalDuration: any;
     protected lastTrigger?: string;
     /**
      * Creates an instance of Reachability.
@@ -82,11 +55,13 @@ export default class Reachability extends EventsScope {
     constructor(webex: object);
     /**
      * Fetches the list of media clusters from the backend
+     * @param {string} trigger - explains the reason for starting reachability, used by Orpheus
+     * @param {Object} previousReport - last reachability report
      * @param {boolean} isRetry
      * @private
      * @returns {Promise<{clusters: ClusterList, joinCookie: any}>}
      */
-    getClusters(isRetry?: boolean): Promise<{
+    getClusters(trigger: GetClustersTrigger, previousReport?: any, isRetry?: boolean): Promise<{
         clusters: ClusterList;
         joinCookie: any;
     }>;
@@ -98,6 +73,39 @@ export default class Reachability extends EventsScope {
      * @memberof Reachability
      */
     gatherReachability(trigger: string): Promise<ReachabilityResults>;
+    /**
+     * Gets the last join cookie we got from Orpheus
+     *
+     * @returns {Promise<Object>} join cookie
+     */
+    getJoinCookie(): Promise<any>;
+    /**
+     * Returns the reachability report that needs to be attached to the ROAP messages
+     * that we send to the backend.
+     *
+     * @returns {Promise<Object>}
+     */
+    getReachabilityReport(): Promise<{
+        joinCookie: any;
+        reachability?: ReachabilityReportV1;
+    } | {
+        reachability: ReachabilityReportV0;
+    }>;
+    /**
+     * This method is called when we don't succeed in reaching the minimum number of clusters
+     * required by Orpheus. It sends the results to Orpheus and gets a new list that it tries to reach again.
+     * @returns {Promise<ReachabilityResults>} reachability results
+     * @public
+     * @memberof Reachability
+     */
+    gatherReachabilityFallback(): Promise<void>;
+    /**
+     * Stops all reachability checks that are in progress
+     * @public
+     * @memberof Reachability
+     * @returns {void}
+     */
+    stopReachability(): void;
     /**
      * Returns statistics about last reachability results. The returned value is an object
      * with a flat list of properties so that it can be easily sent with metrics
@@ -142,6 +150,13 @@ export default class Reachability extends EventsScope {
      * @memberof Reachability
      */
     private getUnreachableClusters;
+    /**
+     * Gets the number of reachable clusters from last run reachability check
+     * @returns {number} reachable clusters count
+     * @private
+     * @memberof Reachability
+     */
+    private getNumberOfReachableClusters;
     /**
      * Make a log of unreachable clusters.
      * @returns {undefined}
@@ -165,6 +180,7 @@ export default class Reachability extends EventsScope {
     private areAllResultsReady;
     /**
      * Resolves the promise returned by gatherReachability() method
+     * @param {boolean} checkMinRequiredClusters - if true, it will check if we have reached the minimum required clusters and do a fallback if needed
      * @returns {void}
      */
     private resolveReachabilityPromise;
@@ -192,9 +208,10 @@ export default class Reachability extends EventsScope {
     /**
      * Sends a metric with all the statistics about how long reachability took
      *
+     * @param {boolean} aborted true if the reachability checks were aborted
      * @returns {void}
      */
-    protected sendMetric(): Promise<void>;
+    protected sendMetric(aborted?: boolean): Promise<void>;
     /**
      * Starts all the timers used for various timeouts
      *
@@ -214,10 +231,40 @@ export default class Reachability extends EventsScope {
      * @returns {void}
      */
     private resetResultCounters;
+    /**
+     * Clears the timer
+     *
+     * @param {string} timer name of the timer to clear
+     * @returns {void}
+     */
+    private clearTimer;
+    /**
+     * Aborts current checks that are in progress
+     *
+     * @returns {void}
+     */
+    private abortCurrentChecks;
     /**
      * Performs reachability checks for all clusters
      * @param {ClusterList} clusterList
      * @returns {Promise<void>} promise that's resolved as soon as the checks are started
      */
     private performReachabilityChecks;
+    /**
+     * Returns the clientMediaPreferences object that needs to be sent to the backend
+     * when joining a meeting
+     *
+     * @param {boolean} isMultistream
+     * @param {IP_VERSION} ipver
+     * @returns {Object}
+     */
+    getClientMediaPreferences(isMultistream: boolean, ipver?: IP_VERSION): Promise<ClientMediaPreferences>;
+    /**
+     * Returns the reachability report that needs to be attached to the ROAP messages
+     * that we send to the backend.
+     * It may return undefined, if reachability is not needed to be attached to ROAP messages (that's the case for v1 or Orpheus API)
+     *
+     * @returns {Promise<ReachabilityReportV0>} object that needs to be attached to Roap messages
+     */
+    getReachabilityReportToAttachToRoap(): Promise<ReachabilityReportV0 | undefined>;
 }

package/dist/types/reachability/reachability.types.d.ts

@@ -0,0 +1,64 @@
+import { IP_VERSION } from '../constants';
+export type TransportResult = {
+    result: 'reachable' | 'unreachable' | 'untested';
+    latencyInMilliseconds?: number;
+    clientMediaIPs?: string[];
+};
+export type ClusterReachabilityResult = {
+    udp: TransportResult;
+    tcp: TransportResult;
+    xtls: TransportResult;
+};
+export type ReachabilityMetrics = {
+    reachability_public_udp_success: number;
+    reachability_public_udp_failed: number;
+    reachability_public_tcp_success: number;
+    reachability_public_tcp_failed: number;
+    reachability_public_xtls_success: number;
+    reachability_public_xtls_failed: number;
+    reachability_vmn_udp_success: number;
+    reachability_vmn_udp_failed: number;
+    reachability_vmn_tcp_success: number;
+    reachability_vmn_tcp_failed: number;
+    reachability_vmn_xtls_success: number;
+    reachability_vmn_xtls_failed: number;
+};
+/**
+ * This is the type that matches what backend expects us to send to them. It is a bit weird, because
+ * it uses strings instead of booleans and numbers, but that's what they require.
+ */
+export type TransportResultForBackend = {
+    reachable?: 'true' | 'false';
+    latencyInMilliseconds?: string;
+    clientMediaIPs?: string[];
+    untested?: 'true';
+};
+export type ReachabilityResultForBackend = {
+    udp: TransportResultForBackend;
+    tcp: TransportResultForBackend;
+    xtls: TransportResultForBackend;
+};
+export type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;
+export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
+    isVideoMesh?: boolean;
+}>;
+export type ReachabilityReportV0 = ReachabilityResultsForBackend;
+export type ReachabilityReportV1 = {
+    version: 1;
+    result: {
+        usedDiscoveryOptions: {
+            'early-call-min-clusters': number;
+        };
+        metrics: {
+            'total-duration-ms': number;
+        };
+        tests: Record<string, ReachabilityResultForBackend>;
+    };
+};
+export interface ClientMediaPreferences {
+    ipver: IP_VERSION;
+    joinCookie: any;
+    preferTranscoding: boolean;
+    reachability?: ReachabilityReportV1;
+}
+export type GetClustersTrigger = 'startup' | 'early-call/no-min-reached';

package/dist/types/reachability/request.d.ts

@@ -1,4 +1,5 @@
 import { IP_VERSION } from '../constants';
+import { GetClustersTrigger } from './reachability.types';
 export interface ClusterNode {
     isVideoMesh: boolean;
     udp: Array<string>;
@@ -22,12 +23,15 @@ declare class ReachabilityRequest {
     /**
      * Gets the cluster information
      *
+     * @param {string} trigger that's passed to Orpheus
      * @param {IP_VERSION} ipVersion information about current ip network we're on
+     * @param {Object} previousReport last reachability result
      * @returns {Promise}
      */
-    getClusters: (ipVersion?: IP_VERSION) => Promise<{
+    getClusters: (trigger: GetClustersTrigger, ipVersion?: IP_VERSION, previousReport?: any) => Promise<{
         clusters: ClusterList;
         joinCookie: any;
+        discoveryOptions?: Record<string, any>;
     }>;
     /**
      * gets remote SDP For Clusters

package/dist/types/recording-controller/enums.d.ts

@@ -1,7 +1,10 @@
-declare enum RecordingAction {
+export declare enum RecordingAction {
     Start = "Start",
     Stop = "Stop",
     Pause = "Pause",
     Resume = "Resume"
 }
-export default RecordingAction;
+export declare enum RecordingType {
+    Premise = "premise",
+    Cloud = "cloud"
+}

package/dist/types/recording-controller/index.d.ts

@@ -161,6 +161,7 @@ export default class RecordingController {
     private extract;
     /**
      * @param {RecordingAction} action
+     * @param {RecordingType} recordingType
      * @private
      * @memberof RecordingController
      * @returns {Promise}

package/dist/types/recording-controller/util.d.ts

@@ -1,10 +1,11 @@
 import { SELF_POLICY } from '../constants';
-import RecordingAction from './enums';
+import { RecordingAction } from './enums';
 declare const _default: {
     canUserStart: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     canUserPause: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     canUserResume: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     canUserStop: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    isPremiseRecordingEnabled: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     deriveRecordingStates: (action: RecordingAction) => {
         recording: boolean;
         paused: boolean;

package/dist/types/roap/request.d.ts

@@ -1,19 +1,9 @@
 import { StatelessWebexPlugin } from '@webex/webex-core';
-import { IP_VERSION } from '../constants';
 import { LocusMediaRequest } from '../meeting/locusMediaRequest';
 /**
  * @class RoapRequest
  */
 export default class RoapRequest extends StatelessWebexPlugin {
-    /**
-     * Returns reachability data.
-     * @param {Object} localSdp
-     * @returns {Object}
-     */
-    attachReachabilityData(localSdp: any): Promise<{
-        localSdp: any;
-        joinCookie: any;
-    }>;
     /**
      * Sends a ROAP message
      * @param {Object} options
@@ -22,15 +12,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
      * @param {String} options.mediaId
      * @param {String} options.correlationId
      * @param {String} options.meetingId
-     * @param {IP_VERSION} options.ipVersion only required for offers
      * @returns {Promise} returns the response/failure of the request
      */
     sendRoap(options: {
         roapMessage: any;
         locusSelfUrl: string;
         mediaId: string;
-        meetingId: string;
-        ipVersion?: IP_VERSION;
+        isMultistream: boolean;
         locusMediaRequest?: LocusMediaRequest;
     }): Promise<{
         mediaConnections: any;