@autofleet/rabbit 3.4.0-beta.1 → 3.4.0-beta.10

package/dist/index.js

@@ -209,15 +209,15 @@ class RabbitMq {
         this.oldPublishConnection = {
             connection: null,
             creatingConnection: false,
-            connectionCreatedEventName: 'publishConnectionCreated',
-            connectionFailedEventName: 'publishConnectionFailed',
+            connectionCreatedEventName: 'oldPublishConnectionCreated',
+            connectionFailedEventName: 'oldPublishConnectionFailed',
             blockReconnect: false,
         };
         this.oldConsumeConnection = {
             connection: null,
             creatingConnection: false,
-            connectionCreatedEventName: 'consumeConnectionCreated',
-            connectionFailedEventName: 'consumeConnectionFailed',
+            connectionCreatedEventName: 'oldConsumeConnectionCreated',
+            connectionFailedEventName: 'oldConsumeConnectionFailed',
             blockReconnect: false,
         };
         this.oldCreatingConnection = false;
@@ -231,6 +231,12 @@ class RabbitMq {
     async getConnection(connection) {
         return new Promise(async (resolve, reject) => {
             const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+            if (connection === this.publishConnection) {
+                debug('rabbit: getConnection publish', { connectionLocal, creatingConnection, blockReconnect });
+            }
+            else if (connection === this.consumeConnection) {
+                debug('rabbit: getConnection consume', { connectionLocal, creatingConnection, blockReconnect });
+            }
             if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -269,6 +275,12 @@ class RabbitMq {
                 findServers,
             });
             connection.connection = newConnection;
+            if (connection === this.publishConnection) {
+                debug('rabbit: publishConnection set');
+            }
+            else if (connection === this.consumeConnection) {
+                debug('rabbit: consumeConnection set');
+            }
             newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
@@ -316,7 +328,13 @@ class RabbitMq {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = localConnection.createChannel({ ...options });
+        if (connection === this.publishConnection) {
+            debug('rabbit: getNewChannel publish', { localConnection });
+        }
+        else if (connection === this.consumeConnection) {
+            debug('rabbit: getNewChannel consume', { localConnection });
+        }
+        const channel = localConnection?.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -611,22 +629,24 @@ class RabbitMq {
                 ]);
             });
         }
-        // TODO: [QUORUM-PHASE-3] Delete the old implementation
-        await this.saveConsumerOld(queue, callback, options);
-        const channelOld = await this.getNewChannelOld({
-            name: `consume-exchange-${exchange}-queue-${queue}-old`,
-            connection: this.oldConsumeConnection,
-        });
-        await channelOld.addSetup(async (c) => {
-            const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
-            await c.assertQueue(queue);
-            this.oldExchanges[exchange] = assertExchange;
-            await c.prefetch(limit, false);
-            return Promise.all([
-                c.bindQueue(queue, exchange, ''),
-                this.consumeOld(queue, callback, options),
-            ]);
-        });
+        else {
+            // TODO: [QUORUM-PHASE-3] Delete the old implementation
+            await this.saveConsumerOld(queue, callback, options);
+            const channelOld = await this.getNewChannelOld({
+                name: `consume-exchange-${exchange}-queue-${queue}-old`,
+                connection: this.oldConsumeConnection,
+            });
+            await channelOld.addSetup(async (c) => {
+                const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
+                await c.assertQueue(queue);
+                this.oldExchanges[exchange] = assertExchange;
+                await c.prefetch(limit, false);
+                return Promise.all([
+                    c.bindQueue(queue, exchange, ''),
+                    this.consumeOld(queue, callback, options),
+                ]);
+            });
+        }
     }
     // Used by the microservices to publish messages to the exchange
     // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
