@webex/calling 3.10.0-next.2 → 3.10.0-next.21

package/dist/module/CallingClient/CallingClient.js

@@ -9,7 +9,7 @@ import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../E
 import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, } from '../common/types';
 import log from '../Logger';
 import { getCallManager } from './calling/callManager';
-import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, MOBIUS_US_PROD, MOBIUS_EU_PROD, MOBIUS_US_INT, MOBIUS_EU_INT, METHODS, NETWORK_FLAP_TIMEOUT, } from './constants';
+import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, METHODS, NETWORK_FLAP_TIMEOUT, } from './constants';
 import Line from './line';
 import { METRIC_EVENT, REG_ACTION, METRIC_TYPE, CONNECTION_ACTION, MOBIUS_SERVER_ACTION, } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
@@ -65,28 +65,7 @@ export class CallingClient extends Eventing {
         this.mediaEngine.setLogger(adaptedLogger);
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
-        let mobiusServiceHost = '';
-        try {
-            mobiusServiceHost = new URL(this.webex.internal.services._serviceUrls.mobius).host;
-        }
-        catch (error) {
-            log.warn(`Failed to parse mobius service URL`, {
-                file: CALLING_CLIENT_FILE,
-                method: this.constructor.name,
-            });
-        }
-        if (this.webex.internal.services._hostCatalog) {
-            this.mobiusClusters =
-                (mobiusServiceHost && this.webex.internal.services._hostCatalog[mobiusServiceHost]) ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_US_PROD] ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_EU_PROD] ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_US_INT] ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_EU_INT];
-        }
-        else {
-            const mobiusObject = this.webex.internal.services._services.find((item) => item.serviceName === 'mobius');
-            this.mobiusClusters = [mobiusObject.serviceUrls[0].baseUrl];
-        }
+        this.mobiusClusters = this.webex.internal.services.getMobiusClusters();
         this.mobiusHost = '';
         this.registerSessionsListener();
         this.registerCallsClearedListener();
@@ -237,67 +216,38 @@ export class CallingClient extends Eventing {
             method: METHODS.GET_CLIENT_REGION_INFO,
         });
         const regionInfo = {};
