@autofleet/rabbit 3.4.0-beta--beta--0.0 → 3.4.0-beta.0

package/src/index.ts

@@ -1,5 +1,4 @@
-/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
-
+/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars,no-param-reassign */
 import { EventEmitter, once } from 'events';
 import { promisify } from 'util';
 import moment from 'moment';
@@ -20,8 +19,6 @@ import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   AUTOMATION_ID_HEADER,
-  CONNECTION_CREATED_CONST,
-  CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
@@ -40,8 +37,8 @@ import {
   CONSUMER_DEFAULT_OPTIONS,
   QueueSetupPromisesDictionary,
   AssertExchangePromisesDictionary,
+  ConnectionData,
 } from './lib/types';
-import { SendTaskOptions, TaskData } from './lib/celery';
 
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger.debug.bind(logger);
@@ -87,11 +84,13 @@ type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
   options?: CreateChannelOpts | undefined;
+  connection: ConnectionData;
 };
 
 type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
+  connection: ConnectionData;
 }
 
 type AfConsumer = {
@@ -144,7 +143,7 @@ class RabbitMq implements IAfRabbitMq {
 
   RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
-  channel: ChannelWrapper | null;
+  publishChannel: ChannelWrapper | null;
 
   publishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
@@ -152,6 +151,10 @@ class RabbitMq implements IAfRabbitMq {
 
   connection: AmqpConnectionManager | null | undefined
 
+  publishConnection: ConnectionData
+
+  consumeConnection: ConnectionData
+
   em: EventEmitter;
 
   creatingConnection: boolean;
@@ -180,13 +183,15 @@ class RabbitMq implements IAfRabbitMq {
   private vhost = 'quorum-vhost';
 
   // TODO:[QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
-  oldChannel: ChannelWrapper | null;
+  oldPublishChannel: ChannelWrapper | null;
 
   oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
   oldBlockReconnect: boolean | null | undefined
 
-  oldConnection: AmqpConnectionManager | null | undefined
+  oldPublishConnection: ConnectionData
+
+  oldConsumeConnection: ConnectionData
 
   oldEm: EventEmitter;
 
@@ -206,9 +211,23 @@ class RabbitMq implements IAfRabbitMq {
 
   constructor(options: AfRabbitOptions = {}, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
-    this.channel = null;
+    this.publishChannel = null;
     this.publishChannelSetupPromise = null;
     this.connection = null;
+    this.publishConnection = {
+      connection: null,
+      creatingConnection: false,
+      connectionCreatedEventName: 'publishConnectionCreated',
+      connectionFailedEventName: 'publishConnectionFailed',
+      blockReconnect: false,
+    };
+    this.consumeConnection = {
+      connection: null,
+      creatingConnection: false,
+      connectionCreatedEventName: 'consumeConnectionCreated',
+      connectionFailedEventName: 'consumeConnectionFailed',
+      blockReconnect: false,
+    };
     this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
@@ -234,9 +253,22 @@ class RabbitMq implements IAfRabbitMq {
 
     // TODO: [QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
     this.oldEm = new EventEmitter();
-    this.oldChannel = null;
+    this.oldPublishChannel = null;
     this.oldPublishChannelSetupPromise = null;
-    this.oldConnection = null;
+    this.oldPublishConnection = {
+      connection: null,
+      creatingConnection: false,
+      connectionCreatedEventName: 'publishConnectionCreated',
+      connectionFailedEventName: 'publishConnectionFailed',
+      blockReconnect: false,
+    };
+    this.oldConsumeConnection = {
+      connection: null,
+      creatingConnection: false,
+      connectionCreatedEventName: 'consumeConnectionCreated',
+      connectionFailedEventName: 'consumeConnectionFailed',
+      blockReconnect: false,
+    };
     this.oldCreatingConnection = false;
     this.oldExchanges = {};
     this.oldQueues = {};
@@ -374,30 +406,37 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnection() {
+  async getConnection(connection: ConnectionData) {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      if (this.blockReconnect) {
+      const {
+        connection: connectionLocal,
+        creatingConnection,
+        connectionCreatedEventName,
+        connectionFailedEventName,
+        blockReconnect,
+      } = connection;
+      if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (this.connection !== null) {
-        if (this.options?.disableReconnect || this.connection?.isConnected()) {
+      if (connectionLocal !== null) {
+        if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
-          return resolve(this.connection);
+          return resolve(connectionLocal);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (this.creatingConnection) {
+      if (creatingConnection) {
         debug('rabbit: creating connection emi');
-        this.em.once(CONNECTION_CREATED_CONST, resolve);
-        this.em.once(CONNECTION_FAILED_CONST, reject);
+        this.em.once(connectionCreatedEventName, resolve);
+        this.em.once(connectionFailedEventName, reject);
         return;
       }
-      this.creatingConnection = true;
+      connection.creatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -413,61 +452,63 @@ class RabbitMq implements IAfRabbitMq {
       };
 
       const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
+      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      this.connection = connection;
-      this.connection.on('error', (err) => {
+      connection.connection = newConnection;
+      newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
+          this.em.emit(connectionFailedEventName, err);
         }
       });
 
-      this.connection.on('connectFailed', (err) => {
+      newConnection.on('connectFailed', (err) => {
         this.consumersTags = [];
         logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
+          this.em.emit(connectionFailedEventName, err);
         }
       });
 
-      this.connection.on('disconnect', ({ err }) => {
-        // this.channel = null;
+      newConnection.on('disconnect', ({ err }) => {
+      // this.publishChannel = null;
         this.consumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
           logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-          this.blockReconnect = true;
+          connection.blockReconnect = true;
         } else {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
 
-      this.connection.once('connect', async () => {
+      newConnection.once('connect', async () => {
         debug('rabbit: connection established');
-        this.creatingConnection = false;
-        this.em.emit(CONNECTION_CREATED_CONST, connection);
+        connection.creatingConnection = false;
+        this.em.emit(connectionCreatedEventName, connection);
         isResolved = true;
-        resolve(connection);
+        resolve(newConnection);
       });
     });
   }
 
-  async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
+  async getNewChannel({
+    name = rand().toString(), onClose = null, options = {}, connection,
+  }: newChannelOpts) {
+    let localConnection!: AmqpConnectionManager;
     try {
-      connection = await this.getConnection();
+      localConnection = await this.getConnection(connection);
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = connection.createChannel({ ...options });
+    const channel = localConnection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -482,19 +523,21 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
+  async assertChannel({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.channel && !force) {
-          return resolve(this.channel);
+        if (this.publishChannel && !force) {
+          return resolve(this.publishChannel);
         }
 
         try {
-          const channel = await this.getNewChannel({});
+          const channel = await this.getNewChannel({ connection });
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
-          this.channel = channel;
+          if (this.publishConnection === connection) {
+            this.publishChannel = channel;
+          }
           resolve(channel);
         } catch (e) {
           reject(e);
@@ -504,8 +547,8 @@ class RabbitMq implements IAfRabbitMq {
     return this.publishChannelSetupPromise;
   }
 
-  async assertExchange(exchangeName: string, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannel();
+  async assertExchange(exchangeName: string, connection: ConnectionData) {
+    const channel: ChannelWrapper = await this.assertChannel({ connection });
 
     if (this.exchanges[exchangeName]) {
       delete this.assertExchangePromises[exchangeName];
@@ -524,7 +567,7 @@ class RabbitMq implements IAfRabbitMq {
   // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
   async getQueueLength(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const { oldChannel: channel } = this;
+    const { oldPublishChannel: channel } = this;
     if (!channel) {
       throw new RabbitError('channel is not defined');
     }
@@ -532,9 +575,9 @@ class RabbitMq implements IAfRabbitMq {
     return channel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string) {
+  private async deleteQueue(queue: string, connection: ConnectionData) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel({ connection });
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
@@ -543,13 +586,14 @@ class RabbitMq implements IAfRabbitMq {
 
   // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
   async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannelOld();
+    const channel: ChannelWrapper = await this.assertChannelOld({ connection: this.oldPublishConnection });
     await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.bindQueue(queue, exchange, ''));
     return channel.bindQueue(queue, exchange, '');
   }
 
   async setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
+    const connection = this.publishConnection;
     const localeOptions = {
       ...options,
       durable: true,
@@ -560,7 +604,7 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannel();
+      const channel: ChannelWrapper = await this.assertChannel({ connection });
       debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup(async (setupChannel: ConfirmChannel) => {
         await setupChannel.assertQueue(queueName, localeOptions);
@@ -571,8 +615,8 @@ class RabbitMq implements IAfRabbitMq {
       logger.error('rabbit: assertQueue error', { queueName, options, error: e });
       if (!this.options?.dontRetryAssert) {
         debug('retrying assertQueue', { queueName });
-        const channel = await this.assertChannel({ force: true });
-        await this.deleteQueue(queueName);
+        const channel = await this.assertChannel({ force: true, connection });
+        await this.deleteQueue(queueName, connection);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
@@ -685,7 +729,7 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannel({});
+    const channel = await this.getNewChannel({ connection: this.consumeConnection });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
       const q = await this.assertQueue(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
@@ -785,7 +829,10 @@ class RabbitMq implements IAfRabbitMq {
     if (options?.isQuorumQueue !== false) {
       await this.assertVHost();
       await this.saveConsumer(queue, callback, options);
-      const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+      const channel: ChannelWrapper = await this.getNewChannel({
+        name: `consume-exchange-${exchange}-queue-${queue}`,
+        connection: this.consumeConnection,
+      });
 
       await channel.addSetup(async (c: ConfirmChannel) => {
         const assertExchange = await assertExchangeFanout(c, exchange);
@@ -805,7 +852,10 @@ class RabbitMq implements IAfRabbitMq {
 
     // 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` });
+    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);
@@ -827,8 +877,8 @@ class RabbitMq implements IAfRabbitMq {
   async publish(exchange: string, content: any, customHeaders?: any) : Promise<boolean> {
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannelOld();
-      await this.assertExchangeOld(exchange);
+      const channel: ChannelWrapper = await this.assertChannelOld({ connection: this.oldPublishConnection });
+      await this.assertExchangeOld(exchange, this.oldPublishConnection);
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
@@ -844,7 +894,7 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
   ): Promise<boolean | undefined> {
     try {
-      await this.assertChannelOld();
+      await this.assertChannelOld({ connection: this.oldPublishConnection });
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
       throw e;
@@ -859,7 +909,7 @@ class RabbitMq implements IAfRabbitMq {
     }
 
     try {
-      const res = await this.oldChannel?.sendToQueue(queue,
+      const res = await this.oldPublishChannel?.sendToQueue(queue,
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
       debug(`rabbit: sending to queue ${queue}`, { res });
@@ -871,61 +921,17 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async sendToCeleryQueue(
-    data: TaskData,
-    taskName: string,
-    queueName: string,
-  ): Promise<boolean | undefined> {
-    const taskId = randomUUID();
-
-    // Celery-compatible message body
-    const taskPayload = {
-      task: taskName,
-      id: taskId,
-      args: [data],
-      kwargs: {},
-      retries: 0,
-      eta: null,
-    };
-
-    // Celery-compatible AMQP headers
-    const publishOptions = {
-      contentType: 'application/json',
-      contentEncoding: 'utf-8',
-      deliveryMode: 2, // persistent
-      headers: {
-        lang: 'py',
-        task: taskName,
-        id: taskId,
-        root_id: taskId,
-        parent_id: null,
-        group: null,
-        retries: 0,
-        eta: null,
-      },
-    };
-
-    try {
-      return await this.sendToQueue(queueName, taskPayload, undefined, publishOptions);
-    } catch (e) {
-      const isConnected = await this.isConnected();
-      logger.error(
-        `rabbit sendToQueue: failed to send to queue ${queueName}, isConnected: ${isConnected}`,
-        { e },
-      );
-      throw e;
-    }
-  }
-
   // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
   async isConnected() : Promise<boolean> {
-    const connection = await this.getConnectionOld();
-    const isConnected = connection.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.error('rabbit: isConnected - false');
       return false;
     }
-    const channel: any = await this.assertChannelOld();
+    const channel: any = await this.assertChannelOld({ connection: this.oldPublishConnection });
     try {
       await Promise.all([
         channel.waitForConnect(),
@@ -935,7 +941,7 @@ class RabbitMq implements IAfRabbitMq {
       logger.error('rabbit: isConnected - false');
       return false;
     }
-    logger.info('rabbit: isConnected - true');
+    logger.debug('rabbit: isConnected - true');
     return true;
   }
 
@@ -971,7 +977,7 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannelOld({});
+    const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
       const q = await this.assertQueueOld(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
@@ -1062,15 +1068,17 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   // TODO: [QUORUM-PHASE-3] Delete all the function under this line (getNewChannelOld, getConnectionOld, assertQueueOld, setupQueueOld, saveConsumerOld)
-  async getNewChannelOld({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
+  async getNewChannelOld({
+    name = rand().toString(), onClose = null, options = {}, connection,
+  }: newChannelOpts) {
+    let localConnection!: AmqpConnectionManager;
     try {
-      connection = await this.getConnectionOld();
+      localConnection = await this.getConnectionOld(connection);
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = connection.createChannel({ ...options });
+    const channel = localConnection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -1085,30 +1093,37 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnectionOld() {
+  async getConnectionOld(connection: ConnectionData) {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      if (this.oldBlockReconnect) {
+      const {
+        connection: connectionLocal,
+        creatingConnection,
+        connectionCreatedEventName,
+        connectionFailedEventName,
+        blockReconnect,
+      } = connection;
+      if (blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (this.oldConnection !== null) {
-        if (this.options?.disableReconnect || this.oldConnection?.isConnected()) {
+      if (connectionLocal !== null) {
+        if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
-          return resolve(this.oldConnection);
+          return resolve(connectionLocal);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (this.oldCreatingConnection) {
+      if (creatingConnection) {
         debug('rabbit: creating connection emi');
-        this.oldEm.once(CONNECTION_CREATED_CONST, resolve);
-        this.oldEm.once(CONNECTION_FAILED_CONST, reject);
+        this.oldEm.once(connectionCreatedEventName, resolve);
+        this.oldEm.once(connectionFailedEventName, reject);
         return;
       }
-      this.oldCreatingConnection = true;
+      connection.creatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -1125,47 +1140,47 @@ class RabbitMq implements IAfRabbitMq {
       };
 
       const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
+      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      this.oldConnection = connection;
-      this.oldConnection.on('error', (err) => {
+      connection.connection = newConnection;
+      newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.oldEm.emit(CONNECTION_FAILED_CONST, err);
+          this.oldEm.emit(connectionFailedEventName, err);
         }
       });
 
-      this.oldConnection.on('connectFailed', (err) => {
+      newConnection.on('connectFailed', (err) => {
         this.oldConsumersTags = [];
         logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.oldEm.emit(CONNECTION_FAILED_CONST, err);
+          this.oldEm.emit(connectionFailedEventName, err);
         }
       });
 
-      this.oldConnection.on('disconnect', ({ err }) => {
+      newConnection.on('disconnect', ({ err }) => {
         this.oldConsumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
           logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-          this.oldBlockReconnect = true;
+          connection.blockReconnect = true;
         } else {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
 
-      this.oldConnection.once('connect', async () => {
+      newConnection.once('connect', async () => {
         debug('rabbit: connection established');
-        this.oldCreatingConnection = false;
-        this.oldEm.emit(CONNECTION_CREATED_CONST, connection);
+        connection.creatingConnection = false;
+        this.oldEm.emit(connectionCreatedEventName, connection);
         isResolved = true;
-        resolve(connection);
+        resolve(newConnection);
       });
     });
   }
@@ -1199,6 +1214,7 @@ class RabbitMq implements IAfRabbitMq {
 
   async setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
+    const connection = this.oldPublishConnection;
     const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
     const localeOptions = {
       ...options,
@@ -1210,7 +1226,7 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannelOld();
+      const channel: ChannelWrapper = await this.assertChannelOld({ connection });
       debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
       debug('assertQueue->channel.assertQueue', { queueName });
@@ -1219,8 +1235,8 @@ class RabbitMq implements IAfRabbitMq {
       logger.error('rabbit: assertQueue error', { queueName, options, error: e });
       if (!this.options?.dontRetryAssert) {
         debug('retrying assertQueue', { queueName });
-        const channel = await this.assertChannelOld({ force: true });
-        await this.deleteQueueOld(queueName);
+        const channel = await this.assertChannelOld({ force: true, connection });
+        await this.deleteQueueOld(queueName, connection);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
@@ -1235,19 +1251,22 @@ class RabbitMq implements IAfRabbitMq {
     return queue;
   }
 
-  async assertChannelOld({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
+  async assertChannelOld({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
     if (!this.oldPublishChannelSetupPromise) {
       this.oldPublishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.oldChannel && !force) {
-          return resolve(this.oldChannel);
+        if (this.oldPublishChannel && !force) {
+          return resolve(this.oldPublishChannel);
         }
 
         try {
-          const channel = await this.getNewChannelOld({});
+          const channel = await this.getNewChannelOld({ connection });
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
-          this.oldChannel = channel;
+          if (this.oldPublishConnection === connection) {
+            debug('rabbit: a new channel assigned to the oldPublishChannel', { connection });
+            this.oldPublishChannel = channel;
+          }
           resolve(channel);
         } catch (e) {
           reject(e);
@@ -1257,17 +1276,17 @@ class RabbitMq implements IAfRabbitMq {
     return this.oldPublishChannelSetupPromise;
   }
 
-  private async deleteQueueOld(queue: string) {
+  private async deleteQueueOld(queue: string, connection: ConnectionData) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannelOld();
+    const channel: ChannelWrapper = await this.assertChannelOld({ connection });
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async assertExchangeOld(exchangeName: string, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannelOld();
+  async assertExchangeOld(exchangeName: string, connection: ConnectionData) {
+    const channel: ChannelWrapper = await this.assertChannelOld({ connection });
 
     if (this.oldExchanges[exchangeName]) {
       delete this.oldAssertExchangePromises[exchangeName];