@webex/internal-plugin-mercury 3.10.0-next.2 → 3.10.0-wxc-disconnect.1

package/src/mercury.js

@@ -96,80 +96,6 @@ const Mercury = WebexPlugin.extend({
     });
   },
 
-  /**
-   * Attach event listeners to a socket.
-   * @param {Socket} socket - The socket to attach listeners to
-   * @returns {void}
-   */
-  _attachSocketEventListeners(socket) {
-    socket.on('close', (event) => this._onclose(event, socket));
-    socket.on('message', (...args) => this._onmessage(...args));
-    socket.on('pong', (...args) => this._setTimeOffset(...args));
-    socket.on('sequence-mismatch', (...args) => this._emit('sequence-mismatch', ...args));
-    socket.on('ping-pong-latency', (...args) => this._emit('ping-pong-latency', ...args));
-  },
-
-  /**
-   * Handle imminent shutdown by establishing a new connection while keeping
-   * the current one alive (make-before-break).
-   * Idempotent: will no-op if already in progress.
-   * @returns {void}
-   */
-  _handleImminentShutdown() {
-    try {
-      if (this._shutdownSwitchoverInProgress) {
-        this.logger.info(`${this.namespace}: [shutdown] switchover already in progress`);
-
-        return;
-      }
-      this._shutdownSwitchoverInProgress = true;
-      this._shutdownSwitchoverId = `${Date.now()}`;
-      this.logger.info(
-        `${this.namespace}: [shutdown] switchover start, id=${this._shutdownSwitchoverId}`
-      );
-
-      this._connectWithBackoff(undefined, {
-        isShutdownSwitchover: true,
-        attemptOptions: {
-          isShutdownSwitchover: true,
-          onSuccess: (newSocket, webSocketUrl) => {
-            this.logger.info(
-              `${this.namespace}: [shutdown] switchover connected, url: ${webSocketUrl}`
-            );
-
-            const oldSocket = this.socket;
-            // Atomically switch active socket reference
-            this.socket = newSocket;
-            this.connected = true; // remain connected throughout
-
-            this._emit('event:mercury_shutdown_switchover_complete', {url: webSocketUrl});
-
-            if (oldSocket) {
-              this.logger.info(
-                `${this.namespace}: [shutdown] old socket retained; server will close with 4001`
-              );
-            }
-          },
-        },
-      })
-        .then(() => {
-          this.logger.info(`${this.namespace}: [shutdown] switchover completed successfully`);
-        })
-        .catch((err) => {
-          this.logger.info(
-            `${this.namespace}: [shutdown] switchover exhausted retries; will fall back to normal reconnection`,
-            err
-          );
-          this._emit('event:mercury_shutdown_switchover_failed', {reason: err});
-          // Old socket will eventually close with 4001, triggering normal reconnection
-        });
-    } catch (e) {
-      this.logger.error(`${this.namespace}: [shutdown] error during switchover`, e);
-      this._shutdownSwitchoverInProgress = false;
-      this._emit('event:mercury_shutdown_switchover_failed', {reason: e});
-    }
-  },
-
   /**
    * Get the last error.
    * @returns {any} The last error.
@@ -226,11 +152,6 @@ const Mercury = WebexPlugin.extend({
         this.backoffCall.abort();
       }
 
-      if (this._shutdownSwitchoverBackoffCall) {
-        this.logger.info(`${this.namespace}: aborting shutdown switchover`);
-        this._shutdownSwitchoverBackoffCall.abort();
-      }
-
       if (this.socket) {
         this.socket.removeAllListeners('message');
         this.once('offline', resolve);
@@ -312,63 +233,55 @@ const Mercury = WebexPlugin.extend({
       });
   },
 
-  _attemptConnection(socketUrl, callback, options = {}) {
-    const {isShutdownSwitchover = false, onSuccess = null} = options;
-
+  _attemptConnection(socketUrl, callback) {
     const socket = new Socket();
-    let newWSUrl;
-
-    this._attachSocketEventListeners(socket);
+    let attemptWSUrl;
 
-    // Check appropriate backoff call based on connection type
-    if (isShutdownSwitchover && !this._shutdownSwitchoverBackoffCall) {
-      const msg = `${this.namespace}: prevent socket open when switchover backoff call no longer defined`;
-      const err = new Error(msg);
+    socket.on('close', (...args) => this._onclose(...args));
+    socket.on('message', (...args) => this._onmessage(...args));
+    socket.on('pong', (...args) => this._setTimeOffset(...args));
+    socket.on('sequence-mismatch', (...args) => this._emit('sequence-mismatch', ...args));
+    socket.on('ping-pong-latency', (...args) => this._emit('ping-pong-latency', ...args));
 
-      this.logger.info(msg);
+    Promise.all([this._prepareUrl(socketUrl), this.webex.credentials.getUserToken()])
+      .then(([webSocketUrl, token]) => {
+        if (!this.backoffCall) {
+          const msg = `${this.namespace}: prevent socket open when backoffCall no longer defined`;
 
-      // Call the callback with the error before rejecting
-      callback(err);
+          this.logger.info(msg);
 
-      return Promise.reject(err);
-    }
+          return Promise.reject(new Error(msg));
+        }
 
-    if (!isShutdownSwitchover && !this.backoffCall) {
-      const msg = `${this.namespace}: prevent socket open when backoffCall no longer defined`;
-      const err = new Error(msg);
+        attemptWSUrl = webSocketUrl;
 
-      this.logger.info(msg);
+        let options = {
+          forceCloseDelay: this.config.forceCloseDelay,
+          pingInterval: this.config.pingInterval,
+          pongTimeout: this.config.pongTimeout,
+          token: token.toString(),
+          trackingId: `${this.webex.sessionId}_${Date.now()}`,
+          logger: this.logger,
+        };
 
-      // Call the callback with the error before rejecting
-      callback(err);
+        // if the consumer has supplied request options use them
+        if (this.webex.config.defaultMercuryOptions) {
+          this.logger.info(`${this.namespace}: setting custom options`);
+          options = {...options, ...this.webex.config.defaultMercuryOptions};
+        }
 
-      return Promise.reject(err);
-    }
+        // Set the socket before opening it. This allows a disconnect() to close
+        // the socket if it is in the process of being opened.
+        this.socket = socket;
 
-    // For shutdown switchover, don't set socket yet (make-before-break)
-    // For normal connection, set socket before opening to allow disconnect() to close it
-    if (!isShutdownSwitchover) {
-      this.socket = socket;
-    }
+        this.logger.info(`${this.namespace} connection url: ${webSocketUrl}`);
 
-    return this._prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover)
-      .then((webSocketUrl) => {
-        newWSUrl = webSocketUrl;
+        return socket.open(webSocketUrl, options);
+      })
+      .then(() => {
         this.logger.info(
-          `${this.namespace}: ${
-            isShutdownSwitchover ? '[shutdown] switchover' : ''
-          } connected to mercury, success, action: connected, url: ${newWSUrl}`
+          `${this.namespace}: connected to mercury, success, action: connected, url: ${attemptWSUrl}`
         );
-
-        // Custom success handler for shutdown switchover
-        if (onSuccess) {
-          onSuccess(socket, webSocketUrl);
-          callback();
-
-          return Promise.resolve();
-        }
-
-        // Default behavior for normal connection
         callback();
 
         return this.webex.internal.feature
@@ -382,14 +295,6 @@ const Mercury = WebexPlugin.extend({
           });
       })
       .catch((reason) => {
-        // For shutdown, simpler error handling - just callback for retry
-        if (isShutdownSwitchover) {
-          this.logger.info(`${this.namespace}: [shutdown] switchover attempt failed`, reason);
-
-          return callback(reason);
-        }
-
-        // Normal connection error handling (existing complex logic)
         this.lastError = reason; // remember the last error
 
         // Suppress connection errors that appear to be network related. This
@@ -439,10 +344,10 @@ const Mercury = WebexPlugin.extend({
             .then((haMessagingEnabled) => {
               if (haMessagingEnabled) {
                 this.logger.info(
-                  `${this.namespace}: received a generic connection error, will try to connect to another datacenter. failed, action: 'failed', url: ${newWSUrl} error: ${reason.message}`
+                  `${this.namespace}: received a generic connection error, will try to connect to another datacenter. failed, action: 'failed', url: ${attemptWSUrl} error: ${reason.message}`
                 );
 
-                return this.webex.internal.services.markFailedUrl(newWSUrl);
+                return this.webex.internal.services.markFailedUrl(attemptWSUrl);
               }
 
               return null;
@@ -458,83 +363,36 @@ const Mercury = WebexPlugin.extend({
       });
   },
 
-  _prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover = false) {
-    const logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-
-    return Promise.all([this._prepareUrl(socketUrl), this.webex.credentials.getUserToken()]).then(
-      ([webSocketUrl, token]) => {
-        let options = {
-          forceCloseDelay: this.config.forceCloseDelay,
-          pingInterval: this.config.pingInterval,
-          pongTimeout: this.config.pongTimeout,
-          token: token.toString(),
-          trackingId: `${this.webex.sessionId}_${Date.now()}`,
-          logger: this.logger,
-        };
-
-        if (this.webex.config.defaultMercuryOptions) {
-          const customOptionsMsg = isShutdownSwitchover
-            ? 'setting custom options for switchover'
-            : 'setting custom options';
-
-          this.logger.info(`${this.namespace}: ${customOptionsMsg}`);
-          options = {...options, ...this.webex.config.defaultMercuryOptions};
-        }
-
-        this.logger.info(`${this.namespace}: ${logPrefix} url: ${webSocketUrl}`);
-
-        return socket.open(webSocketUrl, options).then(() => webSocketUrl);
-      }
-    );
-  },
-
-  _connectWithBackoff(webSocketUrl, context = {}) {
-    const {isShutdownSwitchover = false, attemptOptions = {}} = context;
-
+  _connectWithBackoff(webSocketUrl) {
     return new Promise((resolve, reject) => {
       // eslint gets confused about whether or not call is actually used
       // eslint-disable-next-line prefer-const
       let call;
       const onComplete = (err) => {
-        // Clear state flags based on connection type
-        if (isShutdownSwitchover) {
-          this._shutdownSwitchoverInProgress = false;
-          this._shutdownSwitchoverBackoffCall = undefined;
-        } else {
-          this.connecting = false;
-          this.backoffCall = undefined;
-        }
+        this.connecting = false;
 
+        this.backoffCall = undefined;
         if (err) {
-          const msg = isShutdownSwitchover
-            ? `[shutdown] switchover failed after ${call.getNumRetries()} retries`
-            : `failed to connect after ${call.getNumRetries()} retries`;
-
           this.logger.info(
-            `${this.namespace}: ${msg}; log statement about next retry was inaccurate; ${err}`
+            `${
+              this.namespace
+            }: failed to connect after ${call.getNumRetries()} retries; log statement about next retry was inaccurate; ${err}`
           );
 
           return reject(err);
         }
-
-        // Default success handling for normal connections
-        if (!isShutdownSwitchover) {
-          this.connected = true;
-          this.hasEverConnected = true;
-          this._emit('online');
-          this.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(true);
-        }
+        this.connected = true;
+        this.hasEverConnected = true;
+        this._emit('online');
+        this.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(true);
 
         return resolve();
       };
 
       // eslint-disable-next-line prefer-reflect
       call = backoff.call((callback) => {
-        const attemptNum = call.getNumRetries();
-        const logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-
-        this.logger.info(`${this.namespace}: executing ${logPrefix} attempt ${attemptNum}`);
-        this._attemptConnection(webSocketUrl, callback, attemptOptions);
+        this.logger.info(`${this.namespace}: executing connection attempt ${call.getNumRetries()}`);
+        this._attemptConnection(webSocketUrl, callback);
       }, onComplete);
 
       call.setStrategy(
@@ -544,33 +402,24 @@ const Mercury = WebexPlugin.extend({
         })
       );
 
-      if (
-        this.config.initialConnectionMaxRetries &&
-        !this.hasEverConnected &&
-        !isShutdownSwitchover
-      ) {
+      if (this.config.initialConnectionMaxRetries && !this.hasEverConnected) {
         call.failAfter(this.config.initialConnectionMaxRetries);
       } else if (this.config.maxRetries) {
         call.failAfter(this.config.maxRetries);
       }
 
       call.on('abort', () => {
-        const msg = isShutdownSwitchover ? 'Shutdown Switchover' : 'Connection';
-
-        this.logger.info(`${this.namespace}: ${msg} aborted`);
-        reject(new Error(`Mercury ${msg} Aborted`));
+        this.logger.info(`${this.namespace}: connection aborted`);
+        reject(new Error('Mercury Connection Aborted'));
       });
 
       call.on('callback', (err) => {
         if (err) {
           const number = call.getNumRetries();
           const delay = Math.min(call.strategy_.nextBackoffDelay_, this.config.backoffTimeMax);
-          const logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : '';
 
           this.logger.info(
-            `${this.namespace}: ${logPrefix} failed to connect; attempting retry ${
-              number + 1
-            } in ${delay} ms`
+            `${this.namespace}: failed to connect; attempting retry ${number + 1} in ${delay} ms`
           );
           /* istanbul ignore if */
           if (process.env.NODE_ENV === 'development') {
@@ -582,14 +431,9 @@ const Mercury = WebexPlugin.extend({
         this.logger.info(`${this.namespace}: connected`);
       });
 
-      // Store backoff call reference BEFORE starting (so it's available in _attemptConnection)
-      if (isShutdownSwitchover) {
-        this._shutdownSwitchoverBackoffCall = call;
-      } else {
-        this.backoffCall = call;
-      }
-
       call.start();
+
+      this.backoffCall = call;
     });
   },
 
