rascal 17.0.0 → 17.0.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## 17.0.1
+
+- Rework the republish and forward recovery strategies to remove remote chance of repeat ack/nack
+
 ## 17.0.0
 
 - Updated the configuration processing as per https://github.com/guidesmiths/rascal/issues/219

package/lib/amqp/SubscriberError.js

@@ -68,13 +68,12 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
         execute(session, message, err, strategyConfig, next) {
           debug('Republishing message: %s', message.properties.messageId);
 
-          const once = _.once(next);
           const originalQueue = _.get(message, 'properties.headers.rascal.originalQueue');
           const republished = _.get(message, ['properties', 'headers', 'rascal', 'recovery', originalQueue, 'republished'], 0);
 
           if (strategyConfig.attempts && strategyConfig.attempts <= republished) {
             debug('Skipping recovery - message: %s has already been republished %d times.', message.properties.messageId, republished);
-            return once(null, false);
+            return next(null, false);
           }
 
           const publishOptions = _.cloneDeep(message.properties);
@@ -87,33 +86,50 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
 
           if (strategyConfig.immediateNack) _.set(publishOptions, ['headers', 'rascal', 'recovery', originalQueue, 'immediateNack'], true);
 
-          vhost.getConfirmChannel((err, publisherChannel) => {
-            const nackMessage = (err) => {
-              session._nack(message, (_nackErr) => {
-                // nackError just means the channel was already closed meaning the original message would have been rolled back
-                once(err);
-              });
-            };
+          const ackMessage = () => {
+            session._ack(message, (err) => {
+              next(err, true);
+            });
+          };
 
-            if (err) return nackMessage(err);
+          const nackMessage = (err) => {
+            session._nack(message, (_nackErr) => {
+              // nackError just means the channel was already closed meaning the original message would have been rolled back
+              next(err);
+            });
+          };
+
+          const ackOrNack = _.once((err) => {
+            return err ? nackMessage(err) : ackMessage();
+          });
+
+          vhost.getConfirmChannel((err, publisherChannel) => {
+            if (err) return ackOrNack(err);
 
-            if (!publisherChannel) return nackMessage(new Error('Unable to handle subscriber error by republishing. The VHost is shutting down'));
+            if (!publisherChannel) return ackOrNack(new Error('Unable to handle subscriber error by republishing. The VHost is shutting down'));
 
             publisherChannel.on('error', (err) => {
-              nackMessage(err);
+              ackOrNack(err);
             });
+
             publisherChannel.on('return', () => {
-              nackMessage(new Error(format('Message: %s was republished to queue: %s, but was returned', message.properties.messageId, originalQueue)));
+              ackOrNack(new Error(format('Message: %s was republished to queue: %s, but was returned', message.properties.messageId, originalQueue)));
             });
 
             publisherChannel.publish(undefined, originalQueue, message.content, publishOptions, (err) => {
-              if (err) return nackMessage(err); // Channel will already be closed, reclosing will trigger an error
-
-              publisherChannel.close();
-              debug('Message: %s was republished to queue: %s %d times', message.properties.messageId, originalQueue, republished + 1);
-              session._ack(message, (err) => {
-                once(err, true);
-              });
+              if (err) {
+                // Channel will already be closed, reclosing will trigger an error
+                publisherChannel.removeAllListeners();
+
+                debug('Message: %s failed to be republished to queue: %s %d times - %s', message.properties.messageId, originalQueue, republished + 1, err.message);
+                ackOrNack(err);
+              } else {
+                publisherChannel.close();
+                publisherChannel.removeAllListeners();
+
+                debug('Message: %s was republished to queue: %s %d times', message.properties.messageId, originalQueue, republished + 1);
+                ackOrNack();
+              }
             });
           });
         },
@@ -123,13 +139,12 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
         execute(session, message, err, strategyConfig, next) {
           debug('Forwarding message: %s to publication: %s', message.properties.messageId, strategyConfig.publication);
 
-          const once = _.once(next);
           const originalQueue = _.get(message, 'properties.headers.rascal.originalQueue');
           const forwarded = _.get(message, ['properties', 'headers', 'rascal', 'recovery', originalQueue, 'forwarded'], 0);
 
           if (strategyConfig.attempts && strategyConfig.attempts <= forwarded) {
             debug('Skipping recovery - message: %s has already been forwarded %d times.', message.properties.messageId, forwarded);
-            return once(null, false);
+            return next(null, false);
           }
 
           // See https://github.com/rabbitmq/rabbitmq-server/issues/161
@@ -141,30 +156,39 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
           _.set(forwardOverrides, 'options.headers.rascal.error.message', _.truncate(err.message, { length: 1024 }));
           _.set(forwardOverrides, 'options.headers.rascal.error.code', err.code);
 
+          const ackMessage = () => {
+            session._ack(message, (err) => {
+              next(err, true);
+            });
+          };
+
           const nackMessage = (err) => {
             session._nack(message, (_nackErr) => {
               // nackError just means the channel was already closed meaning the original message would have been rolled back
-              once(err);
+              next(err);
             });
           };
 
+          const ackOrNack = _.once((err) => {
+            return err ? nackMessage(err) : ackMessage();
+          });
+
           broker.forward(strategyConfig.publication, message, forwardOverrides, (err, publication) => {
             if (err) return nackMessage(err);
 
             publication.on('success', () => {
               debug('Message: %s was forwarded to publication: %s %d times', message.properties.messageId, strategyConfig.publication, forwarded + 1);
-              session._ack(message, (ackErr) => {
-                once(ackErr, true);
-              });
+              ackOrNack();
             });
 
             publication.on('error', (err) => {
-              nackMessage(err);
+              debug('Message: %s failed to be forwarded to publication: %s %d times - %s', message.properties.messageId, strategyConfig.publication, forwarded + 1, err.message);
+              ackOrNack(err);
             });
 
             publication.on('return', () => {
               publication.removeAllListeners('success');
-              nackMessage(new Error(format('Message: %s was forwarded to publication: %s, but was returned', message.properties.messageId, strategyConfig.publication)));
+              ackOrNack(new Error(format('Message: %s was forwarded to publication: %s, but was returned', message.properties.messageId, strategyConfig.publication)));
             });
           });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rascal",
-  "version": "17.0.0",
+  "version": "17.0.1",
   "description": "A config driven wrapper for amqplib supporting multi-host connections, automatic error recovery, redelivery flood protection, transparent encryption / decryption,  channel pooling and publication timeouts",
   "main": "index.js",
   "dependencies": {