rascal 13.0.6 → 13.1.3

package/lib/amqp/SubscriberError.js

@@ -1,150 +1,311 @@
-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
+    );
 
-  this.handle = function(session, message, err, recoveryProcess, next) {
+    async.eachSeries(
+      [].concat(recoveryProcess || []).concat({ strategy: "fallback-nack" }),
+      (recoveryConfig, cb) => {
+        debug(
+          "Attempting to recover message: %s using strategy: %s",
+          message.properties.messageId,
+          recoveryConfig.strategy
+        );
 
-    debug('Handling subscriber error for message: %s', message.properties.messageId);
+        const once = _.once(cb);
 
-    async.eachSeries([].concat(recoveryProcess || []).concat({ strategy: 'fallback-nack' }), (recoveryConfig, cb) => {
-      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);
-            return setImmediate(() => {
-              next(err);
-            });
-          }
-          if (handled) {
-            debug('Message: %s was recovered using stragegy: %s', message.properties.messageId, recoveryConfig.strategy);
-            return setImmediate(next);
-          }
-          once();
-        });
-      }, recoveryConfig.defer);
-    }, next);
+        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();
+            }
+          );
+        }, recoveryConfig.defer);
+      },
+      next
+    );
   };
 
-  const recoveryStrategies = _.keyBy([
-    {
-      name: 'ack',
-      execute(session, message, err, strategyConfig, next) {
-        session._ack(message, (err) => {
-          next(err, true);
-        });
-      },
-    },
-    {
-      name: 'nack',
-      execute(session, message, err, strategyConfig, next) {
-        session._nack(message, { requeue: strategyConfig.requeue }, (err) => {
-          next(err, true);
-        });
-      },
-    },
-    {
-      name: 'fallback-nack',
-      execute(session, message, err, strategyConfig, next) {
-        session._nack(message, { requeue: strategyConfig.requeue }, (err) => {
-          next(err, true);
-        });
+  const recoveryStrategies = _.keyBy(
+    [
+      {
+        name: "ack",
+        execute(session, message, err, strategyConfig, next) {
+          session._ack(message, (err) => {
+            next(err, true);
+          });
+        },
       },
-    },
-    {
-      name: 'republish',
-      execute(session, message, err, strategyConfig, next) {
-        debug('Republishing message: %s', message.properties.messageId);
-
-        const originalQueue = _.get(message, 'properties.headers.rascal.originalQueue');
-        const republished = _.get(message, format('properties.headers.rascal.recovery.%s.republished', originalQueue), 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);
-        }
-
-        const publishOptions = _.cloneDeep(message.properties);
-        _.set(publishOptions, format('headers.rascal.recovery.%s.republished', originalQueue), 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, format('headers.rascal.recovery.%s.immediateNack', originalQueue), 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'));
-
-          publisherChannel.on('error', next);
-
-          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);
-            });
+      {
+        name: "nack",
+        execute(session, message, err, strategyConfig, next) {
+          session._nack(message, { requeue: strategyConfig.requeue }, (err) => {
+            next(err, true);
           });
-        });
+        },
       },
-    },
-    {
-      name: 'forward',
-      execute(session, message, err, strategyConfig, next) {
-        debug('Forwarding message: %s', message.properties.messageId);
-
-        const originalQueue = _.get(message, 'properties.headers.rascal.originalQueue');
-        const forwarded = _.get(message, format('properties.headers.rascal.recovery.%s.forwarded', originalQueue), 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);
-        }
-
-        // See https://github.com/rabbitmq/rabbitmq-server/issues/161
-        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, format('options.headers.rascal.recovery.%s.forwarded', originalQueue), 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);
-            });
+      {
+        name: "fallback-nack",
+        execute(session, message, err, strategyConfig, next) {
+          session._nack(message, { requeue: strategyConfig.requeue }, (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)));
+        },
+      },
+      {
+        name: "republish",
+        execute(session, message, err, strategyConfig, next) {
+          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
+          );
+
+          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);
+          }
+
+          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
+          );
+
+          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"
+                )
+              );
+
+            publisherChannel.on("error", next);
+
+            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);
+                });
+              }
+            );
           });
-        });
+        },
+      },
+      {
+        name: "forward",
+        execute(session, message, err, strategyConfig, next) {
+          debug("Forwarding message: %s", message.properties.messageId);
+
+          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);
+          }
+
+          // See https://github.com/rabbitmq/rabbitmq-server/issues/161
+          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
+                    )
+                  )
+                );
+              });
+            }
+          );
+        },
       },
-    },
-    {
-      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)));
+      {
+        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
+              )
+            )
+          );
+        },
       },
-    },
-  ], 'name');
+    ],
+    "name"
+  );
 
   function getStrategy(recoveryConfig) {
-    return recoveryStrategies[recoveryConfig.strategy] || recoveryStrategies.unknown;
+    return (
+      recoveryStrategies[recoveryConfig.strategy] || recoveryStrategies.unknown
+    );
   }
 };

package/lib/amqp/SubscriberSession.js

