rascal 16.1.1 → 16.2.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 16.2.0
+
+- Disable indirect dependabot updates (they're almost pointless for modules since package-lock.json isn't published)
+- Support acknowledging / rejecting all outstanding messages
+
+## 16.1.2
+
+- Add consumer tag subscription option to JSON schema
+
 ## 16.1.1
 
 - Updated README

package/README.md

@@ -1181,7 +1181,7 @@ await subscription = broker.subscribe("s1", { prefetch: 10, retry: false })
 
 The arguments passed to the message event handler are `function(message, content, ackOrNack)`, where message is the raw message, the content (a buffer, text, or object) and an ackOrNack callback. This ackOrNack callback should only be used for messages which were not `{ "options": { "noAck": true } }` by the subscription configuration or the options passed to `broker.subscribe`. For more details on acking or nacking messages see [Message Acknowledgement and Recovery Strategies](#message-acknowledgement-and-recovery-strategies).
 
-> As with publications, you can nest subscriptions inside the vhost block. Rascal creates default subscriptions for every queue so providing you don't need to specify any additional options you don't need to include a subscriptions block at all.
+As with publications, you can nest subscriptions inside the vhost block. Rascal creates default subscriptions for every queue so providing you don't need to specify any additional options you don't need to include a subscriptions block at all.
 
 #### Subscribe All
 
@@ -1412,7 +1412,7 @@ See [here](https://www.npmjs.com/package/rascal-redis-counter) for a redis backe
 
 #### Message Acknowledgement and Recovery Strategies
 
-For messages which are not auto-acknowledged (the default) calling `ackOrNack()` with no arguments will acknowledge it. Calling `ackOrNack(err)` will nack the message using Rascal's default recovery strategy (nack with requeue). Calling `ackOrNack(err, recoveryOptions)` will trigger the specified recovery strategy or strategies.
+For messages which are not auto-acknowledged (the default) calling `ackOrNack()` with no arguments will acknowledge it. Calling `ackOrNack(err)` will nack the message using Rascal's default recovery strategy (nack with requeue). Calling `ackOrNack(err, recoveryOptions)` will trigger the specified recovery strategy or strategies. You can also acknowledge all outstanding messages on the channel by calling `ackOrNack(null, { all: true })`.
 
 When using the callback API, you can call ackOrNack without a callback and errors will be emitted by the subscription. Alternatively you can specify a callback as the final argument irrespective of what other arguments you provide.
 
@@ -1424,7 +1424,11 @@ When using the promises API, ackOrNack will work as for the callback API unless
 ackOrNack(err, { strategy: 'nack' });
 ```
 
-Nack causes the message to be discarded or routed to a dead letter exchange if configured.
+Nack causes the message to be discarded or routed to a dead letter exchange if configured. You can also negatively acknowledge all outstanding messages on a channel as follows
+
+```js
+ackOrNac(err, { strategy: 'nack', all: true });
+```
 
 ##### Nack with Requeue
 

package/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'npm'
+    directory: '/'
+    allow:
+      - dependency-type: 'direct'

package/lib/amqp/SubscriberError.js

@@ -5,11 +5,11 @@ const async = require('async');
 const setTimeoutUnref = require('../utils/setTimeoutUnref');
 
 module.exports = function SubscriptionRecovery(broker, vhost) {
-  this.handle = function (session, message, err, recoveryProcess, next) {
+  this.handle = function (session, message, err, recoveryOptions, next) {
     debug('Handling subscriber error for message: %s', message.properties.messageId);
 
     async.eachSeries(
-      [].concat(recoveryProcess || []).concat({ strategy: 'fallback-nack' }),
+      [].concat(recoveryOptions || []).concat({ strategy: 'fallback-nack' }),
       (recoveryConfig, cb) => {
         debug('Attempting to recover message: %s using strategy: %s', message.properties.messageId, recoveryConfig.strategy);
 
@@ -40,7 +40,8 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
       {
         name: 'ack',
         execute(session, message, err, strategyConfig, next) {
-          session._ack(message, (err) => {
+          const ackFn = strategyConfig.all ? session._nackAll.bind(session) : session._nack.bind(session);
+          ackFn(message, (err) => {
             next(err, true);
           });
         },
@@ -48,7 +49,8 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
       {
         name: 'nack',
         execute(session, message, err, strategyConfig, next) {
-          session._nack(message, { requeue: strategyConfig.requeue }, (err) => {
+          const nackFn = strategyConfig.all ? session._nackAll.bind(session) : session._nack.bind(session);
+          nackFn(message, { requeue: strategyConfig.requeue }, (err) => {
             next(err, true);
           });
         },

package/lib/amqp/SubscriberSession.js

@@ -95,6 +95,14 @@ function SubscriberSession(sequentialChannelOperations, config) {
     });
   };
 
+  this._resetUnacknowledgedMessageCount = function (consumerTag) {
+    if (config.options.noAck) return;
+    withConsumerChannel(consumerTag, (channel, __, entry) => {
+      entry.unacknowledgedMessages = 0;
+      debug('Channel: %s has %s unacknowledged messages', channel._rascal_id, entry.unacknowledgedMessages);
+    });
+  };
+
   this._ack = function (message, next) {
     withConsumerChannel(
       message.fields.consumerTag,
@@ -112,6 +120,23 @@ function SubscriberSession(sequentialChannelOperations, config) {
     );
   };
 
+  this._ackAll = function (message, next) {
+    withConsumerChannel(
+      message.fields.consumerTag,
+      (channel) => {
+        debug('Acknowledging all messages on channel: %s', message.properties.messageId, channel._rascal_id);
+        channel.ackAll();
+        self._resetUnacknowledgedMessageCount(message.fields.consumerTag);
+        setImmediate(next);
+      },
+      () => {
+        setImmediate(() => {
+          next(new Error('The channel has been closed. Unable to ack messages'));
+        });
+      }
+    );
+  };
+
   this._nack = function (message, options, next) {
     if (arguments.length === 2) return self._nack(arguments[0], {}, arguments[1]);
     withConsumerChannel(
@@ -130,6 +155,24 @@ function SubscriberSession(sequentialChannelOperations, config) {
     );
   };
 
+  this._nackAll = function (message, options, next) {
+    if (arguments.length === 2) return self._nackAll(arguments[0], {}, arguments[1]);
+    withConsumerChannel(
+      message.fields.consumerTag,
+      (channel) => {
+        debug('Not acknowledging all messages with requeue: %s on channel: %s', message.properties.messageId, !!options.requeue, channel._rascal_id);
+        channel.nack(message, true, !!options.requeue);
+        self._resetUnacknowledgedMessageCount(message.fields.consumerTag);
+        setImmediate(next);
+      },
+      () => {
+        setImmediate(() => {
+          next(new Error('The channel has been closed. Unable to nack messages'));
+        });
+      }
+    );
+  };
+
   function withCurrentChannel(fn, altFn) {
     const entry = _.chain(channels)
       .values()

package/lib/amqp/Subscription.js

@@ -208,24 +208,28 @@ function Subscription(broker, vhost, subscriptionConfig, counter) {
     return ackOrNack.bind(null, session, message);
   }
 
-  function ackOrNack(session, message, err, recovery, next) {
+  function ackOrNack(session, message, err, options, next) {
     if (arguments.length === 2) return ackOrNack(session, message, undefined, undefined, emitOnError.bind(null, session));
     if (arguments.length === 3 && _.isFunction(arguments[2])) return ackOrNack(session, message, undefined, undefined, arguments[2]);
     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);
+    if (arguments.length === 4) return ackOrNack(session, message, err, options, emitOnError.bind(null, session));
+    if (err) return subscriberError.handle(session, message, err, options, next);
+    if (options && options.all) return session._ackAll(message, next);
+    session._ack(message, next);
   }
 
-  function ackOrNackP(session, message, err, recovery) {
+  function ackOrNackP(session, message, err, options) {
     if (arguments.length === 2) return ackOrNackP(session, message, undefined, undefined);
     if (arguments.length === 3) return ackOrNackP(session, message, err, undefined);
 
     return new Promise((resolve, reject) => {
-      const cb = function (err) {
+      const next = function (err) {
         err ? reject(err) : resolve();
       };
-      err ? subscriberError.handle(session, message, err, recovery, cb) : session._ack(message, cb);
+      if (err) subscriberError.handle(session, message, err, options, next);
+      else if (options && options.all) session._ackAll(message, next);
+      else session._ack(message, next);
     });
   }
 

package/lib/config/schema.json

@@ -619,6 +619,9 @@
             },
             "arguments": {
               "type": "object"
+            },
+            "consumerTag": {
+              "type": "string"
             }
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rascal",
-  "version": "16.1.1",
+  "version": "16.2.0",
   "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": {