@onlineapps/mq-client-core 4.0.1 → 4.2.0

package/src/transports/rabbitmqClient.js

@@ -1416,6 +1416,70 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Race an `amqp.connect()` handshake against its `connectTimeout`, and own the
+   * handshake the timeout abandons.
+   *
+   * When the timeout wins, the race rejects but the handshake does not stop: it
+   * can still complete into a full AMQP connection that no field of this client
+   * points at, so `disconnect()` never closes it and it keeps the process alive
+   * (INFRA 359, measured with a proxy delaying the handshake past the timeout).
+   * The rejection the caller receives is unchanged; what changes is that the
+   * abandoned handshake is closed the moment it completes.
+   *
+   * @private
+   * @param {Promise<Object>} connectPromise - the handshake from `amqp.connect()`
+   * @param {Promise<never>} timeoutPromise - rejects with the timeout error
+   * @param {string} phase - 'connect' or 'reconnect', named in the log lines
+   * @returns {Promise<Object>} the connection, when the handshake won the race
+   */
+  async _raceHandshake(connectPromise, timeoutPromise, phase) {
+    let abandoned = false;
+    const timeoutLeg = timeoutPromise.catch((err) => {
+      abandoned = true;
+      throw err;
+    });
+    try {
+      return await Promise.race([connectPromise, timeoutLeg]);
+    } catch (err) {
+      if (abandoned) {
+        this._closeAbandonedHandshake(connectPromise, phase);
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Close the connection an abandoned handshake produces, whenever it completes.
+   * A handshake that fails after its timeout opened nothing; its error adds
+   * nothing to the timeout the caller already received.
+   * @private
+   * @param {Promise<Object>} connectPromise - the handshake the timeout abandoned
+   * @param {string} phase - 'connect' or 'reconnect'
+   */
+  _closeAbandonedHandshake(connectPromise, phase) {
+    connectPromise.then(
+      async (late) => {
+        this._logger.warn(
+          `[RabbitMQClient] Handshake completed after the ${phase} timeout (${this._connectTimeout} ms) - `
+            + 'closing that connection, nothing in this client owns it'
+        );
+        try {
+          await late.close();
+        } catch (closeErr) {
+          this._logger.warn(
+            `[RabbitMQClient] Error closing the connection whose handshake outlived the ${phase} timeout: ${closeErr.message}`
+          );
+        }
+      },
+      (lateErr) => {
+        this._logger.debug(
+          `[RabbitMQClient] Handshake abandoned by the ${phase} timeout failed afterwards: ${lateErr.message}`
+        );
+      }
+    );
+  }
+
   /**
    * Clear all active timers
    * @private
@@ -1459,7 +1523,7 @@ class RabbitMQClient extends EventEmitter {
         }
       });
       this._logger.debug('[RabbitMQClient] Starting connection race...');
-      this._connection = await Promise.race([connectPromise, timeoutPromise]);
+      this._connection = await this._raceHandshake(connectPromise, timeoutPromise, 'connect');
       if (connectTimeoutTimer) {
         this._clearTimeout(connectTimeoutTimer);
         connectTimeoutTimer = null;
@@ -3437,9 +3501,11 @@ class RabbitMQClient extends EventEmitter {
     // leaves exactly those without a route of their own, because a dead-letter
     // route on a dead-letter queue is a loop or a chain with no end
     // (`mq-consumer-contract` 002 point 2, 003 point 2). Until d.452 the gate
-    // asked only the first question, so the operator's own queue was
-    // unconsumable and its reader — the delivery dispatcher — could not attach
-    // at all. The second question is derived from the templates
+    // asked only the first question, so the operator's own queue could not be
+    // consumed through this library at all. Who reads such a queue is that
+    // service's own fact, not this file's —
+    // @see api/infra/api_monitoring/src/consumer/deadLetterPeek.js
+    // The second question is derived from the templates
     // (`queueConfig.isDeadLetterTarget()`), never from a list of names, so it
     // cannot fall behind them; every other queue with no route is refused
     // exactly as before, with the same sentence.
@@ -3939,7 +4005,7 @@ class RabbitMQClient extends EventEmitter {
           )), this._connectTimeout);
         });
 
-        const revived = await Promise.race([connectPromise, timeoutPromise]);
+        const revived = await this._raceHandshake(connectPromise, timeoutPromise, 'reconnect');
 
         // The caller may have disposed of this client while that handshake was
         // in flight. The socket is up, and it belongs to nobody: keeping it