@webex/calling 3.12.0-next.3 → 3.12.0-next.30

package/dist/module/common/Utils.js

@@ -18,18 +18,32 @@ export function filterMobiusUris(mobiusServers, defaultMobiusUrl) {
     };
     const urisArrayPrimary = [];
     const urisArrayBackup = [];
+    const wssArrayPrimary = [];
+    const wssArrayBackup = [];
     if (mobiusServers?.primary?.uris) {
         log.info('Adding Primary uris', logContext);
         for (const uri of mobiusServers.primary.uris) {
             urisArrayPrimary.push(`${uri}${URL_ENDPOINT}`);
         }
     }
+    if (mobiusServers?.primary?.wss) {
+        log.info('Adding Primary wss uris', logContext);
+        for (const wssUri of mobiusServers.primary.wss) {
+            wssArrayPrimary.push(wssUri);
+        }
+    }
     if (mobiusServers?.backup?.uris) {
         log.info('Adding Backup uris', logContext);
         for (const uri of mobiusServers.backup.uris) {
             urisArrayBackup.push(`${uri}${URL_ENDPOINT}`);
         }
     }
+    if (mobiusServers?.backup?.wss) {
+        log.info('Adding Backup wss uris', logContext);
+        for (const wssUri of mobiusServers.backup.wss) {
+            wssArrayBackup.push(wssUri);
+        }
+    }
     log.info('Adding Default uri', logContext);
     if (!urisArrayPrimary.length && !urisArrayBackup.length) {
         urisArrayPrimary.push(`${defaultMobiusUrl}${URL_ENDPOINT}`);
@@ -39,6 +53,8 @@ export function filterMobiusUris(mobiusServers, defaultMobiusUrl) {
     }
     const primaryUris = [];
     const backupUris = [];
+    const primaryWss = [];
+    const backupWss = [];
     for (let i = 0; i < urisArrayPrimary.length; i += 1) {
         if (primaryUris.indexOf(urisArrayPrimary[i]) === -1) {
             primaryUris.push(urisArrayPrimary[i]);
@@ -49,7 +65,17 @@ export function filterMobiusUris(mobiusServers, defaultMobiusUrl) {
             backupUris.push(urisArrayBackup[i]);
         }
     }
-    return { primary: primaryUris, backup: backupUris };
+    for (let i = 0; i < wssArrayPrimary.length; i += 1) {
+        if (primaryWss.indexOf(wssArrayPrimary[i]) === -1) {
+            primaryWss.push(wssArrayPrimary[i]);
+        }
+    }
+    for (let i = 0; i < wssArrayBackup.length; i += 1) {
+        if (backupWss.indexOf(wssArrayBackup[i]) === -1) {
+            backupWss.push(wssArrayBackup[i]);
+        }
+    }
+    return { primary: primaryUris, backup: backupUris, primaryWss, backupWss };
 }
 function updateCallErrorContext(errContext, type, message, correlationId, callError) {
     const errObj = {};
@@ -74,12 +100,14 @@ function updateErrorContext(errContext, type, message, clientError) {
     errObj.message = message;
     clientError.setError(errObj);
 }
-export function emitFinalFailure(emitterCb, loggerContext) {
-    const clientError = createLineError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
-    updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, 'An unknown error occurred. Wait a moment and try again. Please contact the administrator if the problem persists.', RegistrationStatus.INACTIVE, clientError);
+export function emitFinalFailure(emitterCb, loggerContext, message) {
+    const clientError = createLineError(message || '', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
+    updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, message ||
+        'An unknown error occurred. Wait a moment and try again. Please contact the administrator if the problem persists.', RegistrationStatus.INACTIVE, clientError);
     emitterCb(clientError);
 }
-export async function handleRegistrationErrors(err, emitterCb, loggerContext, retry429Cb, restoreRegCb) {
+export async function handleRegistrationErrors(err, emitterCb, loggerContext, retry429Cb, restoreRegCb, serverCount = 1) {
+    let shouldDisconnect = false;
     const lineError = createLineError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
     const errorCode = Number(err.statusCode);
     let finalError = false;
@@ -90,6 +118,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`400 Bad Request`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.BAD_REQUEST, 'Invalid input. Please verify the required parameters, sign out and then sign back in with the valid data', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.UNAUTHORIZED: {
@@ -97,6 +126,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`401 Unauthorized`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.TOKEN_ERROR, 'User is unauthorized due to an expired token. Sign out, then sign back in.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.DEVICE_NOT_FOUND: {
@@ -104,6 +134,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`404 Device Not Found`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.NOT_FOUND, 'Webex Calling is unable to find your device. Sign out, then sign back in', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.TOO_MANY_REQUESTS: {
@@ -112,20 +143,23 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             const caller = loggerContext.method || 'handleErrors';
             if (retry429Cb && err.headers) {
                 const retryAfter = Number(err.headers['retry-after']);
-                retry429Cb(retryAfter, caller);
+                await retry429Cb(retryAfter, caller);
             }
+            shouldDisconnect = false;
             break;
         }
         case ERROR_CODE.INTERNAL_SERVER_ERROR: {
             log.warn(`500 Internal Server Error`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.SERVER_ERROR, 'An unknown error occurred while placing the request. Wait a moment and try again.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.SERVICE_UNAVAILABLE: {
             log.warn(`503 Service Unavailable`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, 'An error occurred on the server while processing the request. Wait a moment and try again.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.FORBIDDEN: {
@@ -135,7 +169,8 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                 log.warn('Error response has no body, throwing default error', loggerContext);
                 updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, 'An unauthorized action has been received. This action has been blocked. Please contact the administrator if this persists.', RegistrationStatus.INACTIVE, lineError);
                 emitterCb(lineError, finalError);
-                return finalError;
+                shouldDisconnect = serverCount > 1;
+                return { finalError, shouldDisconnect };
             }
             const code = Number(errorBody.errorCode);
             log.warn(`Error code found : ${code}`, loggerContext);
@@ -147,6 +182,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                         const caller = loggerContext.method || 'handleErrors';
                         await restoreRegCb(errorBody, caller);
                     }
+                    shouldDisconnect = false;
                     break;
                 }
                 case DEVICE_ERROR_CODE.DEVICE_CREATION_DISABLED: {
@@ -155,6 +191,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, true);
+                    shouldDisconnect = true;
                     break;
                 }
                 case DEVICE_ERROR_CODE.DEVICE_CREATION_FAILED: {
@@ -162,6 +199,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, finalError);
+                    shouldDisconnect = serverCount > 1;
                     break;
                 }
                 default: {
@@ -169,6 +207,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, finalError);
+                    shouldDisconnect = serverCount > 1;
                 }
             }
             break;