@@ -626,42 +470,19 @@ const Mercury = WebexPlugin.extend({
     return handlers;
   },
 
-  _onclose(event, sourceSocket) {
+  _onclose(event) {
     // I don't see any way to avoid the complexity or statement count in here.
     /* eslint complexity: [0] */
 
     try {
-      const isActiveSocket = sourceSocket === this.socket;
       const reason = event.reason && event.reason.toLowerCase();
+      const socketUrl = this.socket.url;
 
-      let socketUrl;
-      if (isActiveSocket && this.socket) {
-        // Active socket closed - get URL from current socket reference
-        socketUrl = this.socket.url;
-      } else if (sourceSocket) {
-        // Old socket closed - get URL from the closed socket
-        socketUrl = sourceSocket.url;
-      }
-
-      if (isActiveSocket) {
-        // Only tear down state if the currently active socket closed
-        if (this.socket) {
-          this.socket.removeAllListeners();
-        }
-        this.unset('socket');
-        this.connected = false;
-        this._emit('offline', event);
-        this.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(false);
-      } else {
-        // Old socket closed; do not flip connection state
-        this.logger.info(
-          `${this.namespace}: [shutdown] non-active socket closed, code=${event.code}`
-        );
-        // Clean up listeners from old socket now that it's closed
-        if (sourceSocket) {
-          sourceSocket.removeAllListeners();
-        }
-      }
+      this.socket.removeAllListeners();
+      this.unset('socket');
+      this.connected = false;
+      this._emit('offline', event);
+      this.webex.internal.newMetrics.callDiagnosticMetrics.setMercuryConnectedStatus(false);
 
       switch (event.code) {
         case 1003:
@@ -669,42 +490,20 @@ const Mercury = WebexPlugin.extend({
           this.logger.info(
             `${this.namespace}: Mercury service rejected last message; will not reconnect: ${event.reason}`
           );
-          if (isActiveSocket) this._emit('offline.permanent', event);
+          this._emit('offline.permanent', event);
           break;
         case 4000:
           // metric: disconnect
           this.logger.info(`${this.namespace}: socket replaced; will not reconnect`);
-          if (isActiveSocket) this._emit('offline.replaced', event);
-          // If not active, nothing to do
-          break;
-        case 4001:
-          // replaced during shutdown
-          if (isActiveSocket) {
-            // Server closed active socket with 4001, meaning it expected this connection
-            // to be replaced, but the switchover in _handleImminentShutdown failed.
-            // This is a permanent failure - do not reconnect.
-            this.logger.warn(
-              `${this.namespace}: active socket closed with 4001; shutdown switchover failed`
-            );
-            this._emit('offline.permanent', event);
-          } else {
-            // Expected: old socket closed after successful switchover
-            this.logger.info(
-              `${this.namespace}: old socket closed with 4001 (replaced during shutdown); no reconnect needed`
-            );
-            this._emit('offline.replaced', event);
-          }
+          this._emit('offline.replaced', event);
           break;
         case 1001:
         case 1005:
         case 1006:
         case 1011:
           this.logger.info(`${this.namespace}: socket disconnected; reconnecting`);
-          if (isActiveSocket) {
-            this._emit('offline.transient', event);
-            this.logger.info(`${this.namespace}: [shutdown] reconnecting active socket to recover`);
-            this._reconnect(socketUrl);
-          }
+          this._emit('offline.transient', event);
+          this._reconnect(socketUrl);
           // metric: disconnect
           // if (code == 1011 && reason !== ping error) metric: unexpected disconnect
           break;
@@ -712,18 +511,15 @@ const Mercury = WebexPlugin.extend({
         case 3050: // 3050 indicates logout form of closure, default to old behavior, use config reason defined by consumer to proceed with the permanent block
           if (normalReconnectReasons.includes(reason)) {
             this.logger.info(`${this.namespace}: socket disconnected; reconnecting`);
-            if (isActiveSocket) {
-              this._emit('offline.transient', event);
-              this.logger.info(`${this.namespace}: [shutdown] reconnecting due to normal close`);
-              this._reconnect(socketUrl);
-            }
+            this._emit('offline.transient', event);
+            this._reconnect(socketUrl);
             // metric: disconnect
             // if (reason === done forced) metric: force closure
           } else {
             this.logger.info(
               `${this.namespace}: socket disconnected; will not reconnect: ${event.reason}`
             );
-            if (isActiveSocket) this._emit('offline.permanent', event);
+            this._emit('offline.permanent', event);
           }
           break;
         default:
@@ -731,7 +527,7 @@ const Mercury = WebexPlugin.extend({
             `${this.namespace}: socket disconnected unexpectedly; will not reconnect`
           );
           // unexpected disconnect
-          if (isActiveSocket) this._emit('offline.permanent', event);
+          this._emit('offline.permanent', event);
       }
     } catch (error) {
       this.logger.error(`${this.namespace}: error occurred in close handler`, error);
@@ -746,16 +542,6 @@ const Mercury = WebexPlugin.extend({
       this.logger.debug(`${this.namespace}: message envelope: `, envelope);
     }
 
-    // Handle shutdown message shape: { type: 'shutdown' }
-    if (envelope && envelope.type === 'shutdown') {
-      this.logger.info(`${this.namespace}: [shutdown] imminent shutdown message received`);
-      this._emit('event:mercury_shutdown_imminent', envelope);
-
-      this._handleImminentShutdown();
-
-      return Promise.resolve();
-    }
-
     const {data} = envelope;
 
     this._applyOverrides(data);