rascal 13.1.1 → 14.0.1

package/lib/amqp/Subscription.js

@@ -25,12 +25,12 @@ function Subscription(broker, vhost, config, counter) {
 
   this.name = config.name;
 
-  this.init = function(next) {
+  this.init = function (next) {
     debug('Initialising subscription: %s', config.name);
     return next(null, self);
   };
 
-  this.subscribe = function(overrides, next) {
+  this.subscribe = function (overrides, next) {
     const session = new SubscriberSession(sequentialChannelOperations, config);
     subscribeLater(session, _.defaultsDeep(overrides, config));
     return next(null, session);
@@ -82,6 +82,7 @@ function Subscription(broker, vhost, config, counter) {
     if (!message) return handleConsumerCancel(session, config, removeErrorHandlers);
 
     debug('Received message: %s from queue: %s', message.properties.messageId, config.queue);
+    session._incrementUnacknowledgeMessageCount(message.fields.consumerTag);
 
     decorateWithRoutingHeaders(message);
     if (immediateNack(message)) return ackOrNack(session, message, true);
@@ -91,8 +92,7 @@ function Subscription(broker, vhost, config, counter) {
       if (redeliveriesExceeded(message)) return handleRedeliveriesExceeded(session, message);
 
       getContent(message, config, (err, content) => {
-        err ? handleContentError(session, message, err)
-            : session.emit('message', message, content, getAckOrNack(session, message));
+        err ? handleContentError(session, message, err) : session.emit('message', message, content, getAckOrNack(session, message));
       });
     });
   }
@@ -145,7 +145,7 @@ function Subscription(broker, vhost, config, counter) {
   }
 
   function handleRedeliveriesError(err, session, message) {
-    debug('Error handling redeliveries of message %s: %s',  message.properties.messageId, err.message);
+    debug('Error handling redeliveries of message %s: %s', message.properties.messageId, err.message);
     if (session.emit('redeliveries_error', err, message, getAckOrNack(session, message))) return;
     if (session.emit('redeliveries_exceeded', err, message, getAckOrNack(session, message))) return;
     nackAndError(session, message, err);
@@ -198,8 +198,7 @@ function Subscription(broker, vhost, config, counter) {
   }
 
   function immediateNack(message) {
-    if (_.get(message, format('properties.headers.rascal.recovery.%s.immediateNack', message.properties.headers.rascal.originalQueue))) return true;
-    if (_.get(message, format('properties.headers.rascal.recovery.%s.immediateNack', message.properties.headers.rascal.originalQueue))) return true;
+    if (_.get(message, ['properties', 'headers', 'rascal', 'recovery', message.properties.headers.rascal.originalQueue, 'immediateNack'])) return true;
     return false;
   }
 
@@ -215,8 +214,7 @@ function Subscription(broker, vhost, config, counter) {
     if (arguments.length === 3) return ackOrNack(session, message, err, undefined, emitOnError.bind(null, session));
     if (arguments.length === 4 && _.isFunction(arguments[3])) return ackOrNack(session, message, err, undefined, arguments[3]);
     if (arguments.length === 4) return ackOrNack(session, message, err, recovery, emitOnError.bind(null, session));
-    err ? subscriberError.handle(session, message, err, recovery, next)
-        : session._ack(message, next);
+    err ? subscriberError.handle(session, message, err, recovery, next) : session._ack(message, next);
   }
 
   function ackOrNackP(session, message, err, recovery) {
@@ -224,9 +222,10 @@ function Subscription(broker, vhost, config, counter) {
     if (arguments.length === 3) return ackOrNackP(session, message, err, undefined);
 
     return new Promise((resolve, reject) => {
-      const cb = function(err) { err ? reject(err) : resolve(); };
-      err ? subscriberError.handle(session, message, err, recovery, cb)
-          : session._ack(message, cb);
+      const cb = function (err) {
+        err ? reject(err) : resolve();
+      };
+      err ? subscriberError.handle(session, message, err, recovery, cb) : session._ack(message, cb);
     });
   }
 
@@ -256,12 +255,13 @@ function Subscription(broker, vhost, config, counter) {
     debug('Handling channel error: %s from %s using channel: %s', err.message, config.name, session._getRascalChannelId());
     if (removeErrorHandlers) removeErrorHandlers();
     session.emit('error', err);
-    config.retry && subscribeNow(session, config, (err) => {
-      if (!err) return;
-      const delay = timer.next();
-      debug('Will attempt resubscription(%d) to %s in %dms', attempts + 1, config.name, delay);
-      session._schedule(handleChannelError.bind(null, session, config, null, attempts + 1, err), delay);
-    });
+    config.retry &&
+      subscribeNow(session, config, (err) => {
+        if (!err) return;
+        const delay = timer.next();
+        debug('Will attempt resubscription(%d) to %s in %dms', attempts + 1, config.name, delay);
+        session._schedule(handleChannelError.bind(null, session, config, null, attempts + 1, err), delay);
+      });
   }
 
   function handleConsumerCancel(session, config, removeErrorHandlers) {
@@ -271,12 +271,13 @@ function Subscription(broker, vhost, config, counter) {
       if (err) debug('Error cancelling subscription: %s', err.message);
       const cancelErr = new Error(format('Subscription: %s was cancelled by the broker', config.name));
       session.emit('cancelled', cancelErr) || session.emit('error', cancelErr);
-      config.retry && subscribeNow(session, config, (err) => {
-        if (!err) return;
-        const delay = timer.next();
-        debug('Will attempt resubscription(%d) to %s in %dms', 1, config.name, delay);
-        session._schedule(handleChannelError.bind(null, session, config, null, 1, err), delay);
-      });
+      config.retry &&
+        subscribeNow(session, config, (err) => {
+          if (!err) return;
+          const delay = timer.next();
+          debug('Will attempt resubscription(%d) to %s in %dms', 1, config.name, delay);
+          session._schedule(handleChannelError.bind(null, session, config, null, 1, err), delay);
+        });
     });
   }
 }

package/lib/amqp/Vhost.js

@@ -19,7 +19,6 @@ module.exports = {
 inherits(Vhost, EventEmitter);
 
 function Vhost(config) {
-
   const self = this;
   let connection;
   let connectionConfig;
@@ -41,7 +40,7 @@ function Vhost(config) {
 
   pauseChannelAllocation();
 
-  this.init = function(next) {
+  this.init = function (next) {
     if (shuttingDown) {
       debug('Aborting initialisation. Vhost %s is shutting down.', self.name);
       return next();
@@ -73,7 +72,7 @@ function Vhost(config) {
     return self;
   };
 
-  this.forewarn = function(next) {
+  this.forewarn = function (next) {
     debug('Forewarning vhost: %s about impending shutdown', self.name);
     pauseChannelAllocation();
     shuttingDown = true;
@@ -81,7 +80,7 @@ function Vhost(config) {
     next();
   };
 
-  this.shutdown = function(next) {
+  this.shutdown = function (next) {
     debug('Shutting down vhost: %s', self.name);
     clearTimeout(reconnectTimeout);
     pauseChannelAllocation();
@@ -91,7 +90,7 @@ function Vhost(config) {
     });
   };
 
-  this.nuke = function(next) {
+  this.nuke = function (next) {
     debug('Nuking vhost: %s', self.name);
     pauseChannelAllocation();
     drainChannelPools((err) => {
@@ -104,7 +103,7 @@ function Vhost(config) {
     });
   };
 
-  this.purge = function(next) {
+  this.purge = function (next) {
     debug('Purging vhost: %s', self.name);
     purge(config, { purge: true, connectionIndex: self.connectionIndex }, (err) => {
       if (err) return next(err);
@@ -113,21 +112,22 @@ function Vhost(config) {
     });
   };
 
-  this.bounce = function(next) {
-    async.series([
-      self.disconnect,
-      self.init,
-    ], next);
+  this.bounce = function (next) {
+    async.series([self.disconnect, self.init], (err) => {
+      if (err) return next(err);
+      debug('Finished bouncing vhost: %s', self.name);
+      setImmediate(next);
+    });
   };
 
-  this.connect = function(next) {
+  this.connect = function (next) {
     debug('Connecting to vhost: %s', self.name);
     connect(config, { connectionIndex: self.connectionIndex }, (err, config, ctx) => {
       return next(err, ctx.connection);
     });
   };
 
-  this.disconnect = function(next) {
+  this.disconnect = function (next) {
     debug('Disconnecting from vhost: %s', self.name);
     if (!connection) return next();
     connection.removeAllListeners();
@@ -140,51 +140,51 @@ function Vhost(config) {
     });
   };
 
-  this.getChannel = function(next) {
+  this.getChannel = function (next) {
     channelCreator.push({ confirm: false }, next);
     debug('Requested channel. Outstanding channel requests: %d', channelCreator.length());
   };
 
-  this.getConfirmChannel = function(next) {
+  this.getConfirmChannel = function (next) {
     channelCreator.push({ confirm: true }, next);
     debug('Requested confirm channel. Outstanding channel requests: %d', channelCreator.length());
   };
 
-  this.borrowChannel = function(next) {
+  this.borrowChannel = function (next) {
     if (!regularChannelPool) return next(new Error(format('Vhost: %s must be initialised before you can borrow a channel', self.name)));
     regularChannelPool.borrow(next);
   };
 
-  this.returnChannel = function(channel) {
+  this.returnChannel = function (channel) {
     if (!regularChannelPool) return;
     regularChannelPool.release(channel);
   };
 
-  this.destroyChannel = function(channel) {
+  this.destroyChannel = function (channel) {
     if (!regularChannelPool) return;
     regularChannelPool.destroy(channel);
   };
 
-  this.borrowConfirmChannel = function(next) {
+  this.borrowConfirmChannel = function (next) {
     if (!confirmChannelPool) return next(new Error(format('Vhost: %s must be initialised before you can borrow a confirm channel', self.name)));
     confirmChannelPool.borrow(next);
   };
 
-  this.returnConfirmChannel = function(channel) {
+  this.returnConfirmChannel = function (channel) {
     if (!confirmChannelPool) return;
     confirmChannelPool.release(channel);
   };
 
-  this.destroyConfirmChannel = function(channel) {
+  this.destroyConfirmChannel = function (channel) {
     if (!confirmChannelPool) return;
     confirmChannelPool.destroy(channel);
   };
 
-  this.isPaused = function() {
+  this.isPaused = function () {
     return paused;
   };
 
-  this.getConnectionDetails = function() {
+  this.getConnectionDetails = function () {
     return { vhost: self.name, connectionUrl: connectionConfig.loggableUrl };
   };
 
@@ -281,37 +281,46 @@ function Vhost(config) {
 
     function release(channel) {
       debug('Releasing %s channel: %s. %o', mode, channel._rascal_id, stats());
-      pool.release(channel).catch((err) => {
-        debug('Error releasing %s channel: %s. %s', mode, channel._rascal_id, err.message);
-      }).then(() => {
-        if (poolQueue.length() > 0 || !busy) return;
-        busy = false;
-        self.emit('ready', stats());
-      });
+      pool
+        .release(channel)
+        .catch((err) => {
+          debug('Error releasing %s channel: %s. %s', mode, channel._rascal_id, err.message);
+        })
+        .then(() => {
+          if (poolQueue.length() > 0 || !busy) return;
+          busy = false;
+          self.emit('ready', stats());
+        });
     }
 
     function destroy(channel) {
       debug('Destroying %s channel: %s. %o', mode, channel._rascal_id, stats());
-      pool.destroy(channel).catch((err) => {
-        debug('Error destroying %s channel: %s. %s', mode, channel._rascal_id, err.message);
-      }).then(() => {
-        if (poolQueue.length() > 0 || !busy) return;
-        busy = false;
-        self.emit('ready', stats());
-      });
+      pool
+        .destroy(channel)
+        .catch((err) => {
+          debug('Error destroying %s channel: %s. %s', mode, channel._rascal_id, err.message);
+        })
+        .then(() => {
+          if (poolQueue.length() > 0 || !busy) return;
+          busy = false;
+          self.emit('ready', stats());
+        });
     }
 
     function drain(next) {
       debug('Draining %s channel pool. %o', mode, stats());
-      pool.drain().then(() => {
-        return pool.clear().then(() => {
-          debug('Drained %s channel pool. %o', mode, stats());
+      pool
+        .drain()
+        .then(() => {
+          return pool.clear().then(() => {
+            debug('Drained %s channel pool. %o', mode, stats());
+            setImmediate(next);
+          });
+        })
+        .catch((err) => {
+          debug('Error draining %s channel pool. %s', mode, err.message);
           setImmediate(next);
         });
-      }).catch((err) => {
-        debug('Error draining %s channel pool. %s', mode, err.message);
-        setImmediate(next);
-      });
     }
 
     debug('Creating %s channel pool %o', mode, options.pool);
@@ -324,11 +333,14 @@ function Vhost(config) {
     });
 
     poolQueue = async.queue((__, next) => {
-      pool.acquire().then((channel) => {
-        setImmediate(() => {
-          next(null, channel);
-        });
-      }).catch(next);
+      pool
+        .acquire()
+        .then((channel) => {
+          setImmediate(() => {
+            next(null, channel);
+          });
+        })
+        .catch(next);
     }, 1);
 
     return {
@@ -351,13 +363,12 @@ function Vhost(config) {
     });
     function onVhostInitialised() {
       debug('Vhost: %s was initialised. Resuming channel creation', self.name);
-      createChannel(confirm, next);      
+      createChannel(confirm, next);
     }
     self.once('vhost_initialised', onVhostInitialised);
   }
 
   function createChannel(confirm, next) {
-
     if (shuttingDown) {
       debug('Ignoring create channel request. Vhost: %s is shutting down.', self.name);
       return next();
@@ -392,6 +403,7 @@ function Vhost(config) {
 
       channel._rascal_id = channelId;
       channel.connection._rascal_id = connection._rascal_id;
+      channel.connection.setMaxListeners(0);
       debug('Created %s channel: %s from connection: %s', getChannelMode(confirm), channel._rascal_id, connection._rascal_id);
 
       // See https://github.com/squaremo/amqp.node/issues/388
@@ -434,19 +446,32 @@ function Vhost(config) {
   }
 
   function ensureChannelPools() {
-    regularChannelPool = regularChannelPool || createChannelPool({ confirm: false, pool: config.publicationChannelPools.regularPool });
-    confirmChannelPool = confirmChannelPool || createChannelPool({ confirm: true, pool: config.publicationChannelPools.confirmPool });
+    regularChannelPool =
+      regularChannelPool ||
+      createChannelPool({
+        confirm: false,
+        pool: config.publicationChannelPools.regularPool,
+      });
+    confirmChannelPool =
+      confirmChannelPool ||
+      createChannelPool({
+        confirm: true,
+        pool: config.publicationChannelPools.confirmPool,
+      });
   }
 
   function drainChannelPools(next) {
-    async.series([
-      function(cb) {
-        regularChannelPool ? regularChannelPool.drain(cb) : cb();
-      },
-      function(cb) {
-        confirmChannelPool ? confirmChannelPool.drain(cb) : cb();
-      },
-    ], next);
+    async.series(
+      [
+        function (cb) {
+          regularChannelPool ? regularChannelPool.drain(cb) : cb();
+        },
+        function (cb) {
+          confirmChannelPool ? confirmChannelPool.drain(cb) : cb();
+        },
+      ],
+      next
+    );
   }
 
   function attachErrorHandlers(config) {
@@ -462,11 +487,12 @@ function Vhost(config) {
     connection = undefined;
     self.emit('disconnect');
     self.emit('error', err, self.getConnectionDetails());
-    connectionConfig.retry && self.init((err) => {
-      if (!err) return;
-      const delay = timer.next();
-      debug('Will attempt reconnection in in %dms', delay);
-      reconnectTimeout = setTimeoutUnref(handleConnectionError.bind(null, borked, config, err), delay);
-    });
+    connectionConfig.retry &&
+      self.init((err) => {
+        if (!err) return;
+        const delay = timer.next();
+        debug('Will attempt reconnection in in %dms', delay);
+        reconnectTimeout = setTimeoutUnref(handleConnectionError.bind(null, borked, config, err), delay);
+      });
   }
 }

package/lib/amqp/tasks/applyBindings.js

@@ -4,17 +4,20 @@ const _ = require('lodash');
 const async = require('async');
 
 module.exports = _.curry((config, ctx, next) => {
-
   const bind = {
     queue: bindQueue,
     exchange: bindExchange,
   };
 
-  async.eachSeries(_.values(config.bindings), (binding, callback) => {
-    bind[binding.destinationType](config, ctx.channel, binding, callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.values(config.bindings),
+    (binding, callback) => {
+      bind[binding.destinationType](config, ctx.channel, binding, callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function bindQueue(config, channel, binding, next) {

package/lib/amqp/tasks/assertExchanges.js

@@ -3,11 +3,15 @@ const _ = require('lodash');
 const async = require('async');
 
 module.exports = _.curry((config, ctx, next) => {
-  async.eachSeries(_.keys(config.exchanges), (name, callback) => {
-    assertExchange(ctx.channel, config.exchanges[name], callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.keys(config.exchanges),
+    (name, callback) => {
+      assertExchange(ctx.channel, config.exchanges[name], callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function assertExchange(channel, config, next) {

package/lib/amqp/tasks/assertQueues.js

@@ -3,11 +3,15 @@ const _ = require('lodash');
 const async = require('async');
 
 module.exports = _.curry((config, ctx, next) => {
-  async.eachSeries(_.keys(config.queues), (name, callback) => {
-    assertQueue(ctx.channel, config.queues[name], callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.keys(config.queues),
+    (name, callback) => {
+      assertQueue(ctx.channel, config.queues[name], callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function assertQueue(channel, config, next) {

package/lib/amqp/tasks/assertVhost.js

@@ -7,17 +7,21 @@ module.exports = _.curry((config, ctx, next) => {
   if (!config.assert) return next(null, config, ctx);
   const candidates = config.connections;
 
-  async.retry(candidates.length, (cb) => {
-    const connectionConfig = candidates[ctx.connectionIndex];
-    client.assertVhost(config.name, connectionConfig.management, (err) => {
-      if (err) {
-        ctx.connectionIndex = (ctx.connectionIndex + 1) % candidates.length;
-        return cb(err);
-      }
-      ctx.connectionConfig = connectionConfig;
-      cb();
-    });
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.retry(
+    candidates.length,
+    (cb) => {
+      const connectionConfig = candidates[ctx.connectionIndex];
+      client.assertVhost(config.name, connectionConfig.management, (err) => {
+        if (err) {
+          ctx.connectionIndex = (ctx.connectionIndex + 1) % candidates.length;
+          return cb(err);
+        }
+        ctx.connectionConfig = connectionConfig;
+        cb();
+      });
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });

package/lib/amqp/tasks/bounceVhost.js

@@ -1,4 +1,4 @@
-module.exports = function(config, ctx, next) {
+module.exports = function (config, ctx, next) {
   ctx.vhost.bounce((err) => {
     if (err) return next(err);
     return next(null, config, ctx);

package/lib/amqp/tasks/checkExchanges.js

@@ -3,11 +3,15 @@ const _ = require('lodash');
 const async = require('async');
 
 module.exports = _.curry((config, ctx, next) => {
-  async.eachSeries(_.keys(config.exchanges), (name, callback) => {
-    checkExchange(ctx.channel, config.exchanges[name], callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.keys(config.exchanges),
+    (name, callback) => {
+      checkExchange(ctx.channel, config.exchanges[name], callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function checkExchange(channel, config, next) {

package/lib/amqp/tasks/checkQueues.js

@@ -3,11 +3,15 @@ const _ = require('lodash');
 const async = require('async');
 
 module.exports = _.curry((config, ctx, next) => {
-  async.eachSeries(_.keys(config.queues), (name, callback) => {
-    checkQueue(ctx.channel, config.queues[name], callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.keys(config.queues),
+    (name, callback) => {
+      checkQueue(ctx.channel, config.queues[name], callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function checkQueue(channel, config, next) {

package/lib/amqp/tasks/checkVhost.js

@@ -7,17 +7,21 @@ module.exports = _.curry((config, ctx, next) => {
   if (!config.check) return next(null, config, ctx);
   const candidates = config.connections;
 
-  async.retry(candidates.length, (cb) => {
-    const connectionConfig = candidates[ctx.connectionIndex];
-    client.checkVhost(config.name, connectionConfig.management, (err) => {
-      if (err) {
-        ctx.connectionIndex = (ctx.connectionIndex + 1) % candidates.length;
-        return cb(err);
-      }
-      ctx.connectionConfig = connectionConfig;
-      cb();
-    });
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.retry(
+    candidates.length,
+    (cb) => {
+      const connectionConfig = candidates[ctx.connectionIndex];
+      client.checkVhost(config.name, connectionConfig.management, (err) => {
+        if (err) {
+          ctx.connectionIndex = (ctx.connectionIndex + 1) % candidates.length;
+          return cb(err);
+        }
+        ctx.connectionConfig = connectionConfig;
+        cb();
+      });
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });

package/lib/amqp/tasks/closeChannel.js

@@ -2,7 +2,6 @@ const debug = require('debug')('rascal:tasks:closeChannel');
 const _ = require('lodash');
 
 module.exports = _.curry((config, ctx, next) => {
-
   debug('Closing channel');
 
   ctx.channel.close((err) => {

package/lib/amqp/tasks/createChannel.js

@@ -2,7 +2,6 @@ const debug = require('debug')('rascal:tasks:createChannel');
 const _ = require('lodash');
 
 module.exports = _.curry((config, ctx, next) => {
-
   debug('Creating channel');
 
   ctx.connection.createChannel((err, channel) => {