@@ -669,27 +689,47 @@ class RabbitMq {
     }
     // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
     async isConnected() {
-        debug('rabbit: start is connected');
-        const consumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
-        const publishConnection = await this.getConnectionOld(this.oldPublishConnection);
-        const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
-        try {
-            await Promise.all([
-                channel.waitForConnect(),
-                ...this.oldConsumers.map((c) => channel.checkQueue(c.queue)),
-            ]);
-        }
-        catch (e) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        logger_1.default.debug('rabbit: isConnected - true');
+        debug('rabbit: start old is connected', { connection: this.oldPublishConnection.connectionCreatedEventName });
         return true;
+        // debug('rabbit: start old is connected');
+        // const oldConsumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
+        // const oldPublishConnection = await this.getConnectionOld(this.oldPublishConnection);
+        // const oldIsConnected = oldConsumeConnection.isConnected() && oldPublishConnection.isConnected();
+        // if (!oldIsConnected) {
+        //   logger.error('rabbit: isConnected - false');
+        //   return false;
+        // }
+        // const oldChannel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
+        // try {
+        //   await Promise.all([
+        //     oldChannel.waitForConnect(),
+        //     ...this.oldConsumers.map((c: AfConsumer) => oldChannel.checkQueue(c.queue)),
+        //   ]);
+        // } catch (e) {
+        //   logger.error('rabbit: isConnected - false');
+        //   return false;
+        // }
+        // logger.debug('rabbit: old isConnected - true');
+        // debug('rabbit: start is connected');
+        // const consumeConnection = await this.getConnection(this.oldConsumeConnection);
+        // const publishConnection = await this.getConnection(this.oldPublishConnection);
+        // const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
+        // if (!isConnected) {
+        //   logger.error('rabbit: isConnected - false');
+        //   return false;
+        // }
+        // const channel: any = await this.assertChannel({ connection: this.oldPublishConnection });
+        // try {
+        //   await Promise.all([
+        //     channel.waitForConnect(),
+        //     ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+        //   ]);
+        // } catch (e) {
+        //   logger.error('rabbit: isConnected - false');
+        //   return false;
+        // }
+        // logger.debug('rabbit: isConnected - true');
+        // return true;
     }
     async gracefulShutdown(signal) {
         // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
@@ -711,6 +751,7 @@ class RabbitMq {
     }
     async consumeFromRabbitOld(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
+        debug('rabbit: consumeFromRabbitOld', { queue });
         RabbitMq.validateName('queue', queue);
         this.saveConsumerOld(queue, callback, options);
         const uniqueId = (0, node_crypto_1.randomUUID)();
@@ -802,6 +843,12 @@ class RabbitMq {
     // TODO: [QUORUM-PHASE-3] Delete all the function under this line (getNewChannelOld, getConnectionOld, assertQueueOld, setupQueueOld, saveConsumerOld)
     async getNewChannelOld({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
         let localConnection;
+        if (connection === this.oldPublishConnection) {
+            debug('rabbit: getConnectionOld publish', { connection });
+        }
+        else if (connection === this.oldConsumeConnection) {
+            debug('rabbit: getConnectionOld consume', { connection });
+        }
         try {
             localConnection = await this.getConnectionOld(connection);
         }
@@ -809,8 +856,11 @@ class RabbitMq {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
+        if (!localConnection) {
+            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+        }
         debug('rabbit: getNewChannelOld', { localConnection });
-        const channel = localConnection.createChannel({ ...options });
+        const channel = localConnection?.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -828,7 +878,12 @@ class RabbitMq {
     async getConnectionOld(connection) {
         return new Promise(async (resolve, reject) => {
             const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
-            debug('rabbit: getConnectionOld', { connectionLocal, creatingConnection, blockReconnect });
+            if (connection === this.oldPublishConnection) {
+                debug('rabbit: getConnectionOld publish', { connectionLocal, creatingConnection, blockReconnect });
+            }
+            else if (connection === this.oldConsumeConnection) {
+                debug('rabbit: getConnectionOld consume', { connectionLocal, creatingConnection, blockReconnect });
+            }
             if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -867,6 +922,12 @@ class RabbitMq {
                 findServers,
             });
             connection.connection = newConnection;
+            if (connection === this.oldPublishConnection) {
+                debug('rabbit: oldPublishConnection set');
+            }
+            else if (connection === this.oldConsumeConnection) {
+                debug('rabbit: oldConsumeConnection set');
+            }
             newConnection.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
@@ -966,6 +1027,12 @@ class RabbitMq {
         return queue;
     }
     async assertChannelOld({ force = false, connection }) {
+        if (connection === this.oldPublishConnection) {
+            debug('rabbit: assertChannelOld publish', { force, promiseSetup: this.oldPublishChannelSetupPromise });
+        }
+        else if (connection === this.oldConsumeConnection) {
+            debug('rabbit: assertChannelOld consume', { force, promiseSetup: this.oldPublishChannelSetupPromise });
+        }
         if (!this.oldPublishChannelSetupPromise) {
             this.oldPublishChannelSetupPromise = new Promise(async (resolve, reject) => {
                 if (this.oldPublishChannel && !force) {
@@ -973,6 +1040,12 @@ class RabbitMq {
                 }
                 try {
                     const channel = await this.getNewChannelOld({ connection });
+                    if (connection === this.oldPublishConnection) {
+                        debug('rabbit: old new channel got publish', { force, channel });
+                    }
+                    else if (connection === this.oldConsumeConnection) {
+                        debug('rabbit: old new channel got consume', { force, channel });
+                    }
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.4.0-beta.1",
+  "version": "3.4.0-beta.10",
   "description": "",
   "main": "dist/index.js",
   "engines": {

package/src/index.ts

@@ -258,15 +258,15 @@ class RabbitMq implements IAfRabbitMq {
     this.oldPublishConnection = {
       connection: null,
       creatingConnection: false,
-      connectionCreatedEventName: 'publishConnectionCreated',
-      connectionFailedEventName: 'publishConnectionFailed',
+      connectionCreatedEventName: 'oldPublishConnectionCreated',
+      connectionFailedEventName: 'oldPublishConnectionFailed',
       blockReconnect: false,
     };
     this.oldConsumeConnection = {
       connection: null,
       creatingConnection: false,
-      connectionCreatedEventName: 'consumeConnectionCreated',
-      connectionFailedEventName: 'consumeConnectionFailed',
+      connectionCreatedEventName: 'oldConsumeConnectionCreated',
+      connectionFailedEventName: 'oldConsumeConnectionFailed',
       blockReconnect: false,
     };
     this.oldCreatingConnection = false;
@@ -415,6 +415,11 @@ class RabbitMq implements IAfRabbitMq {
         connectionFailedEventName,
         blockReconnect,
       } = connection;
+      if (connection === this.publishConnection) {
+        debug('rabbit: getConnection publish', { connectionLocal, creatingConnection, blockReconnect });
+      } else if (connection === this.consumeConnection) {
+        debug('rabbit: getConnection consume', { connectionLocal, creatingConnection, blockReconnect });
+      }
       if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -457,6 +462,11 @@ class RabbitMq implements IAfRabbitMq {
       });
 
       connection.connection = newConnection;
+      if (connection === this.publishConnection) {
+        debug('rabbit: publishConnection set');
+      } else if (connection === this.consumeConnection) {
+        debug('rabbit: consumeConnection set');
+      }
       newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
@@ -508,7 +518,12 @@ class RabbitMq implements IAfRabbitMq {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = localConnection.createChannel({ ...options });
+    if (connection === this.publishConnection) {
+      debug('rabbit: getNewChannel publish', { localConnection });
+    } else if (connection === this.consumeConnection) {
+      debug('rabbit: getNewChannel consume', { localConnection });
+    }
+    const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -848,28 +863,28 @@ class RabbitMq implements IAfRabbitMq {
           ),
         ]);
       });
+    } else {
+      // TODO: [QUORUM-PHASE-3] Delete the old implementation
+      await this.saveConsumerOld(queue, callback, options);
+      const channelOld: ChannelWrapper = await this.getNewChannelOld({
+        name: `consume-exchange-${exchange}-queue-${queue}-old`,
+        connection: this.oldConsumeConnection,
+      });
+      await channelOld.addSetup(async (c: ConfirmChannel) => {
+        const assertExchange = await assertExchangeFanout(c, exchange);
+        await c.assertQueue(queue);
+        this.oldExchanges[exchange] = assertExchange;
+        await c.prefetch(limit, false);
+        return Promise.all([
+          c.bindQueue(queue, exchange, ''),
+          this.consumeOld(
+            queue,
+            callback,
+            options,
+          ),
+        ]);
+      });
     }
-
-    // TODO: [QUORUM-PHASE-3] Delete the old implementation
-    await this.saveConsumerOld(queue, callback, options);
-    const channelOld: ChannelWrapper = await this.getNewChannelOld({
-      name: `consume-exchange-${exchange}-queue-${queue}-old`,
-      connection: this.oldConsumeConnection,
-    });
-    await channelOld.addSetup(async (c: ConfirmChannel) => {
-      const assertExchange = await assertExchangeFanout(c, exchange);
-      await c.assertQueue(queue);
-      this.oldExchanges[exchange] = assertExchange;
-      await c.prefetch(limit, false);
-      return Promise.all([
-        c.bindQueue(queue, exchange, ''),
-        this.consumeOld(
-          queue,
-          callback,
-          options,
-        ),
-      ]);
-    });
   }
 
   // Used by the microservices to publish messages to the exchange
@@ -923,26 +938,48 @@ class RabbitMq implements IAfRabbitMq {
 
   // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
   async isConnected() : Promise<boolean> {
-    debug('rabbit: start is connected');
-    const consumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
-    const publishConnection = await this.getConnectionOld(this.oldPublishConnection);
-    const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const channel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
-    try {
-      await Promise.all([
-        channel.waitForConnect(),
-        ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
-      ]);
-    } catch (e) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    logger.debug('rabbit: isConnected - true');
+    debug('rabbit: start old is connected', { connection: this.oldPublishConnection.connectionCreatedEventName });
     return true;
+    // debug('rabbit: start old is connected');
+    // const oldConsumeConnection = await this.getConnectionOld(this.oldConsumeConnection);
+    // const oldPublishConnection = await this.getConnectionOld(this.oldPublishConnection);
+    // const oldIsConnected = oldConsumeConnection.isConnected() && oldPublishConnection.isConnected();
+    // if (!oldIsConnected) {
+    //   logger.error('rabbit: isConnected - false');
+    //   return false;
+    // }
+    // const oldChannel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
+    // try {
+    //   await Promise.all([
+    //     oldChannel.waitForConnect(),
+    //     ...this.oldConsumers.map((c: AfConsumer) => oldChannel.checkQueue(c.queue)),
+    //   ]);
+    // } catch (e) {
+    //   logger.error('rabbit: isConnected - false');
+    //   return false;
+    // }
+    // logger.debug('rabbit: old isConnected - true');
+
+    // debug('rabbit: start is connected');
+    // const consumeConnection = await this.getConnection(this.oldConsumeConnection);
+    // const publishConnection = await this.getConnection(this.oldPublishConnection);
+    // const isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
+    // if (!isConnected) {
+    //   logger.error('rabbit: isConnected - false');
+    //   return false;
+    // }
+    // const channel: any = await this.assertChannel({ connection: this.oldPublishConnection });
+    // try {
+    //   await Promise.all([
+    //     channel.waitForConnect(),
+    //     ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+    //   ]);
+    // } catch (e) {
+    //   logger.error('rabbit: isConnected - false');
+    //   return false;
+    // }
+    // logger.debug('rabbit: isConnected - true');
+    // return true;
   }
 
   async gracefulShutdown(signal: string) : Promise<void> {
@@ -965,6 +1002,7 @@ class RabbitMq implements IAfRabbitMq {
 
   private async consumeFromRabbitOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
+    debug('rabbit: consumeFromRabbitOld', { queue });
     RabbitMq.validateName('queue', queue);
     this.saveConsumerOld(queue, callback, options);
     const uniqueId = randomUUID();
@@ -1072,14 +1110,24 @@ class RabbitMq implements IAfRabbitMq {
     name = rand().toString(), onClose = null, options = {}, connection,
   }: newChannelOpts) {
     let localConnection!: AmqpConnectionManager;
+    if (connection === this.oldPublishConnection) {
+      debug('rabbit: getConnectionOld publish', { connection });
+    } else if (connection === this.oldConsumeConnection) {
+      debug('rabbit: getConnectionOld consume', { connection });
+    }
     try {
       localConnection = await this.getConnectionOld(connection);
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
+
+    if (!localConnection) {
+      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+    }
+
     debug('rabbit: getNewChannelOld', { localConnection });
-    const channel = localConnection.createChannel({ ...options });
+    const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -1103,7 +1151,12 @@ class RabbitMq implements IAfRabbitMq {
         connectionFailedEventName,
         blockReconnect,
       } = connection;
-      debug('rabbit: getConnectionOld', { connectionLocal, creatingConnection, blockReconnect });
+
+      if (connection === this.oldPublishConnection) {
+        debug('rabbit: getConnectionOld publish', { connectionLocal, creatingConnection, blockReconnect });
+      } else if (connection === this.oldConsumeConnection) {
+        debug('rabbit: getConnectionOld consume', { connectionLocal, creatingConnection, blockReconnect });
+      }
       if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -1147,6 +1200,11 @@ class RabbitMq implements IAfRabbitMq {
       });
 
       connection.connection = newConnection;
+      if (connection === this.oldPublishConnection) {
+        debug('rabbit: oldPublishConnection set');
+      } else if (connection === this.oldConsumeConnection) {
+        debug('rabbit: oldConsumeConnection set');
+      }
       newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
@@ -1254,6 +1312,11 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async assertChannelOld({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
+    if (connection === this.oldPublishConnection) {
+      debug('rabbit: assertChannelOld publish', { force, promiseSetup: this.oldPublishChannelSetupPromise });
+    } else if (connection === this.oldConsumeConnection) {
+      debug('rabbit: assertChannelOld consume', { force, promiseSetup: this.oldPublishChannelSetupPromise });
+    }
     if (!this.oldPublishChannelSetupPromise) {
       this.oldPublishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
         if (this.oldPublishChannel && !force) {
@@ -1262,6 +1325,11 @@ class RabbitMq implements IAfRabbitMq {
 
         try {
           const channel = await this.getNewChannelOld({ connection });
+          if (connection === this.oldPublishConnection) {
+            debug('rabbit: old new channel got publish', { force, channel });
+          } else if (connection === this.oldConsumeConnection) {
+            debug('rabbit: old new channel got consume', { force, channel });
+          }
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });