rascal 13.1.3 → 14.2.0

package/lib/amqp/SubscriberError.js

@@ -1,55 +1,34 @@
-const debug = require("debug")("rascal:SubscriberError");
-const format = require("util").format;
-const _ = require("lodash");
-const async = require("async");
-const setTimeoutUnref = require("../utils/setTimeoutUnref");
+const debug = require('debug')('rascal:SubscriberError');
+const format = require('util').format;
+const _ = require('lodash');
+const async = require('async');
+const setTimeoutUnref = require('../utils/setTimeoutUnref');
 
 module.exports = function SubscriptionRecovery(broker, vhost) {
   this.handle = function (session, message, err, recoveryProcess, next) {
-    debug(
-      "Handling subscriber error for message: %s",
-      message.properties.messageId
-    );
+    debug('Handling subscriber error for message: %s', message.properties.messageId);
 
     async.eachSeries(
-      [].concat(recoveryProcess || []).concat({ strategy: "fallback-nack" }),
+      [].concat(recoveryProcess || []).concat({ strategy: 'fallback-nack' }),
       (recoveryConfig, cb) => {
-        debug(
-          "Attempting to recover message: %s using strategy: %s",
-          message.properties.messageId,
-          recoveryConfig.strategy
-        );
+        debug('Attempting to recover message: %s using strategy: %s', message.properties.messageId, recoveryConfig.strategy);
 
         const once = _.once(cb);
 
         setTimeoutUnref(() => {
-          getStrategy(recoveryConfig).execute(
-            session,
-            message,
-            err,
-            _.omit(recoveryConfig, "defer"),
-            (err, handled) => {
-              if (err) {
-                debug(
-                  "Message: %s failed to be recovered using stragegy: %s",
-                  message.properties.messageId,
-                  recoveryConfig.strategy
-                );
-                setImmediate(() => next(err));
-                return once(false);
-              }
-              if (handled) {
-                debug(
-                  "Message: %s was recovered using stragegy: %s",
-                  message.properties.messageId,
-                  recoveryConfig.strategy
-                );
-                setImmediate(next);
-                return once(false);
-              }
-              once();
+          getStrategy(recoveryConfig).execute(session, message, err, _.omit(recoveryConfig, 'defer'), (err, handled) => {
+            if (err) {
+              debug('Message: %s failed to be recovered using stragegy: %s', message.properties.messageId, recoveryConfig.strategy);
+              setImmediate(() => next(err));
+              return once(false);
+            }
+            if (handled) {
+              debug('Message: %s was recovered using stragegy: %s', message.properties.messageId, recoveryConfig.strategy);
+              setImmediate(next);
+              return once(false);
             }
-          );
+            once();
+          });
         }, recoveryConfig.defer);
       },
       next
@@ -59,7 +38,7 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
   const recoveryStrategies = _.keyBy(
     [
       {
-        name: "ack",
+        name: 'ack',
         execute(session, message, err, strategyConfig, next) {
           session._ack(message, (err) => {
             next(err, true);
@@ -67,7 +46,7 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
         },
       },
       {
-        name: "nack",
+        name: 'nack',
         execute(session, message, err, strategyConfig, next) {
           session._nack(message, { requeue: strategyConfig.requeue }, (err) => {
             next(err, true);
@@ -75,7 +54,7 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
         },
       },
       {
-        name: "fallback-nack",
+        name: 'fallback-nack',
         execute(session, message, err, strategyConfig, next) {
           session._nack(message, { requeue: strategyConfig.requeue }, (err) => {
             next(err, true);
@@ -83,229 +62,124 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
         },
       },
       {
-        name: "republish",
+        name: 'republish',
         execute(session, message, err, strategyConfig, next) {
-          debug("Republishing message: %s", message.properties.messageId);
+          debug('Republishing message: %s', message.properties.messageId);
 
-          const originalQueue = _.get(
-            message,
-            "properties.headers.rascal.originalQueue"
-          );
-          const republished = _.get(
-            message,
-            [
-              "properties",
-              "headers",
-              "rascal",
-              "recovery",
-              originalQueue,
-              "republished",
-            ],
-            0
-          );
+          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 next(null, false);
+          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);
           }
 
           const publishOptions = _.cloneDeep(message.properties);
-          _.set(
-            publishOptions,
-            ["headers", "rascal", "recovery", originalQueue, "republished"],
-            republished + 1
-          );
-          _.set(
-            publishOptions,
-            "headers.rascal.originalExchange",
-            message.fields.exchange
-          );
-          _.set(
-            publishOptions,
-            "headers.rascal.originalRoutingKey",
-            message.fields.routingKey
-          );
-          _.set(
-            publishOptions,
-            "headers.rascal.error.message",
-            _.truncate(err.message, { length: 1024 })
-          );
-          _.set(publishOptions, "headers.rascal.error.code", err.code);
-          _.set(
-            publishOptions,
-            "headers.rascal.restoreRoutingHeaders",
-            _.has(strategyConfig, "restoreRoutingHeaders")
-              ? strategyConfig.restoreRoutingHeaders
-              : true
-          );
+          _.set(publishOptions, ['headers', 'rascal', 'recovery', originalQueue, 'republished'], republished + 1);
+          _.set(publishOptions, 'headers.rascal.originalExchange', message.fields.exchange);
+          _.set(publishOptions, 'headers.rascal.originalRoutingKey', message.fields.routingKey);
+          _.set(publishOptions, 'headers.rascal.error.message', _.truncate(err.message, { length: 1024 }));
+          _.set(publishOptions, 'headers.rascal.error.code', err.code);
+          _.set(publishOptions, 'headers.rascal.restoreRoutingHeaders', _.has(strategyConfig, 'restoreRoutingHeaders') ? strategyConfig.restoreRoutingHeaders : true);
 
-          if (strategyConfig.immediateNack)
-            _.set(
-              publishOptions,
-              ["headers", "rascal", "recovery", originalQueue, "immediateNack"],
-              true
-            );
+          if (strategyConfig.immediateNack) _.set(publishOptions, ['headers', 'rascal', 'recovery', originalQueue, 'immediateNack'], true);
 
           vhost.getConfirmChannel((err, publisherChannel) => {
-            if (err) return next(err);
-            if (!publisherChannel)
-              return next(
-                new Error(
-                  "Unable to handle subscriber error by republishing. The VHost is shutting down"
-                )
-              );
+            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);
+              });
+            };
 
-            publisherChannel.on("error", next);
+            if (err) return nackMessage(err);
 
-            publisherChannel.publish(
-              undefined,
-              originalQueue,
-              message.content,
-              publishOptions,
-              (err) => {
-                if (err) return next(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) => {
-                  next(err, true);
-                });
-              }
-            );
+            if (!publisherChannel) return nackMessage(new Error('Unable to handle subscriber error by republishing. The VHost is shutting down'));
+
+            publisherChannel.on('error', (err) => {
+              nackMessage(err);
+            });
+            publisherChannel.on('return', () => {
+              nackMessage(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);
+              });
+            });
           });
         },
       },
       {
-        name: "forward",
+        name: 'forward',
         execute(session, message, err, strategyConfig, next) {
-          debug("Forwarding message: %s", message.properties.messageId);
+          debug('Forwarding message: %s to publication: %s', message.properties.messageId, strategyConfig.publication);
 
-          const originalQueue = _.get(
-            message,
-            "properties.headers.rascal.originalQueue"
-          );
-          const forwarded = _.get(
-            message,
-            [
-              "properties",
-              "headers",
-              "rascal",
-              "recovery",
-              originalQueue,
-              "forwarded",
-            ],
-            0
-          );
+          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 next(null, false);
+            debug('Skipping recovery - message: %s has already been forwarded %d times.', message.properties.messageId, forwarded);
+            return once(null, false);
           }
 
           // See https://github.com/rabbitmq/rabbitmq-server/issues/161
-          if (strategyConfig.xDeathFix)
-            delete message.properties.headers["x-death"];
+          if (strategyConfig.xDeathFix) delete message.properties.headers['x-death'];
 
           const forwardOverrides = _.cloneDeep(strategyConfig.options) || {};
-          _.set(
-            forwardOverrides,
-            "restoreRoutingHeaders",
-            _.has(strategyConfig, "restoreRoutingHeaders")
-              ? strategyConfig.restoreRoutingHeaders
-              : true
-          );
-          _.set(
-            forwardOverrides,
-            [
-              "options",
-              "headers",
-              "rascal",
-              "recovery",
-              originalQueue,
-              "forwarded",
-            ],
-            forwarded + 1
-          );
-          _.set(
-            forwardOverrides,
-            "options.headers.rascal.error.message",
-            _.truncate(err.message, { length: 1024 })
-          );
-          _.set(
-            forwardOverrides,
-            "options.headers.rascal.error.code",
-            err.code
-          );
-
-          broker.forward(
-            strategyConfig.publication,
-            message,
-            forwardOverrides,
-            (err, publication) => {
-              if (err) return next(err);
-              publication.on("success", () => {
-                debug(
-                  "Message: %s was forwarded to publication: %s %d times",
-                  message.properties.messageId,
-                  strategyConfig.publication,
-                  forwarded + 1
-                );
-                session._ack(message, (err) => {
-                  next(err, true);
-                });
-              });
-              publication.on("error", next);
-              publication.on("return", () => {
-                next(
-                  new Error(
-                    format(
-                      "Message: %s was forwared to publication: %s, but was returned",
-                      message.properties.messageId,
-                      strategyConfig.publication
-                    )
-                  )
-                );
+          _.set(forwardOverrides, 'restoreRoutingHeaders', _.has(strategyConfig, 'restoreRoutingHeaders') ? strategyConfig.restoreRoutingHeaders : true);
+          _.set(forwardOverrides, ['options', 'headers', 'rascal', 'recovery', originalQueue, 'forwarded'], forwarded + 1);
+          _.set(forwardOverrides, 'options.headers.rascal.error.message', _.truncate(err.message, { length: 1024 }));
+          _.set(forwardOverrides, 'options.headers.rascal.error.code', err.code);
+
+          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);
+            });
+          };
+
+          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);
               });
-            }
-          );
+            });
+
+            publication.on('error', (err) => {
+              nackMessage(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)));
+            });
+          });
         },
       },
       {
-        name: "unknown",
+        name: 'unknown',
         execute(session, message, err, strategyConfig, next) {
-          next(
-            new Error(
-              format(
-                "Error recovering message: %s. No such strategy: %s.",
-                message.properties.messageId,
-                strategyConfig.strategy
-              )
-            )
-          );
+          session._nack(message, () => {
+            next(new Error(format('Error recovering message: %s. No such strategy: %s.', message.properties.messageId, strategyConfig.strategy)));
+          });
         },
       },
     ],
-    "name"
+    'name'
   );
 
   function getStrategy(recoveryConfig) {
-    return (
-      recoveryStrategies[recoveryConfig.strategy] || recoveryStrategies.unknown
-    );
+    return recoveryStrategies[recoveryConfig.strategy] || recoveryStrategies.unknown;
   }
 };

package/lib/amqp/SubscriberSession.js

@@ -1,8 +1,9 @@
-const debug = require("debug")("rascal:SubscriberSession");
-const EventEmitter = require("events").EventEmitter;
-const inherits = require("util").inherits;
-const _ = require("lodash");
-const setTimeoutUnref = require("../utils/setTimeoutUnref");
+const debug = require('debug')('rascal:SubscriberSession');
+const EventEmitter = require('events').EventEmitter;
+const inherits = require('util').inherits;
+const _ = require('lodash');
+const async = require('async');
+const setTimeoutUnref = require('../utils/setTimeoutUnref');
 
 module.exports = SubscriberSession;
 
@@ -23,15 +24,11 @@ function SubscriberSession(sequentialChannelOperations, config) {
   };
 
   this._open = function (channel, consumerTag, next) {
-    if (cancelled) return next(new Error("Subscriber has been cancelled"));
-    debug(
-      "Opening subscriber session: %s on channel: %s",
-      consumerTag,
-      channel._rascal_id
-    );
-    channels[consumerTag] = { index: index++, channel, consumerTag };
-    channel.once("close", unref.bind(null, consumerTag));
-    channel.once("error", unref.bind(null, consumerTag));
+    if (cancelled) return next(new Error('Subscriber has been cancelled'));
+    debug('Opening subscriber session: %s on channel: %s', consumerTag, channel._rascal_id);
+    channels[consumerTag] = { index: index++, channel, consumerTag, unacknowledgedMessages: 0 };
+    channel.once('close', unref.bind(null, consumerTag));
+    channel.once('error', unref.bind(null, consumerTag));
     next();
   };
 