@@ -177,9 +216,10 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             updateLineErrorContext(loggerContext, ERROR_TYPE.DEFAULT, 'Unknown error', RegistrationStatus.INACTIVE, lineError);
             log.warn(`Unknown Error`, loggerContext);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
         }
     }
-    return finalError;
+    return { finalError, shouldDisconnect };
 }
 export async function handleCallingClientErrors(err, emitterCb, loggerContext) {
     const clientError = createClientError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
@@ -851,7 +891,7 @@ export function inferIdFromUuid(id, decodeType) {
 function isValidServiceIndicator(indicator) {
     return Object.values(ServiceIndicator).some((v) => v === indicator);
 }
-function isValidServiceDomain(serviceData) {
+export function isValidServiceDomain(serviceData) {
     const regexp = /^[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,6}$/i;
     const { domain } = serviceData;
     if (!domain) {
@@ -866,9 +906,6 @@ export function validateServiceData(serviceData) {
     if (!isValidServiceIndicator(serviceData.indicator)) {
         throw new Error(`Invalid service indicator, Allowed values are: ${formattedValues}`);
     }
-    if (!isValidServiceDomain(serviceData)) {
-        throw new Error('Invalid service domain.');
-    }
 }
 export function modifySdpForIPv4(sdp) {
     try {
@@ -941,3 +978,6 @@ export async function uploadLogs(metaData = {}, throwError = false) {
         return undefined;
     }
 }
+export function normalizeMobiusUris(urls) {
+    return urls.map((url) => (!url.endsWith('/') ? `${url}/` : url));
+}

package/dist/module/common/testUtil.js

@@ -1,4 +1,5 @@
 import platform from 'platform';
+import { CISCO_DEVICE_URL } from '../CallingClient/constants';
 const MediaSDKMock = jest.createMockFromModule('@webex/internal-media-core');
 export function getTestUtilsWebex() {
     return {
@@ -34,6 +35,9 @@ export function getTestUtilsWebex() {
                     entitlement: {
                         models: [{ _values: { key: 'bc-sp-standard' } }],
                     },
+                    developer: {
+                        get: jest.fn().mockReturnValue({ value: false }),
+                    },
                 },
             },
             encryption: {
@@ -106,7 +110,7 @@ export const mockCallingClient = {
 export const getMockRequestTemplate = () => {
     return {
         headers: {
-            'cisco-device-url': 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/c5ae3b86-1bb7-40f1-a6a9-c296ee7e61d5',
+            [CISCO_DEVICE_URL]: 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/c5ae3b86-1bb7-40f1-a6a9-c296ee7e61d5',
             'spark-user-agent': 'webex-calling/beta',
         },
         service: 'mobius',

package/dist/module/common/types.js

@@ -62,6 +62,8 @@ export var WorkerMessageType;
 (function (WorkerMessageType) {
     WorkerMessageType["START_KEEPALIVE"] = "START_KEEPALIVE";
     WorkerMessageType["CLEAR_KEEPALIVE"] = "CLEAR_KEEPALIVE";
+    WorkerMessageType["SEND_KEEPALIVE"] = "SEND_KEEPALIVE";
+    WorkerMessageType["KEEPALIVE_RESULT"] = "KEEPALIVE_RESULT";
     WorkerMessageType["KEEPALIVE_SUCCESS"] = "KEEPALIVE_SUCCESS";
     WorkerMessageType["KEEPALIVE_FAILURE"] = "KEEPALIVE_FAILURE";
 })(WorkerMessageType || (WorkerMessageType = {}));

package/dist/module/mobius-socket/config.js

@@ -0,0 +1,15 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+const mobiusSocketConfig = {
+    wssResponseTimeout: 10000,
+    backoffTimeMax: 32000,
+    backoffTimeReset: 1000,
+    initialConnectionMaxRetries: 0,
+    maxRetries: 0,
+    forceCloseDelay: 2000,
+    dedupCacheMaxSize: 1000,
+};
+export default {
+    mobiusSocket: mobiusSocketConfig,
+};

package/dist/module/mobius-socket/errors.js

@@ -0,0 +1,64 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import { Exception } from '@webex/common';
+export class ConnectionError extends Exception {
+    static defaultMessage = 'Failed to connect to socket';
+    code;
+    reason;
+    constructor(event) {
+        super(event);
+    }
+    parse(event = {}) {
+        Object.defineProperties(this, {
+            code: {
+                value: event.code,
+            },
+            reason: {
+                value: event.reason,
+            },
+        });
+        return event.reason;
+    }
+}
+export class UnknownResponse extends ConnectionError {
+    static defaultMessage = 'UnknownResponse is produced by IE when we receive a 4XXX. You probably want to treat this like a NotFound';
+    constructor(event) {
+        super(event);
+    }
+}
+export class BadRequest extends ConnectionError {
+    static defaultMessage = 'BadRequest usually implies an attempt to use service account credentials';
+    constructor(event) {
+        super(event);
+    }
+}
+export class NotAuthorized extends ConnectionError {
+    static defaultMessage = 'Please refresh your access token';
+    constructor(event) {
+        super(event);
+    }
+}
+export class Forbidden extends ConnectionError {
+    static defaultMessage = 'Forbidden usually implies these credentials are not entitled for Webex';
+    constructor(event) {
+        super(event);
+    }
+}
+export function createWssResponseError(response, statusCode, statusMessage) {
+    const error = new Error(statusMessage || `Mobius websocket request failed with status ${statusCode || 'unknown'}`);
+    error.name = 'MobiusSocketResponseError';
+    error.statusCode = statusCode;
+    error.statusMessage = statusMessage;
+    error.response = response;
+    error.trackingId = response?.trackingId;
+    return error;
+}
+export function createTimeoutError(request) {
+    const errorPayload = {
+        type: 'response_event',
+        subtype: request.type,
+        trackingId: request.trackingId,
+    };
+    return createWssResponseError(errorPayload, 408, 'Mobius websocket response timed out');
+}

package/dist/module/mobius-socket/index.js

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import '@webex/internal-plugin-device';
+import '@webex/internal-plugin-feature';
+import '@webex/internal-plugin-metrics';
+import MobiusSocket from './mobius-socket';
+import config from './config';
+let mobiusSocketInstance;
+export function getMobiusSocketInstance(webex, mobiusSocketConfig) {
+    if (mobiusSocketInstance) {
+        return mobiusSocketInstance;
+    }
+    mobiusSocketInstance = new MobiusSocket(webex, {
+        ...config.mobiusSocket,
+        ...mobiusSocketConfig,
+    });
+    return mobiusSocketInstance;
+}
+export function resetMobiusSocketInstance() {
+    mobiusSocketInstance = undefined;
+}
+export default MobiusSocket;
+export { MobiusSocket };