@@ -1,15 +1,14 @@
-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 setTimeoutUnref = require("../utils/setTimeoutUnref");
 
 module.exports = SubscriberSession;
 
 inherits(SubscriberSession, EventEmitter);
 
 function SubscriberSession(sequentialChannelOperations, config) {
-
   let index = 0;
   const channels = {};
   let cancelled = false;
@@ -19,20 +18,24 @@ function SubscriberSession(sequentialChannelOperations, config) {
   this.name = config.name;
   this.config = _.cloneDeep(config);
 
-  this.isCancelled = function() {
+  this.isCancelled = function () {
     return cancelled;
   };
 
-  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);
+  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));
+    channel.once("close", unref.bind(null, consumerTag));
+    channel.once("error", unref.bind(null, consumerTag));
     next();
   };
 
-  this.cancel = function(next) {
+  this.cancel = function (next) {
     clearTimeout(timeout);
     sequentialChannelOperations.push((done) => {
       cancelled = true;
@@ -40,35 +43,42 @@ function SubscriberSession(sequentialChannelOperations, config) {
     }, next);
   };
 
-  this._close = function(next) {
+  this._close = function (next) {
     sequentialChannelOperations.push((done) => {
       self._unsafeClose(done);
     }, next);
   };
 
-  this._unsafeClose = function(next) {
-    withCurrentChannel((channel, consumerTag) => {
-      debug('Cancelling subscriber session: %s on channel: %s', consumerTag, channel._rascal_id);
-      channel.cancel(consumerTag, (err) => {
-        if (err) return next(err);
-        doom(consumerTag);
+  this._unsafeClose = function (next) {
+    withCurrentChannel(
+      (channel, consumerTag) => {
+        debug(
+          "Cancelling subscriber session: %s on channel: %s",
+          consumerTag,
+          channel._rascal_id
+        );
+        channel.cancel(consumerTag, (err) => {
+          if (err) return next(err);
+          doom(consumerTag);
+          next();
+        });
+      },
+      () => {
+        debug("No current subscriber session");
         next();
-      });
-    }, () => {
-      debug('No current subscriber session');
-      next();
-    });
+      }
+    );
   };
 
-  this._schedule = function(fn, delay) {
+  this._schedule = function (fn, delay) {
     timeout = setTimeoutUnref(fn, delay);
   };
 
-  this._maxDeferCloseChannel = function(other) {
-    return Math.max(config.deferCloseChannel, other) ;
+  this._maxDeferCloseChannel = function (other) {
+    return Math.max(config.deferCloseChannel, other);
   };
 
-  this._getRascalChannelId = function() {
+  this._getRascalChannelId = function () {
     let rascalChannelId = null;
     withCurrentChannel((channel) => {
       rascalChannelId = channel._rascal_id;
@@ -76,35 +86,60 @@ function SubscriberSession(sequentialChannelOperations, config) {
     return rascalChannelId;
   };
 
-  this._ack = function(message, next) {
-    withConsumerChannel(message.fields.consumerTag, (channel) => {
-      debug('Acknowledging message: %s on channel: %s', message.properties.messageId, channel._rascal_id);
-      channel.ack(message);
-      setImmediate(next);
-    }, () => {
-      setImmediate(() => {
-        next(new Error('The channel has been closed. Unable to ack message'));
-      });
-    });
+  this._ack = function (message, next) {
+    withConsumerChannel(
+      message.fields.consumerTag,
+      (channel) => {
+        debug(
+          "Acknowledging message: %s on channel: %s",
+          message.properties.messageId,
+          channel._rascal_id
+        );
+        channel.ack(message);
+        setImmediate(next);
+      },
+      () => {
+        setImmediate(() => {
+          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]);
-    withConsumerChannel(message.fields.consumerTag, (channel) => {
-      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);
-      setImmediate(next);
-    }, () => {
-      setImmediate(() => {
-        next(new Error('The channel has been closed. Unable to nack message'));
-      });
-    });
+  this._nack = function (message, options, next) {
+    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
+        );
+        channel.nack(message, false, !!options.requeue);
+        setImmediate(next);
+      },
+      () => {
+        setImmediate(() => {
+          next(
+            new Error("The channel has been closed. Unable to nack message")
+          );
+        });
+      }
+    );
   };
 
   function withCurrentChannel(fn, altFn) {
-    const entry = _.chain(channels).values().filter(channel => {
-      return !channel.doomed;
-    }).sortBy('index').last().value();
+    const entry = _.chain(channels)
+      .values()
+      .filter((channel) => {
+        return !channel.doomed;
+      })
+      .sortBy("index")
+      .last()
+      .value();
     if (entry) return fn(entry.channel, entry.consumerTag, entry);
     return altFn && altFn();
   }
@@ -117,7 +152,7 @@ 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];
     });
   }
@@ -137,11 +172,15 @@ function SubscriberSession(sequentialChannelOperations, config) {
     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);
+    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);
+          debug("Channel: %s was closed", channel._rascal_id);
         });
       });
     }, config.deferCloseChannel);