@@ -51,20 +48,22 @@ function SubscriberSession(sequentialChannelOperations, config) {
 
   this._unsafeClose = function (next) {
     withCurrentChannel(
-      (channel, consumerTag) => {
-        debug(
-          "Cancelling subscriber session: %s on channel: %s",
-          consumerTag,
-          channel._rascal_id
-        );
+      (channel, consumerTag, entry) => {
+        entry.doomed = true;
+        debug('Cancelling subscriber session: %s on channel: %s', consumerTag, channel._rascal_id);
         channel.cancel(consumerTag, (err) => {
           if (err) return next(err);
-          doom(consumerTag);
-          next();
+          const waitOrTimeout = config.closeTimeout ? async.timeout(waitForUnacknowledgedMessages, config.closeTimeout) : waitForUnacknowledgedMessages;
+          waitOrTimeout(entry, null, (err) => {
+            channel.close(() => {
+              debug('Channel: %s was closed', entry.channel._rascal_id);
+              next(err);
+            });
+          });
         });
       },
       () => {
-        debug("No current subscriber session");
+        debug('No current subscriber session');
         next();
       }
     );
@@ -74,10 +73,6 @@ function SubscriberSession(sequentialChannelOperations, config) {
     timeout = setTimeoutUnref(fn, delay);
   };
 
-  this._maxDeferCloseChannel = function (other) {
-    return Math.max(config.deferCloseChannel, other);
-  };
-
   this._getRascalChannelId = function () {
     let rascalChannelId = null;
     withCurrentChannel((channel) => {
@@ -86,46 +81,50 @@ function SubscriberSession(sequentialChannelOperations, config) {
     return rascalChannelId;
   };
 
+  this._incrementUnacknowledgeMessageCount = function (consumerTag) {
+    if (config.options.noAck) return;
+    withConsumerChannel(consumerTag, (channel, __, entry) => {
+      debug('Channel: %s has %s unacknowledged messages', channel._rascal_id, ++entry.unacknowledgedMessages);
+    });
+  };
+
+  this._decrementUnacknowledgeMessageCount = function (consumerTag) {
+    if (config.options.noAck) return;
+    withConsumerChannel(consumerTag, (channel, __, entry) => {
+      debug('Channel: %s has %s unacknowledged messages', channel._rascal_id, --entry.unacknowledgedMessages);
+    });
+  };
+
   this._ack = function (message, next) {
     withConsumerChannel(
       message.fields.consumerTag,
       (channel) => {
-        debug(
-          "Acknowledging message: %s on channel: %s",
-          message.properties.messageId,
-          channel._rascal_id
-        );
+        debug('Acknowledging message: %s on channel: %s', message.properties.messageId, channel._rascal_id);
         channel.ack(message);
+        self._decrementUnacknowledgeMessageCount(message.fields.consumerTag);
         setImmediate(next);
       },
       () => {
         setImmediate(() => {
-          next(new Error("The channel has been closed. Unable to ack message"));
+          next(new Error('The channel has been closed. Unable to ack message'));
         });
       }
     );
   };
 
   this._nack = function (message, options, next) {
-    if (arguments.length === 2)
-      return self._nack(arguments[0], {}, arguments[1]);
+    if (arguments.length === 2) return self._nack(arguments[0], {}, arguments[1]);
     withConsumerChannel(
       message.fields.consumerTag,
       (channel) => {
-        debug(
-          "Not acknowledging message: %s with requeue: %s on channel: %s",
-          message.properties.messageId,
-          !!options.requeue,
-          channel._rascal_id
-        );
+        debug('Not acknowledging message: %s with requeue: %s on channel: %s', message.properties.messageId, !!options.requeue, channel._rascal_id);
         channel.nack(message, false, !!options.requeue);
+        self._decrementUnacknowledgeMessageCount(message.fields.consumerTag);
         setImmediate(next);
       },
       () => {
         setImmediate(() => {
-          next(
-            new Error("The channel has been closed. Unable to nack message")
-          );
+          next(new Error('The channel has been closed. Unable to nack message'));
         });
       }
     );
@@ -134,10 +133,8 @@ function SubscriberSession(sequentialChannelOperations, config) {
   function withCurrentChannel(fn, altFn) {
     const entry = _.chain(channels)
       .values()
-      .filter((channel) => {
-        return !channel.doomed;
-      })
-      .sortBy("index")
+      .filter((entry) => !entry.doomed)
+      .sortBy('index')
       .last()
       .value();
     if (entry) return fn(entry.channel, entry.consumerTag, entry);
@@ -152,37 +149,20 @@ function SubscriberSession(sequentialChannelOperations, config) {
 
   function unref(consumerTag) {
     withConsumerChannel(consumerTag, (channel) => {
-      debug("Removing channel: %s from session", channel._rascal_id);
+      debug('Removing channel: %s from session', channel._rascal_id);
       delete channels[consumerTag];
     });
   }
 
-  function doom(consumerTag) {
-    withConsumerChannel(consumerTag, (channel, consumerTag, entry) => {
-      if (entry.doomed) return;
-      entry.doomed = true;
-      scheduleClose(entry);
-    });
-  }
-
-  /*
-    There may still be delivered messages that have yet to be ack or nacked
-    but no way of telling how many are outstanding since due to potentially
-    complicated recovery strategies, with timeouts etc.
-    Keeping channels around for a minute shouldn't hurt
-  */
-  function scheduleClose(entry) {
-    debug(
-      "Deferring close channel: %s by %dms",
-      entry.channel._rascal_id,
-      config.deferCloseChannel
-    );
-    setTimeoutUnref(() => {
-      withConsumerChannel(entry.consumerTag, (channel) => {
-        channel.close(() => {
-          debug("Channel: %s was closed", channel._rascal_id);
-        });
-      });
-    }, config.deferCloseChannel);
+  function waitForUnacknowledgedMessages(entry, previousCount, next) {
+    const currentCount = entry.unacknowledgedMessages;
+    if (currentCount > 0) {
+      if (currentCount !== previousCount) {
+        debug('Waiting for %d unacknowledged messages from channel: %s', currentCount, entry.channel._rascal_id);
+      }
+      setTimeoutUnref(() => waitForUnacknowledgedMessages(entry, currentCount, next), 100);
+      return;
+    }
+    next();
   }
 }

package/lib/amqp/SubscriberSessionAsPromised.js

@@ -1,6 +1,6 @@
-const EventEmitter = require("events").EventEmitter;
-const inherits = require("util").inherits;
-const forwardEvents = require("forward-emitter");
+const EventEmitter = require('events').EventEmitter;
+const inherits = require('util').inherits;
+const forwardEvents = require('forward-emitter');
 
 module.exports = SubscriberSessionAsPromised;