-        for (const mobius of this.mobiusClusters) {
-            if (mobius.host) {
-                this.mobiusHost = `https://${mobius.host}${API_V1}`;
-            }
-            else {
-                this.mobiusHost = mobius;
-            }
-            try {
-                const temp = await this.webex.request({
-                    uri: `${this.mobiusHost}${URL_ENDPOINT}${IP_ENDPOINT}`,
-                    method: HTTP_METHODS.GET,
-                    headers: {
-                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
-                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                    },
-                    service: ALLOWED_SERVICES.MOBIUS,
-                });
-                log.log(`Response trackingId: ${temp?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                });
-                const myIP = temp.body.ipv4;
-                const response = await this.webex.request({
-                    uri: `${DISCOVERY_URL}/${myIP}`,
-                    method: HTTP_METHODS.GET,
-                    addAuthHeader: false,
-                    headers: {
-                        [SPARK_USER_AGENT]: null,
-                    },
-                });
-                log.log(`Response trackingId: ${response?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                });
-                const clientRegionInfo = response.body;
-                regionInfo.clientRegion = clientRegionInfo?.clientRegion
-                    ? clientRegionInfo.clientRegion
-                    : '';
-                regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
-                log.log(`Successfully fetched Client region info: ${regionInfo.clientRegion}, countryCode: ${regionInfo.countryCode}, and response trackingid: ${response?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                });
-                this.metricManager.submitRegionInfoMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.REGION_INFO, METRIC_TYPE.BEHAVIORAL, this.mobiusHost, clientRegionInfo.clientRegion, clientRegionInfo.countryCode, response?.headers?.trackingid ?? '');
-                break;
-            }
-            catch (err) {
-                log.error(`Failed to get client region info: ${JSON.stringify(err)}`, {
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                    file: CALLING_CLIENT_FILE,
-                });
-                abort = await handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
-                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
-                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-                regionInfo.clientRegion = '';
-                regionInfo.countryCode = '';
-                if (abort) {
-                    await uploadLogs();
-                    return regionInfo;
-                }
+        try {
+            const response = await this.webex.request({
+                uri: `${DISCOVERY_URL}`,
+                method: HTTP_METHODS.GET,
+                addAuthHeader: false,
+                headers: {
+                    [SPARK_USER_AGENT]: null,
+                },
+            });
+            const clientRegionInfo = response.body;
+            regionInfo.clientRegion = clientRegionInfo?.clientRegion || '';
+            regionInfo.countryCode = clientRegionInfo?.countryCode || '';
+            log.log(`Successfully fetched Client region info: ${regionInfo.clientRegion}, countryCode: ${regionInfo.countryCode}, and response trackingid: ${response?.headers?.trackingid}`, {
+                file: CALLING_CLIENT_FILE,
+                method: METHODS.GET_CLIENT_REGION_INFO,
+            });
+            this.metricManager.submitRegionInfoMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.REGION_INFO, METRIC_TYPE.BEHAVIORAL, this.mobiusHost, clientRegionInfo.clientRegion, clientRegionInfo.countryCode, response?.headers?.trackingid ?? '');
+        }
+        catch (err) {
+            log.error(`Failed to get client region info: ${JSON.stringify(err)}`, {
+                method: METHODS.GET_CLIENT_REGION_INFO,
+                file: CALLING_CLIENT_FILE,
+            });
+            abort = await handleCallingClientErrors(err, (clientError) => {
+                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
+            }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+            regionInfo.clientRegion = '';
+            regionInfo.countryCode = '';
+            if (abort) {
+                await uploadLogs();
+                return regionInfo;
             }
         }
         return regionInfo;
@@ -317,7 +267,9 @@ export class CallingClient extends Eventing {
             });
             clientRegion = this.sdkConfig?.discovery?.region;
             countryCode = this.sdkConfig?.discovery?.country;
-            this.mobiusHost = this.webex.internal.services._serviceUrls.mobius;
+            this.mobiusHost =
+                this.webex.internal.services._serviceUrls?.mobius ||
+                    this.webex.internal.services.get(this.webex.internal.services._activeServices.mobius);
         }
         else {
             log.log('Updating region and country through Region discovery', {
@@ -333,43 +285,53 @@ export class CallingClient extends Eventing {
                 file: CALLING_CLIENT_FILE,
                 method: GET_MOBIUS_SERVERS_UTIL,
             });
-            try {
-                const response = await this.webex.request({
-                    uri: `${this.mobiusHost}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
-                    method: HTTP_METHODS.GET,
-                    headers: {
-                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
-                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                    },
-                    service: ALLOWED_SERVICES.MOBIUS,
-                });
-                log.log(`Mobius Server found for the region. Response trackingId: ${response?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: GET_MOBIUS_SERVERS_UTIL,
-                });
-                const mobiusServers = response.body;
-                this.metricManager.submitMobiusServersMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.MOBIUS_SERVERS, METRIC_TYPE.BEHAVIORAL, mobiusServers, response?.headers?.trackingid ?? '');
-                const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
-                this.primaryMobiusUris = mobiusUris.primary;
-                this.backupMobiusUris = mobiusUris.backup;
-                log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: GET_MOBIUS_SERVERS_UTIL,
-                });
-            }
-            catch (err) {
-                log.error(`Failed to get Mobius servers: ${JSON.stringify(err)}`, {
-                    method: METHODS.GET_MOBIUS_SERVERS,
-                    file: CALLING_CLIENT_FILE,
-                });
-                const abort = await handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
-                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
-                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-                if (abort) {
-                    await uploadLogs();
+            for (const mobius of this.mobiusClusters) {
+                if (mobius.host) {
+                    this.mobiusHost = `https://${mobius.host}${API_V1}`;
+                }
+                else {
+                    this.mobiusHost = mobius;
+                }
+                try {
+                    const response = await this.webex.request({
+                        uri: `${this.mobiusHost}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
+                        method: HTTP_METHODS.GET,
+                        headers: {
+                            [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                            [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                        },
+                        service: ALLOWED_SERVICES.MOBIUS,
+                    });
+                    log.log(`Mobius Server found for the region. Response trackingId: ${response?.headers?.trackingid}`, {
+                        file: CALLING_CLIENT_FILE,
+                        method: GET_MOBIUS_SERVERS_UTIL,
+                    });
+                    const mobiusServers = response.body;
+                    this.metricManager.submitMobiusServersMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.MOBIUS_SERVERS, METRIC_TYPE.BEHAVIORAL, mobiusServers, response?.headers?.trackingid ?? '');
+                    const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
+                    this.primaryMobiusUris = mobiusUris.primary;
+                    this.backupMobiusUris = mobiusUris.backup;
+                    log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
+                        file: CALLING_CLIENT_FILE,
+                        method: GET_MOBIUS_SERVERS_UTIL,
+                    });
+                    break;
+                }
+                catch (err) {
+                    log.error(`Failed to get Mobius servers: ${JSON.stringify(err)}`, {
+                        method: METHODS.GET_MOBIUS_SERVERS,
+                        file: CALLING_CLIENT_FILE,
+                    });
+                    const abort = await handleCallingClientErrors(err, (clientError) => {
+                        this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
+                        this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
+                    }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+                    if (abort) {
+                        useDefault = true;
+                        await uploadLogs();
+                        break;
+                    }
                 }
-                useDefault = true;
             }
         }
         else {

package/dist/module/CallingClient/calling/call.js

@@ -7,7 +7,7 @@ import { ERROR_LAYER, ERROR_TYPE } from '../../Errors/types';
 import { handleCallErrors, modifySdpForIPv4, parseMediaQualityStatistics, serviceErrorCodeHandler, uploadLogs, } from '../../common/Utils';
 import { ALLOWED_SERVICES, CallDirection, HTTP_METHODS, } from '../../common/types';
 import { createCallError } from '../../Errors/catalog/CallError';
-import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
+import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MAX_CALL_KEEPALIVE_RETRY_COUNT, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
 import SDKConnector from '../../SDKConnector';
 import { Eventing } from '../../Events/impl';
 import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
@@ -51,6 +51,7 @@ export class Call extends Eventing {
     receivedRoapOKSeq;
     localAudioStream;
     rtcMetrics;
+    callKeepaliveRetryCount = 0;
     isMuted() {
         return this.muted;
     }
@@ -881,20 +882,21 @@ export class Call extends Eventing {
     async handleIncomingCallDisconnect(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+            method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
         });
+        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
         this.setDisconnectReason();
         try {
             const response = await this.delete();
             log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
         }
         catch (e) {
             log.warn(`Failed to delete the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
             uploadLogs({
                 correlationId: this.correlationId,
@@ -916,7 +918,6 @@ export class Call extends Eventing {
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
-        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
     }
     async handleOutgoingCallDisconnect(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
@@ -961,50 +962,70 @@ export class Call extends Eventing {
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
     }
-    handleCallEstablished(event) {
-        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
-            file: CALL_FILE,
-            method: METHODS.HANDLE_CALL_ESTABLISHED,
-        });
-        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
-        this.earlyMedia = false;
-        this.connected = true;
-        if (this.sessionTimer) {
-            log.log('Resetting session timer', {
+    callKeepaliveRetryCallback = (interval) => {
+        if (this.callKeepaliveRetryCount === MAX_CALL_KEEPALIVE_RETRY_COUNT) {
+            log.warn(`Max keepalive retry attempts reached. Aborting call keepalive for callId: ${this.callId}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_CALL_ESTABLISHED,
+                method: 'keepaliveRetryCallback',
             });
+            return;
+        }
+        this.callKeepaliveRetryCount += 1;
+        setTimeout(async () => {
+            try {
+                await this.postStatus();
+                this.scheduleCallKeepaliveInterval();
+            }
+            catch (err) {
+                await this.handleCallKeepaliveError(err);
+            }
+        }, interval * 1000);
+    };
+    handleCallKeepaliveError = async (err) => {
+        const error = err;
+        if (this.sessionTimer) {
             clearInterval(this.sessionTimer);
         }
+        const abort = await handleCallErrors((callError) => {
+            this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
+            this.submitCallErrorMetric(callError);
+        }, ERROR_LAYER.CALL_CONTROL, this.callKeepaliveRetryCallback, this.getCorrelationId(), error, 'handleCallEstablished', CALL_FILE);
+        if (abort) {
+            this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_DISCONNECT' });
+            this.emit(CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
+            this.callKeepaliveRetryCount = 0;
+        }
+        await uploadLogs({
+            correlationId: this.correlationId,
+            callId: this.callId,
+            broadworksCorrelationInfo: this.broadworksCorrelationInfo,
+        });
+    };
+    scheduleCallKeepaliveInterval = () => {
+        const loggerContext = {
+            file: CALL_FILE,
+            method: 'scheduleCallKeepaliveInterval',
+        };
         this.sessionTimer = setInterval(async () => {
             try {
                 const res = await this.postStatus();
-                log.info(`Session refresh successful`, {
-                    file: CALL_FILE,
-                    method: METHODS.HANDLE_CALL_ESTABLISHED,
-                });
+                log.info(`Session refresh successful`, loggerContext);
             }
             catch (err) {
-                const error = err;
-                if (this.sessionTimer) {
-                    clearInterval(this.sessionTimer);
-                }
-                handleCallErrors((callError) => {
-                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
-                    this.submitCallErrorMetric(callError);
-                }, ERROR_LAYER.CALL_CONTROL, (interval) => {
-                    setTimeout(() => {
-                        this.postStatus();
-                        this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
-                    }, interval * 1000);
-                }, this.getCorrelationId(), error, this.handleCallEstablished.name, CALL_FILE);
-                await uploadLogs({
-                    correlationId: this.correlationId,
-                    callId: this.callId,
-                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
-                });
+                await this.handleCallKeepaliveError(err);
             }
         }, DEFAULT_SESSION_TIMER);
+    };
+    handleCallEstablished(event) {
+        const loggerContext = {
+            file: CALL_FILE,
+            method: METHODS.HANDLE_CALL_ESTABLISHED,
+        };
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, loggerContext);
+        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
+        this.earlyMedia = false;
+        this.connected = true;
+        this.scheduleCallKeepaliveInterval();
     }
     async handleUnknownState(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
@@ -1159,7 +1180,7 @@ export class Call extends Eventing {
             method: METHODS.HANDLE_ROAP_ERROR,
         });
         const message = event.data;
-        if (message) {
+        if (message && message.messageType === 'ERROR') {
             try {
                 const res = await this.postMedia(message);
                 log.info(`Response code: ${res.statusCode}`, {

package/dist/module/CallingClient/constants.js

@@ -12,6 +12,7 @@ export const DEFAULT_LOCAL_CALL_ID = 'DefaultLocalId';
 export const DEFAULT_REHOMING_INTERVAL_MAX = 120;
 export const DEFAULT_REHOMING_INTERVAL_MIN = 60;
 export const DEFAULT_SESSION_TIMER = 1000 * 60 * 10;
+export const MAX_CALL_KEEPALIVE_RETRY_COUNT = 4;
 export const DEVICES_ENDPOINT_RESOURCE = 'devices';
 export const DISCOVERY_URL = 'https://ds.ciscospark.com/v1/region';
 export const DUMMY_METRICS = {
@@ -112,6 +113,7 @@ export const REGISTRATION_UTIL = 'triggerRegistration';
 export const REGISTER_UTIL = 'attemptRegistrationWithServers';
 export const GET_MOBIUS_SERVERS_UTIL = 'getMobiusServers';
 export const KEEPALIVE_UTIL = 'startKeepaliveTimer';
+export const RECONNECT_ON_FAILURE_UTIL = 'reconnectOnFailure';
 export const FAILBACK_UTIL = 'executeFailback';
 export const REG_429_RETRY_UTIL = 'handle429Retry';
 export const FAILOVER_UTIL = 'startFailoverTimer';
@@ -122,6 +124,7 @@ export const MOBIUS_US_PROD = 'mobius-us-east-1.prod.infra.webex.com';
 export const MOBIUS_EU_PROD = 'mobius-eu-central-1.prod.infra.webex.com';
 export const MOBIUS_US_INT = 'mobius-us-east-1.int.infra.webex.com';
 export const MOBIUS_EU_INT = 'mobius-eu-central-1.int.infra.webex.com';
+export const FAILOVER_CACHE_PREFIX = 'wxc-failover-state';
 export const ICE_CANDIDATES_TIMEOUT = 3000;
 export const METHODS = {
     CONSTRUCTOR: 'constructor',

package/dist/module/CallingClient/registration/register.js

@@ -8,7 +8,7 @@ import { getCallManager } from '../calling';
 import log from '../../Logger';
 import SDKConnector from '../../SDKConnector';
 import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, WorkerMessageType, } from '../../common/types';
-import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
 import { LINE_EVENTS } from '../line/types';
 export class Registration {
     sdkConnector;
@@ -58,6 +58,53 @@ export class Registration {
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
     }
+    getFailoverCacheKey() {
+        return `${FAILOVER_CACHE_PREFIX}.${this.userId || 'unknown'}`;
+    }
+    saveFailoverState(failoverState) {
+        try {
+            localStorage.setItem(this.getFailoverCacheKey(), JSON.stringify(failoverState));
+        }
+        catch (error) {
+            log.warn(`Storing failover state in cache failed with error: ${String(error)}`, {
+                file: REGISTRATION_FILE,
+                method: 'saveFailoverState',
+            });
+        }
+    }
+    clearFailoverState() {
+        try {
+            localStorage.removeItem(this.getFailoverCacheKey());
+        }
+        catch {
+            log.warn('Clearing failover state from localStorage failed', {
+                file: REGISTRATION_FILE,
+                method: 'clearFailoverState',
+            });
+        }
+    }
+    async resumeFailover() {
+        try {
+            const cachedState = localStorage.getItem(this.getFailoverCacheKey());
+            const failoverState = cachedState
+                ? JSON.parse(cachedState)
+                : undefined;
+            if (failoverState && !this.isDeviceRegistered()) {
+                const currentTime = Math.floor(Date.now() / 1000);
+                const newElapsed = failoverState.timeElapsed + (currentTime - failoverState.retryScheduledTime);
+                this.clearFailoverState();
+                await this.startFailoverTimer(failoverState.attempt, newElapsed);
+                return true;
+            }
+        }
+        catch (error) {
+            log.warn(`No failover state found in cache`, {
+                file: REGISTRATION_FILE,
+                method: 'triggerRegistration',
+            });
+        }
+        return false;
+    }
     getActiveMobiusUrl() {
         return this.activeMobiusUrl;
     }
@@ -119,6 +166,22 @@ export class Registration {
         let abort = false;
         if (this.activeMobiusUrl) {
             abort = await this.attemptRegistrationWithServers(caller, [this.activeMobiusUrl]);
+            if (this.retryAfter) {
+                if (this.retryAfter < RETRY_TIMER_UPPER_LIMIT) {
+                    setTimeout(async () => {
+                        await this.restartRegistration(caller);
+                    }, this.retryAfter * 1000);
+                }
+                else if (this.primaryMobiusUris.includes(this.activeMobiusUrl) &&
+                    this.backupMobiusUris.length > 0) {
+                    abort = await this.attemptRegistrationWithServers(caller, this.backupMobiusUris);
+                }
+                else {
+                    this.restartRegistration(caller);
+                }
+                this.retryAfter = undefined;
+                return true;
+            }
         }
         return abort;
     }
@@ -190,6 +253,12 @@ export class Registration {
             if (this.retryAfter != null) {
                 interval = Math.max(interval, this.retryAfter);
             }
+            this.saveFailoverState({
+                attempt,
+                timeElapsed,
+                retryScheduledTime: scheduledTime,
+                serverType: 'primary',
+            });
             setTimeout(async () => {
                 await this.mutex.runExclusive(async () => {
                     abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL);
@@ -202,6 +271,12 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
+            this.saveFailoverState({
+                attempt,
+                timeElapsed,
+                retryScheduledTime: Math.floor(Date.now() / 1000),
+                serverType: 'backup',
+            });
             log.info('Failing over to backup servers.', loggerContext);
             this.failoverImmediately = false;
             abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL, this.backupMobiusUris);
@@ -417,6 +492,9 @@ export class Registration {
         };
     }
     async triggerRegistration() {
+        if (await this.resumeFailover()) {
+            return;
+        }
         if (this.primaryMobiusUris.length > 0) {
             const abort = await this.attemptRegistrationWithServers(REGISTRATION_UTIL, this.primaryMobiusUris);
             if (!this.isDeviceRegistered() && !abort) {
@@ -450,6 +528,7 @@ export class Registration {
                     method: REGISTER_UTIL,
                 });
                 const resp = await this.postRegistration(url);
+                this.clearFailoverState();
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
                 this.setActiveMobiusUrl(url);
@@ -537,7 +616,7 @@ export class Registration {
                                 this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                                 await uploadLogs();
                                 if (!abort) {
-                                    await this.reconnectOnFailure(KEEPALIVE_UTIL);
+                                    await this.reconnectOnFailure(RECONNECT_ON_FAILURE_UTIL);
                                 }
                                 else if (error.statusCode === 404) {
                                     this.handle404KeepaliveFailure(KEEPALIVE_UTIL);
@@ -578,6 +657,7 @@ export class Registration {
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);
+        this.clearFailoverState();
     }
     isRegRetry() {
         return this.registerRetry;

package/dist/module/Contacts/ContactsClient.js

@@ -12,6 +12,7 @@ export class ContactsClient {
     groups;
     contacts;
     defaultGroupId;
+    contactsServiceUrl;
     constructor(webex, logger) {
         this.sdkConnector = SDKConnector;
         if (!this.sdkConnector.getWebex()) {
@@ -22,6 +23,9 @@ export class ContactsClient {
         this.groups = undefined;
         this.contacts = undefined;
         this.defaultGroupId = '';
+        this.contactsServiceUrl =
+            this.webex.internal.services._serviceUrls?.contactsService ||
+                this.webex.internal.services.get(this.webex.internal.services._activeServices.contactsService);
         log.setLogger(logger.level, CONTACTS_CLIENT);
     }
     async decryptContactDetail(encryptionKeyUrl, contactDetails) {
@@ -195,7 +199,7 @@ export class ContactsClient {
         const cloudContactsMap = {};
         try {
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
                 method: HTTP_METHODS.GET,
             });
             log.log(`Response code: ${response.statusCode} and Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
@@ -372,7 +376,7 @@ export class ContactsClient {
         };
         try {
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}`,
                 method: HTTP_METHODS.POST,
                 body: groupInfo,
             });
@@ -407,7 +411,7 @@ export class ContactsClient {
         try {
             log.info(`Deleting contact group: ${groupId}`, loggerContext);
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}/${groupId}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}/${groupId}`,
                 method: HTTP_METHODS.DELETE,
             });
             log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
@@ -481,7 +485,7 @@ export class ContactsClient {
                 }
             }
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
                 method: HTTP_METHODS.POST,
                 body: requestBody,
             });
@@ -526,7 +530,7 @@ export class ContactsClient {
         try {
             log.info(`Deleting contact : ${contactId}`, loggerContext);
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}/${contactId}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}/${contactId}`,
                 method: HTTP_METHODS.DELETE,
             });
             const contactResponse = {

package/dist/module/Voicemail/BroadworksBackendConnector.js

@@ -67,9 +67,11 @@ export class BroadworksBackendConnector {
             method: METHODS.GET_BW_TOKEN,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
+        const broadworksIdpProxyUrl = this.webex.internal.services._serviceUrls?.broadworksIdpProxy ||
+            this.webex.internal.services.get(this.webex.internal.services._activeServices.broadworksIdpProxy);
         try {
             const bwTokenResponse = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.broadworksIdpProxy}${BW_TOKEN_FETCH_ENDPOINT}`,
+                uri: `${broadworksIdpProxyUrl}${BW_TOKEN_FETCH_ENDPOINT}`,
                 method: HTTP_METHODS.GET,
             });
             const response = bwTokenResponse.body;