@autofleet/rabbit 3.4.0-beta.18 → 3.4.0-beta.2

package/dist/index.js

@@ -168,14 +168,14 @@ class RabbitMq {
         this.publishChannelSetupPromise = null;
         this.connection = null;
         this.publishConnection = {
-            amqpConnection: null,
+            connection: null,
             creatingConnection: false,
             connectionCreatedEventName: 'publishConnectionCreated',
             connectionFailedEventName: 'publishConnectionFailed',
             blockReconnect: false,
         };
         this.consumeConnection = {
-            amqpConnection: null,
+            connection: null,
             creatingConnection: false,
             connectionCreatedEventName: 'consumeConnectionCreated',
             connectionFailedEventName: 'consumeConnectionFailed',
@@ -207,17 +207,17 @@ class RabbitMq {
         this.oldPublishChannel = null;
         this.oldPublishChannelSetupPromise = null;
         this.oldPublishConnection = {
-            amqpConnection: null,
+            connection: null,
             creatingConnection: false,
-            connectionCreatedEventName: 'oldPublishConnectionCreated',
-            connectionFailedEventName: 'oldPublishConnectionFailed',
+            connectionCreatedEventName: 'publishConnectionCreated',
+            connectionFailedEventName: 'publishConnectionFailed',
             blockReconnect: false,
         };
         this.oldConsumeConnection = {
-            amqpConnection: null,
+            connection: null,
             creatingConnection: false,
-            connectionCreatedEventName: 'oldConsumeConnectionCreated',
-            connectionFailedEventName: 'oldConsumeConnectionFailed',
+            connectionCreatedEventName: 'consumeConnectionCreated',
+            connectionFailedEventName: 'consumeConnectionFailed',
             blockReconnect: false,
         };
         this.oldCreatingConnection = false;
@@ -230,7 +230,7 @@ class RabbitMq {
     }
     async getConnection(connection) {
         return new Promise(async (resolve, reject) => {
-            const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+            const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
             if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -268,7 +268,13 @@ class RabbitMq {
             const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            connection.amqpConnection = newConnection;
+            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) {
@@ -301,7 +307,7 @@ class RabbitMq {
             newConnection.once('connect', async () => {
                 debug('rabbit: connection established');
                 connection.creatingConnection = false;
-                this.em.emit(connectionCreatedEventName, newConnection);
+                this.em.emit(connectionCreatedEventName, connection);
                 isResolved = true;
                 resolve(newConnection);
             });
@@ -316,7 +322,7 @@ class RabbitMq {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        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);
@@ -374,7 +380,7 @@ class RabbitMq {
         if (!channel) {
             throw new rabbitError_1.default('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.oldPublishConnection.amqpConnection?.isConnected() });
+        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
         return channel?.checkQueue(queue);
     }
     async deleteQueue(queue, connection) {
@@ -669,26 +675,26 @@ 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 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_1.default.error('rabbit: old isConnected - false');
+        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 oldChannel = await this.assertChannelOld({ connection: this.oldPublishConnection });
+        const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
         try {
             await Promise.all([
-                oldChannel.waitForConnect(),
-                ...this.oldConsumers.map((c) => oldChannel.checkQueue(c.queue)),
+                channel.waitForConnect(),
+                ...this.oldConsumers.map((c) => channel.checkQueue(c.queue)),
             ]);
         }
         catch (e) {
-            logger_1.default.error('rabbit: old isConnected - false');
+            logger_1.default.error('rabbit: isConnected - false');
             return false;
         }
-        logger_1.default.debug('rabbit: old isConnected - true');
+        logger_1.default.debug('rabbit: isConnected - true');
         return true;
     }
     async gracefulShutdown(signal) {
@@ -809,10 +815,8 @@ 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}`);
-        }
-        const channel = localConnection?.createChannel({ ...options });
+        debug('rabbit: getNewChannelOld', { localConnection });
+        const channel = localConnection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
             onClose?.(args);
@@ -829,7 +833,13 @@ class RabbitMq {
     }
     async getConnectionOld(connection) {
         return new Promise(async (resolve, reject) => {
-            const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+            const { connection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+            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,7 +877,13 @@ class RabbitMq {
             const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            connection.amqpConnection = newConnection;
+            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) {
@@ -899,7 +915,7 @@ class RabbitMq {
             newConnection.once('connect', async () => {
                 debug('rabbit: connection established');
                 connection.creatingConnection = false;
-                this.oldEm.emit(connectionCreatedEventName, newConnection);
+                this.oldEm.emit(connectionCreatedEventName, connection);
                 isResolved = true;
                 resolve(newConnection);
             });
@@ -978,6 +994,7 @@ class RabbitMq {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
                     if (this.oldPublishConnection === connection) {
+                        debug('rabbit: a new channel assigned to the oldPublishChannel', { connection });
                         this.oldPublishChannel = channel;
                     }
                     resolve(channel);

package/dist/lib/types.d.ts

@@ -44,7 +44,7 @@ export type AfConsumer = {
 };
 export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
 export type ConnectionData = {
-    amqpConnection: AmqpConnectionManager | null;
+    connection: AmqpConnectionManager | null;
     creatingConnection: boolean;
     connectionCreatedEventName: string;
     connectionFailedEventName: string;

package/package.json

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

package/src/index.ts

@@ -215,14 +215,14 @@ class RabbitMq implements IAfRabbitMq {
     this.publishChannelSetupPromise = null;
     this.connection = null;
     this.publishConnection = {
-      amqpConnection: null,
+      connection: null,
       creatingConnection: false,
       connectionCreatedEventName: 'publishConnectionCreated',
       connectionFailedEventName: 'publishConnectionFailed',
       blockReconnect: false,
     };
     this.consumeConnection = {
-      amqpConnection: null,
+      connection: null,
       creatingConnection: false,
       connectionCreatedEventName: 'consumeConnectionCreated',
       connectionFailedEventName: 'consumeConnectionFailed',
@@ -256,17 +256,17 @@ class RabbitMq implements IAfRabbitMq {
     this.oldPublishChannel = null;
     this.oldPublishChannelSetupPromise = null;
     this.oldPublishConnection = {
-      amqpConnection: null,
+      connection: null,
       creatingConnection: false,
-      connectionCreatedEventName: 'oldPublishConnectionCreated',
-      connectionFailedEventName: 'oldPublishConnectionFailed',
+      connectionCreatedEventName: 'publishConnectionCreated',
+      connectionFailedEventName: 'publishConnectionFailed',
       blockReconnect: false,
     };
     this.oldConsumeConnection = {
-      amqpConnection: null,
+      connection: null,
       creatingConnection: false,
-      connectionCreatedEventName: 'oldConsumeConnectionCreated',
-      connectionFailedEventName: 'oldConsumeConnectionFailed',
+      connectionCreatedEventName: 'consumeConnectionCreated',
+      connectionFailedEventName: 'consumeConnectionFailed',
       blockReconnect: false,
     };
     this.oldCreatingConnection = false;
@@ -409,13 +409,12 @@ class RabbitMq implements IAfRabbitMq {
   async getConnection(connection: ConnectionData) {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       const {
-        amqpConnection: connectionLocal,
+        connection: connectionLocal,
         creatingConnection,
         connectionCreatedEventName,
         connectionFailedEventName,
         blockReconnect,
       } = connection;
-
       if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -457,7 +456,12 @@ class RabbitMq implements IAfRabbitMq {
         findServers,
       });
 
-      connection.amqpConnection = newConnection;
+      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) {
@@ -492,7 +496,7 @@ class RabbitMq implements IAfRabbitMq {
       newConnection.once('connect', async () => {
         debug('rabbit: connection established');
         connection.creatingConnection = false;
-        this.em.emit(connectionCreatedEventName, newConnection);
+        this.em.emit(connectionCreatedEventName, connection);
         isResolved = true;
         resolve(newConnection);
       });
@@ -509,7 +513,7 @@ class RabbitMq implements IAfRabbitMq {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = localConnection?.createChannel({ ...options });
+    const channel = localConnection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -572,7 +576,7 @@ class RabbitMq implements IAfRabbitMq {
     if (!channel) {
       throw new RabbitError('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: this.oldPublishConnection.amqpConnection?.isConnected() });
+    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
     return channel?.checkQueue(queue);
   }
 
@@ -850,6 +854,7 @@ class RabbitMq implements IAfRabbitMq {
         ]);
       });
     }
+
     // TODO: [QUORUM-PHASE-3] Delete the old implementation
     await this.saveConsumerOld(queue, callback, options);
     const channelOld: ChannelWrapper = await this.getNewChannelOld({
@@ -922,26 +927,26 @@ 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 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: old isConnected - false');
+  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 oldChannel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
+    const channel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
     try {
       await Promise.all([
-        oldChannel.waitForConnect(),
-        ...this.oldConsumers.map((c: AfConsumer) => oldChannel.checkQueue(c.queue)),
+        channel.waitForConnect(),
+        ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
       ]);
     } catch (e) {
-      logger.error('rabbit: old isConnected - false');
+      logger.error('rabbit: isConnected - false');
       return false;
     }
-    logger.debug('rabbit: old isConnected - true');
+    logger.debug('rabbit: isConnected - true');
     return true;
   }
 
@@ -1078,12 +1083,8 @@ class RabbitMq implements IAfRabbitMq {
       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}`);
-    }
-
-    const channel = localConnection?.createChannel({ ...options });
+    debug('rabbit: getNewChannelOld', { localConnection });
+    const channel = localConnection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -1101,13 +1102,18 @@ class RabbitMq implements IAfRabbitMq {
   async getConnectionOld(connection: ConnectionData) {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       const {
-        amqpConnection: connectionLocal,
+        connection: connectionLocal,
         creatingConnection,
         connectionCreatedEventName,
         connectionFailedEventName,
         blockReconnect,
       } = connection;
 
+      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
@@ -1150,7 +1156,12 @@ class RabbitMq implements IAfRabbitMq {
         findServers,
       });
 
-      connection.amqpConnection = newConnection;
+      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) {
@@ -1184,7 +1195,7 @@ class RabbitMq implements IAfRabbitMq {
       newConnection.once('connect', async () => {
         debug('rabbit: connection established');
         connection.creatingConnection = false;
-        this.oldEm.emit(connectionCreatedEventName, newConnection);
+        this.oldEm.emit(connectionCreatedEventName, connection);
         isResolved = true;
         resolve(newConnection);
       });
@@ -1270,6 +1281,7 @@ class RabbitMq implements IAfRabbitMq {
             logger.error('rabbit: channel error', { err });
           });
           if (this.oldPublishConnection === connection) {
+            debug('rabbit: a new channel assigned to the oldPublishChannel', { connection });
             this.oldPublishChannel = channel;
           }
           resolve(channel);

package/src/lib/types.ts

@@ -64,7 +64,7 @@ export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
 };
 
 export type ConnectionData = {
-  amqpConnection: AmqpConnectionManager | null;
+  connection: AmqpConnectionManager | null;
   creatingConnection: boolean;
   connectionCreatedEventName: string;
   connectionFailedEventName: string;