@webex/calling 3.12.0-next.4 → 3.12.0-next.40

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

@@ -1,4 +1,3 @@
-import { v4 as uuid } from 'uuid';
 import { METHOD_START_MESSAGE } from '../../common/constants';
 import { emitFinalFailure, handleRegistrationErrors, uploadLogs } from '../../common';
 import webWorkerStr from './webWorkerStr';
@@ -8,8 +7,9 @@ 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, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, 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';
+import { APIRequest } from '../utils/request';
 export class Registration {
     sdkConnector;
     webex;
@@ -36,6 +36,7 @@ export class Registration {
     retryAfter;
     scheduled429Retry = false;
     webWorker;
+    apiRequest;
     constructor(webex, serviceData, mutex, lineEmitter, logLevel, jwe) {
         this.jwe = jwe;
         this.sdkConnector = SDKConnector;
@@ -57,6 +58,12 @@ export class Registration {
         this.lineEmitter = lineEmitter;
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
+    }
+    getServerType(url) {
+        return ((this.primaryMobiusUris.includes(url) && 'PRIMARY') ||
+            (this.backupMobiusUris?.includes(url) && 'BACKUP') ||
+            'UNKNOWN');
     }
     getFailoverCacheKey() {
         return `${FAILOVER_CACHE_PREFIX}.${this.userId || 'unknown'}`;
@@ -131,16 +138,22 @@ export class Registration {
     }
     async deleteRegistration(url, deviceId, deviceUrl) {
         let response;
+        const requestObj = {
+            uri: `${url}${DEVICES_ENDPOINT_RESOURCE}/${deviceId}`,
+            method: HTTP_METHODS.DELETE,
+            headers: {
+                [CISCO_DEVICE_URL]: deviceUrl,
+                [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+            },
+            service: ALLOWED_SERVICES.MOBIUS,
+        };
+        if (this.apiRequest.isSocketEnabled()) {
+            requestObj.body = {
+                deviceId,
+            };
+        }
         try {
-            response = await fetch(`${url}${DEVICES_ENDPOINT_RESOURCE}/${deviceId}`, {
-                method: HTTP_METHODS.DELETE,
-                headers: {
-                    [CISCO_DEVICE_URL]: deviceUrl,
-                    Authorization: await this.webex.credentials.getUserToken(),
-                    trackingId: `${WEBEX_WEB_CLIENT}_${uuid()}`,
-                    [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                },
-            });
+            response = await this.apiRequest.makeRequest(requestObj);
         }
         catch (error) {
             log.warn(`Delete failed with Mobius: ${JSON.stringify(error)}`, {
@@ -151,7 +164,7 @@ export class Registration {
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
-        return response?.json();
+        return response;
     }
     async postRegistration(url) {
         const deviceInfo = {
@@ -159,7 +172,7 @@ export class Registration {
             clientDeviceUri: this.webex.internal.device.url,
             serviceData: this.jwe ? { ...this.serviceData, jwe: this.jwe } : this.serviceData,
         };
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${url}device`,
             method: HTTP_METHODS.POST,
             headers: {
@@ -171,7 +184,23 @@ export class Registration {
         });
     }
     async restorePreviousRegistration(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.RESTORE_PREVIOUS_REGISTRATION,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}, activeMobiusUrl: ${this.activeMobiusUrl}`, loggerContext);
         let abort = false;
+        if (this.apiRequest.isSocketEnabled() &&
+            `${this.apiRequest.getConnectedWebSocketUrl()}/` !== this.activeMobiusUrl) {
+            log.info(`Disconnecting from Mobius socket to restore previous registration.`, {
+                file: REGISTRATION_FILE,
+                method: 'restorePreviousRegistration',
+            });
+            await this.apiRequest.disconnectFromMobiusSocket({
+                code: 3050,
+                reason: 'done (permanent)',
+            });
+        }
         if (this.activeMobiusUrl) {
             abort = await this.attemptRegistrationWithServers(caller, [this.activeMobiusUrl]);
             if (this.retryAfter) {
@@ -185,20 +214,31 @@ export class Registration {
                     abort = await this.attemptRegistrationWithServers(caller, this.backupMobiusUris);
                 }
                 else {
-                    this.restartRegistration(caller);
+                    await this.restartRegistration(caller);
                 }
                 this.retryAfter = undefined;
+                log.log(`restorePreviousRegistration completed via 429 retry-after path - caller: ${caller}`, loggerContext);
                 return true;
             }
         }
+        log.log(`restorePreviousRegistration completed - caller: ${caller}, deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
         return abort;
     }
     async handle404KeepaliveFailure(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_404_KEEPALIVE_FAILURE,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}`, loggerContext);
         if (caller === KEEPALIVE_UTIL) {
             const abort = await this.attemptRegistrationWithServers(caller);
             if (!abort && !this.isDeviceRegistered()) {
+                log.warn('Keepalive 404 recovery: re-registration did not complete, starting failover timer', loggerContext);
                 await this.startFailoverTimer();
             }
+            else {
+                log.log(`Keepalive 404 recovery handled - deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
+            }
         }
     }
     async handle429Retry(retryAfter, caller) {
@@ -279,6 +319,14 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
+            if (this.apiRequest.isSocketEnabled()) {
+                log.info('Disconnecting from primary Mobius socket for failover to backup servers', loggerContext);
+                await this.apiRequest.disconnectFromMobiusSocket({
+                    code: 3050,
+                    reason: 'done (permanent)',
+                });
+                log.log('Mobius socket disconnect complete prior to backup failover', loggerContext);
+            }
             this.saveFailoverState({
                 attempt,
                 timeElapsed,
@@ -311,7 +359,7 @@ export class Registration {
             await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
-            }, loggerContext);
+            }, loggerContext, interval < 0 ? 'Timer threshold exceeded during failover' : undefined);
         }
     }
     clearFailbackTimer() {
@@ -320,11 +368,25 @@ export class Registration {
             this.failbackTimer = undefined;
         }
     }
+    async postKeepAlive(deviceUrl, url) {
+        return this.apiRequest.makeRequest({
+            uri: `${url}/status`,
+            method: HTTP_METHODS.POST,
+            headers: {
+                [CISCO_DEVICE_URL]: deviceUrl,
+                [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+            },
+            body: {
+                deviceId: this.deviceInfo.device?.deviceId,
+            },
+            service: ALLOWED_SERVICES.MOBIUS,
+        });
+    }
     async isPrimaryActive() {
         let status;
         for (const mobiusUrl of this.primaryMobiusUris) {
             try {
-                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/');
+                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/').replace('wss://', 'https://');
                 const response = await this.webex.request({
                     uri: `${baseUri}ping`,
                     method: HTTP_METHODS.GET,
@@ -362,14 +424,23 @@ export class Registration {
             this.rehomingIntervalMin);
     }
     initiateFailback() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.INITIATE_FAILBACK,
+        };
         if (this.isFailbackRequired()) {
             if (!this.failbackTimer) {
                 this.failback429RetryAttempts = 0;
                 const intervalInMinutes = this.getFailbackInterval();
+                log.info(`Scheduling failback to primary - intervalMinutes: ${intervalInMinutes}`, loggerContext);
                 this.startFailbackTimer(intervalInMinutes * MINUTES_TO_SEC_MFACTOR);
             }
+            else {
+                log.info('Failback timer already scheduled, skipping', loggerContext);
+            }
         }
         else {
+            log.info('Failback not required, clearing any pending failback timer', loggerContext);
             this.failback429RetryAttempts = 0;
             this.clearFailbackTimer();
         }
@@ -382,15 +453,25 @@ export class Registration {
         });
     }
     async executeFailback() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.EXECUTE_FAILBACK,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         await this.mutex.runExclusive(async () => {
             if (this.isFailbackRequired()) {
                 const primaryServerStatus = await this.isPrimaryActive();
                 if (Object.keys(this.callManager.getActiveCalls()).length === 0 && primaryServerStatus) {
-                    log.info(`Attempting failback to primary.`, {
-                        file: REGISTRATION_FILE,
-                        method: this.executeFailback.name,
-                    });
+                    log.info(`Attempting failback to primary.`, loggerContext);
                     await this.deregister();
+                    if (this.apiRequest.isSocketEnabled()) {
+                        log.info('Disconnecting from backup Mobius socket for failback to primary', loggerContext);
+                        await this.apiRequest.disconnectFromMobiusSocket({
+                            code: 3050,
+                            reason: 'done (permanent)',
+                        });
+                        log.log('Mobius socket disconnect complete prior to primary failback', loggerContext);
+                    }
                     const abort = await this.attemptRegistrationWithServers(FAILBACK_UTIL);
                     if (this.scheduled429Retry || abort || this.isDeviceRegistered()) {
                         return;
@@ -401,7 +482,7 @@ export class Registration {
                         return;
                     }
                     if (!this.isDeviceRegistered()) {
-                        await this.restartRegistration(this.executeFailback.name);
+                        await this.restartRegistration(loggerContext.method);
                     }
                     else {
                         this.failbackTimer = undefined;
@@ -409,10 +490,7 @@ export class Registration {
                     }
                 }
                 else {
-                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', {
-                        file: REGISTRATION_FILE,
-                        method: this.executeFailback.name,
-                    });
+                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', loggerContext);
                     this.failbackTimer = undefined;
                     this.initiateFailback();
                 }
@@ -442,12 +520,18 @@ export class Registration {
         this.registrationStatus = value;
     }
     async restartRegistration(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.RESTART_REGISTRATION,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}`, loggerContext);
         this.clearFailbackTimer();
         this.failback429RetryAttempts = 0;
         const abort = await this.attemptRegistrationWithServers(caller, this.primaryMobiusUris);
         if (!abort && !this.isDeviceRegistered()) {
             await this.startFailoverTimer();
         }
+        log.log(`restartRegistration completed - caller: ${caller}, deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
     }
     async handleConnectionRestoration(retry) {
         log.info(METHOD_START_MESSAGE, {
@@ -500,7 +584,13 @@ export class Registration {
         };
     }
     async triggerRegistration() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.TRIGGER_REGISTRATION,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         if (await this.resumeFailover()) {
+            log.info('Registration trigger handled by resumeFailover path', loggerContext);
             return;
         }
         if (this.primaryMobiusUris.length > 0) {
@@ -508,43 +598,48 @@ export class Registration {
             if (!this.isDeviceRegistered() && !abort) {
                 await this.startFailoverTimer();
             }
+            log.log(`triggerRegistration completed - deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
+        }
+        else {
+            log.warn('triggerRegistration skipped: no primary Mobius URIs available', loggerContext);
         }
     }
     async attemptRegistrationWithServers(caller, servers = this.primaryMobiusUris) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: REGISTER_UTIL,
+        };
         let abort = false;
         this.retryAfter = undefined;
+        let connectedWebSocketUrl;
         if (this.failoverImmediately) {
             return abort;
         }
         if (this.isDeviceRegistered()) {
-            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
-                file: REGISTRATION_FILE,
-                method: REGISTER_UTIL,
-            });
+            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, loggerContext);
             return abort;
         }
         for (const url of servers) {
-            const serverType = (this.primaryMobiusUris.includes(url) && 'PRIMARY') ||
-                (this.backupMobiusUris?.includes(url) && 'BACKUP') ||
-                'UNKNOWN';
+            const serverType = this.getServerType(url);
             try {
                 abort = false;
                 this.registrationStatus = RegistrationStatus.INACTIVE;
                 this.lineEmitter(LINE_EVENTS.CONNECTING);
-                log.info(`[${caller}] : Mobius url to contact: ${url}`, {
-                    file: REGISTRATION_FILE,
-                    method: REGISTER_UTIL,
-                });
+                log.info(`[${caller}] : Mobius url to contact: ${url}`, loggerContext);
+                if (this.apiRequest.isSocketEnabled()) {
+                    const wssNormalizedUrl = url.endsWith('/') ? url.slice(0, -1) : url;
+                    log.info(`[${caller}] : Connecting to Mobius WebSocket - serverType: ${serverType}, wssUrl: ${wssNormalizedUrl}`, loggerContext);
+                    connectedWebSocketUrl = await this.apiRequest.connectToMobiusSocket(wssNormalizedUrl);
+                    connectedWebSocketUrl = connectedWebSocketUrl ? `${connectedWebSocketUrl}/` : undefined;
+                    log.log(`[${caller}] : Mobius WebSocket connected - serverType: ${serverType}, connectedWebSocketUrl: ${connectedWebSocketUrl}`, loggerContext);
+                }
                 const resp = await this.postRegistration(url);
                 this.clearFailoverState();
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
-                this.setActiveMobiusUrl(url);
+                this.setActiveMobiusUrl(connectedWebSocketUrl || url);
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
-                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, {
-                    file: REGISTRATION_FILE,
-                    method: METHODS.REGISTER,
-                });
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, loggerContext);
                 this.setIntervalValues(this.deviceInfo);
                 this.metricManager.setDeviceInfo(this.deviceInfo);
                 this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, resp.headers?.trackingid ?? '', undefined, undefined);
@@ -554,22 +649,29 @@ export class Registration {
             }
             catch (err) {
                 const body = err;
-                abort = await handleRegistrationErrors(body, (clientError, finalError) => {
-                    if (finalError) {
+                const { finalError, shouldDisconnect } = await handleRegistrationErrors(body, (clientError, isFinalError) => {
+                    if (isFinalError) {
                         this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                     }
                     else {
                         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                     }
                     this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, body.headers?.trackingid ?? '', undefined, clientError);
-                }, { method: caller, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller), this.restoreRegistrationCallBack());
+                }, { method: caller, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller), this.restoreRegistrationCallBack(), servers.length);
+                abort = finalError;
                 if (this.registrationStatus === RegistrationStatus.ACTIVE) {
-                    log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, {
-                        file: REGISTRATION_FILE,
-                        method: this.attemptRegistrationWithServers.name,
-                    });
+                    log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, loggerContext);
                     break;
                 }
+                if (shouldDisconnect && this.apiRequest.isSocketEnabled()) {
+                    connectedWebSocketUrl = undefined;
+                    log.info(`[${caller}] : Tearing down Mobius WebSocket after registration error - serverType: ${serverType}`, loggerContext);
+                    await this.apiRequest.disconnectFromMobiusSocket({
+                        code: 3050,
+                        reason: 'done (permanent)',
+                    });
+                    log.log(`[${caller}] : Mobius WebSocket disconnect complete after registration error - serverType: ${serverType}`, loggerContext);
+                }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
                     await uploadLogs();
@@ -584,7 +686,6 @@ export class Registration {
         const RETRY_COUNT_THRESHOLD = this.isCCFlow ? 4 : 5;
         await this.mutex.runExclusive(async () => {
             if (this.isDeviceRegistered()) {
-                const accessToken = await this.webex.credentials.getUserToken();
                 if (!this.webWorker) {
                     const blob = new Blob([webWorkerStr], { type: 'application/javascript' });
                     const blobUrl = URL.createObjectURL(blob);
@@ -592,17 +693,38 @@ export class Registration {
                     URL.revokeObjectURL(blobUrl);
                     this.webWorker.postMessage({
                         type: WorkerMessageType.START_KEEPALIVE,
-                        accessToken: String(accessToken),
-                        deviceUrl: String(this.webex.internal.device.url),
                         interval,
                         retryCountThreshold: RETRY_COUNT_THRESHOLD,
-                        url,
                     });
                     this.webWorker.onmessage = async (event) => {
                         const logContext = {
                             file: REGISTRATION_FILE,
                             method: KEEPALIVE_UTIL,
                         };
+                        if (event.data.type === WorkerMessageType.SEND_KEEPALIVE) {
+                            try {
+                                const res = await this.postKeepAlive(String(this.webex.internal.device.url), url);
+                                this.webWorker?.postMessage({
+                                    type: WorkerMessageType.KEEPALIVE_RESULT,
+                                    statusCode: res.statusCode,
+                                });
+                            }
+                            catch (err) {
+                                const error = {
+                                    headers: {
+                                        trackingid: err.headers?.trackingid,
+                                        'retry-after': err.headers['retry-after'],
+                                    },
+                                    statusCode: err.statusCode,
+                                    statusText: err.statusText,
+                                    type: err.type,
+                                };
+                                this.webWorker?.postMessage({
+                                    type: WorkerMessageType.KEEPALIVE_RESULT,
+                                    err: error,
+                                });
+                            }
+                        }
                         if (event.data.type === WorkerMessageType.KEEPALIVE_SUCCESS) {
                             log.info(`Sent Keepalive, status: ${event.data.statusCode}`, logContext);
                             this.lineEmitter(LINE_EVENTS.RECONNECTED);
@@ -610,7 +732,7 @@ export class Registration {
                         if (event.data.type === WorkerMessageType.KEEPALIVE_FAILURE) {
                             const error = event.data.err;
                             log.warn(`Keep-alive missed ${event.data.keepAliveRetryCount} times. Status -> ${error.statusCode} `, logContext);
-                            const abort = await handleRegistrationErrors(error, (clientError, finalError) => {
+                            const { finalError: abort } = await handleRegistrationErrors(error, (clientError, finalError) => {
                                 if (finalError) {
                                     this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                                 }
@@ -649,19 +771,25 @@ export class Registration {
     isReconnectPending() {
         return this.reconnectPending;
     }
-    async deregister() {
+    async deregister(closeMobiusWss = false) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.DEREGISTER,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             await this.deleteRegistration(this.activeMobiusUrl, this.deviceInfo.device?.deviceId, this.deviceInfo.device?.clientDeviceUri);
-            log.log('Registration successfully deregistered', {
-                file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
-            });
+            log.log('Registration successfully deregistered', loggerContext);
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, {
-                file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, loggerContext);
+        }
+        if (closeMobiusWss) {
+            await this.apiRequest.disconnectFromMobiusSocket({
+                code: 3050,
+                reason: 'done (permanent)',
             });
+            log.log('Mobius socket disconnect complete after deregistration', loggerContext);
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);
@@ -683,7 +811,10 @@ export class Registration {
                 rehomingIntervalMin: DEFAULT_REHOMING_INTERVAL_MIN,
             };
             const stringToReplace = `${DEVICES_ENDPOINT_RESOURCE}/${restoreData.devices[0].deviceId}`;
-            const uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+            let uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+            if (this.apiRequest.isSocketEnabled()) {
+                uri = uri.replace('https://', 'wss://');
+            }
             this.setActiveMobiusUrl(uri);
             this.registrationStatus = RegistrationStatus.ACTIVE;
             return true;
@@ -709,5 +840,46 @@ export class Registration {
             }
         }
     }
+    async handleRegistrationDownEvent(event) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_REGISTRATION_DOWN_EVENT,
+        };
+        log.info(`Registration down received - trackingId: ${event?.trackingId ?? 'unknown'}, eventId: ${event?.eventId ?? 'unknown'}`, loggerContext);
+        const [activeCall] = Object.values(this.callManager.getActiveCalls());
+        activeCall?.end();
+        await this.performRegistrationDownCleanup(METHODS.HANDLE_REGISTRATION_DOWN_EVENT);
+    }
+    async performRegistrationDownCleanup(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_REGISTRATION_DOWN_EVENT,
+        };
+        log.info(`[${caller}] : Running registration-down cleanup`, loggerContext);
+        await this.mutex.runExclusive(async () => {
+            this.clearFailbackTimer();
+            this.clearKeepaliveTimer();
+            this.reconnectPending = false;
+            this.scheduled429Retry = false;
+            this.failoverImmediately = false;
+            this.retryAfter = undefined;
+            this.registerRetry = false;
+            this.clearFailoverState();
+            this.setStatus(RegistrationStatus.INACTIVE);
+            if (this.apiRequest.isSocketEnabled()) {
+                try {
+                    await this.apiRequest.disconnectFromMobiusSocket({
+                        code: 3050,
+                        reason: 'done (permanent)',
+                    });
+                    log.log('Mobius socket disconnect complete after registration-down', loggerContext);
+                }
+                catch (err) {
+                    log.warn(`Mobius socket disconnect failed after registration-down: ${String(err)}`, loggerContext);
+                }
+            }
+            this.lineEmitter(LINE_EVENTS.UNREGISTERED);
+        });
+    }
 }
 export const createRegistration = (webex, serviceData, mutex, lineEmitter, logLevel, jwe) => new Registration(webex, serviceData, mutex, lineEmitter, logLevel, jwe);

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

@@ -1,73 +1,54 @@
-import { v4 as uuid } from 'uuid';
-import { HTTP_METHODS, WorkerMessageType } from '../../common/types';
+import { WorkerMessageType } from '../../common/types';
 let keepaliveTimer;
+let keepAliveRetryCount = 0;
+let keepaliveInFlight = false;
+const clearKeepaliveTimer = () => {
+    if (keepaliveTimer) {
+        clearInterval(keepaliveTimer);
+        keepaliveTimer = undefined;
+    }
+};
 const messageHandler = (event) => {
     const { type } = event.data;
-    const postKeepAlive = async (accessToken, deviceUrl, url) => {
-        const response = await fetch(`${url}/status`, {
-            method: HTTP_METHODS.POST,
-            headers: {
-                'cisco-device-url': deviceUrl,
-                'spark-user-agent': 'webex-calling/beta',
-                Authorization: `${accessToken}`,
-                trackingId: `web_worker_${uuid()}`,
-            },
-        });
-        if (!response.ok) {
-            throw response;
-        }
-        return response;
-    };
     if (type === WorkerMessageType.START_KEEPALIVE) {
-        let keepAliveRetryCount = 0;
-        const { accessToken, deviceUrl, interval, retryCountThreshold, url } = event.data;
-        if (keepaliveTimer) {
-            clearInterval(keepaliveTimer);
-            keepaliveTimer = undefined;
-        }
-        keepaliveTimer = setInterval(async () => {
-            if (keepAliveRetryCount < retryCountThreshold) {
-                try {
-                    const res = await postKeepAlive(accessToken, deviceUrl, url);
-                    const statusCode = res.status;
-                    if (keepAliveRetryCount > 0) {
-                        postMessage({
-                            type: WorkerMessageType.KEEPALIVE_SUCCESS,
-                            statusCode,
-                        });
-                    }
-                    keepAliveRetryCount = 0;
-                }
-                catch (err) {
-                    const headers = {};
-                    if (err.headers?.has('Retry-After')) {
-                        headers['retry-after'] = err.headers.get('Retry-After');
-                    }
-                    if (err.headers?.has('Trackingid')) {
-                        headers['trackingid'] = err.headers.get('Trackingid');
-                    }
-                    const error = {
-                        headers,
-                        statusCode: err.status,
-                        statusText: err.statusText,
-                        type: err.type,
-                    };
-                    keepAliveRetryCount += 1;
-                    postMessage({
-                        type: WorkerMessageType.KEEPALIVE_FAILURE,
-                        err: error,
-                        keepAliveRetryCount,
-                    });
-                }
+        const { interval, retryCountThreshold } = event.data;
+        clearKeepaliveTimer();
+        keepAliveRetryCount = 0;
+        keepaliveInFlight = false;
+        keepaliveTimer = setInterval(() => {
+            if (keepAliveRetryCount < retryCountThreshold && !keepaliveInFlight) {
+                keepaliveInFlight = true;
+                postMessage({
+                    type: WorkerMessageType.SEND_KEEPALIVE,
+                });
             }
         }, interval * 1000);
     }
-    if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
-        if (keepaliveTimer) {
-            clearInterval(keepaliveTimer);
-            keepaliveTimer = undefined;
+    if (type === WorkerMessageType.KEEPALIVE_RESULT) {
+        keepaliveInFlight = false;
+        if (event.data.err === undefined) {
+            if (keepAliveRetryCount > 0) {
+                postMessage({
+                    type: WorkerMessageType.KEEPALIVE_SUCCESS,
+                    statusCode: event.data.statusCode,
+                });
+            }
+            keepAliveRetryCount = 0;
+        }
+        else {
+            keepAliveRetryCount += 1;
+            postMessage({
+                type: WorkerMessageType.KEEPALIVE_FAILURE,
+                err: event.data.err,
+                keepAliveRetryCount,
+            });
         }
     }
+    if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
+        clearKeepaliveTimer();
+        keepAliveRetryCount = 0;
+        keepaliveInFlight = false;
+    }
 };
 self.addEventListener('message', messageHandler);
 export default messageHandler;