rascal 13.1.0 → 14.0.0

package/lib/amqp/Broker.js

@@ -28,7 +28,6 @@ module.exports = {
 inherits(Broker, EventEmitter);
 
 function Broker(config, components) {
-
   const self = this;
   let vhosts = {};
   let publications = {};
@@ -40,12 +39,16 @@ function Broker(config, components) {
   const forewarnVhost = tasks.forewarnVhost;
   const shutdownVhost = tasks.shutdownVhost;
   const bounceVhost = tasks.bounceVhost;
-  const counters = _.defaults({}, components.counters, { stub, inMemory, inMemoryCluster });
+  const counters = _.defaults({}, components.counters, {
+    stub,
+    inMemory,
+    inMemoryCluster,
+  });
 
   this.config = config;
   this.promises = false;
 
-  this._init = function(next) {
+  this._init = function (next) {
     debug('Initialising broker');
     vhosts = {};
     publications = {};
@@ -59,87 +62,107 @@ function Broker(config, components) {
     });
   };
 
-  this.connect = function(name, next) {
+  this.connect = function (name, next) {
     if (!vhosts[name]) return next(new Error(format('Unknown vhost: %s', name)));
     vhosts[name].connect(next);
   };
 
-  this.nuke = function(next) {
-    debug('Nuking broker');
-    self.unsubscribeAll((err) => {
-      if (err) return next(err);
-      async.eachSeries(_.values(vhosts), (vhost, callback) => {
-        nukeVhost(config, { vhost }, callback);
-      }, (err) => {
+  this.purge = function (next) {
+    debug('Purging all queues in all vhosts');
+    async.eachSeries(
+      _.values(vhosts),
+      (vhost, callback) => {
+        purgeVhost(config, { vhost }, callback);
+      },
+      (err) => {
         if (err) return next(err);
-        vhosts = publications = subscriptions = {};
-        clearInterval(self.keepActive);
-        debug('Finished nuking broker');
+        debug('Finished purging all queues in all vhosts');
         next();
-      });
-    });
-  };
-
-  this.purge = function(next) {
-    debug('Purging all queues in all vhosts');
-    async.eachSeries(_.values(vhosts), (vhost, callback) => {
-      purgeVhost(config, { vhost }, callback);
-    }, (err) => {
-      if (err) return next(err);
-      debug('Finished purging all queues in all vhosts');
-      next();
-    });
+      }
+    );
   };
 
-  this.shutdown = function(next) {
+  this.shutdown = function (next) {
     debug('Shutting down broker');
-    async.eachSeries(_.values(vhosts), (vhost, callback) => {
-      forewarnVhost(config, { vhost }, callback);
-    }, (err) => {
-      if (err) return next(err);
-      self.unsubscribeAll((err) => {
+    async.eachSeries(
+      _.values(vhosts),
+      (vhost, callback) => {
+        forewarnVhost(config, { vhost }, callback);
+      },
+      (err) => {
         if (err) return next(err);
-        async.eachSeries(_.values(vhosts), (vhost, callback) => {
-          shutdownVhost(config, { vhost }, callback);
-        }, (err) => {
+        self.unsubscribeAll((err) => {
+          if (err) self.emit('error', err);
+          async.eachSeries(
+            _.values(vhosts),
+            (vhost, callback) => {
+              shutdownVhost(config, { vhost }, callback);
+            },
+            (err) => {
+              if (err) return next(err);
+              clearInterval(self.keepActive);
+              debug('Finished shutting down broker');
+              next();
+            }
+          );
+        });
+      }
+    );
+  };
+
+  this.bounce = function (next) {
+    debug('Bouncing broker');
+    self.unsubscribeAll((err) => {
+      if (err) self.emit('error', err);
+      async.eachSeries(
+        _.values(vhosts),
+        (vhost, callback) => {
+          bounceVhost(config, { vhost }, callback);
+        },
+        (err) => {
           if (err) return next(err);
-          clearInterval(self.keepActive);
-          debug('Finished shutting down broker');
+          debug('Finished bouncing broker');
           next();
-        });
-      });
+        }
+      );
     });
   };
 
-  this.bounce = function(next) {
-    debug('Bouncing broker');
+  this.nuke = function (next) {
+    debug('Nuking broker');
     self.unsubscribeAll((err) => {
-      if (err) return next(err);
-      async.eachSeries(_.values(vhosts), (vhost, callback) => {
-        bounceVhost(config, { vhost }, callback);
-      }, (err) => {
-        if (err) return next(err);
-        debug('Finished bouncing broker');
-        next();
-      });
+      if (err) self.emit('error', err);
+      async.eachSeries(
+        _.values(vhosts),
+        (vhost, callback) => {
+          nukeVhost(config, { vhost }, callback);
+        },
+        (err) => {
+          if (err) return next(err);
+          vhosts = publications = subscriptions = {};
+          clearInterval(self.keepActive);
+          debug('Finished nuking broker');
+          next();
+        }
+      );
     });
   };
 
-  this.publish = function(name, message, overrides, next) {
+  this.publish = function (name, message, overrides, next) {
     if (arguments.length === 3) return self.publish(name, message, {}, arguments[2]);
     if (_.isString(overrides)) return self.publish(name, message, { routingKey: overrides }, next);
     if (!publications[name]) return next(new Error(format('Unknown publication: %s', name)));
     publications[name].publish(message, overrides, next);
   };
 
-  this.forward = function(name, message, overrides, next) {
+  this.forward = function (name, message, overrides, next) {
     if (arguments.length === 3) return self.forward(name, message, {}, arguments[2]);
     if (_.isString(overrides)) return self.forward(name, message, { routingKey: overrides }, next);
     if (!config.publications[name]) return next(new Error(format('Unknown publication: %s', name)));
     publications[name].forward(message, overrides, next);
   };
 
-  this.subscribe = function(name, overrides, next) {
+  this.subscribe = function (name, overrides, next) {
     if (arguments.length === 2) return self.subscribe(name, {}, arguments[1]);
     if (!subscriptions[name]) return next(new Error(format('Unknown subscription: %s', name)));
     subscriptions[name].subscribe(overrides, (err, session) => {
@@ -149,54 +172,54 @@ function Broker(config, components) {
     });
   };
 
-  this.subscribeAll = function(filter, next) {
-    if (arguments.length === 1) return self.subscribeAll(() => { return true; }, arguments[0]);
+  this.subscribeAll = function (filter, next) {
+    if (arguments.length === 1)
+      return self.subscribeAll(() => {
+        return true;
+      }, arguments[0]);
     const filteredSubscriptions = _.chain(config.subscriptions).values().filter(filter).value();
-    async.mapSeries(filteredSubscriptions, (subscriptionConfig, cb) => {
-      self.subscribe(subscriptionConfig.name, (err, subscription) => {
-        if (err) return cb(err);
-        cb(null, subscription);
-      });
-    }, next);
+    async.mapSeries(
+      filteredSubscriptions,
+      (subscriptionConfig, cb) => {
+        self.subscribe(subscriptionConfig.name, (err, subscription) => {
+          if (err) return cb(err);
+          cb(null, subscription);
+        });
+      },
+      next
+    );
   };
 
-  this.unsubscribeAll = function(next) {
-    const timeout = getMaxDeferCloseChannelTimeout();
-    async.eachSeries(sessions.slice(), (session, cb) => {
-      sessions.shift();
-      session.cancel(cb);
-    }, (err) => {
-      if (err) return next(err);
-      debug('Waiting %dms for all subscriber channels to close', timeout);
-      setTimeoutUnref(next, timeout);
-    });
+  this.unsubscribeAll = function (next) {
+    async.each(
+      sessions.slice(),
+      (session, cb) => {
+        sessions.shift();
+        session.cancel(cb);
+      },
+      next
+    );
   };
 
-  this.getConnections = function() {
+  this.getConnections = function () {
     return Object.keys(vhosts).map((name) => {
       return vhosts[name].getConnectionDetails();
     });
   };
 
-  this.getFullyQualifiedName = this.qualify = function(vhost, name) {
+  this.getFullyQualifiedName = this.qualify = function (vhost, name) {
     return fqn.qualify(name, config.vhosts[vhost].namespace);
   };
 
-  this._addVhost = function(vhost) {
+  this._addVhost = function (vhost) {
     vhosts[vhost.name] = vhost;
   };
 
-  this._addPublication = function(publication) {
+  this._addPublication = function (publication) {
     publications[publication.name] = publication;
   };
 
-  this._addSubscription = function(subscription) {
+  this._addSubscription = function (subscription) {
     subscriptions[subscription.name] = subscription;
   };
-
-  function getMaxDeferCloseChannelTimeout() {
-    return sessions.reduce((value, session) => {
-      return session._maxDeferCloseChannel(value);
-    }, 0);
-  }
 }

package/lib/amqp/BrokerAsPromised.js

@@ -9,15 +9,20 @@ module.exports = {
   create() {
     const args = Array.prototype.slice.call(arguments);
     return new Promise((resolve, reject) => {
-      Broker.create(...args.concat((err, broker) => {
-        if (err && !broker) return reject(err);
-        broker.promises = true;
-        const brokerAsPromised = new BrokerAsPromised(broker);
-        if (!err) return resolve(brokerAsPromised);
-        err.broker = Symbol();
-        Object.defineProperty(err, err.broker, { enumerable: false, value: brokerAsPromised });
-        return reject(err);
-      }));
+      Broker.create(
+        ...args.concat((err, broker) => {
+          if (err && !broker) return reject(err);
+          broker.promises = true;
+          const brokerAsPromised = new BrokerAsPromised(broker);
+          if (!err) return resolve(brokerAsPromised);
+          err.broker = Symbol();
+          Object.defineProperty(err, err.broker, {
+            enumerable: false,
+            value: brokerAsPromised,
+          });
+          return reject(err);
+        })
+      );
     });
   },
 };
@@ -25,20 +30,21 @@ module.exports = {
 inherits(BrokerAsPromised, EventEmitter);
 
 function BrokerAsPromised(broker) {
-
   const methods = ['connect', 'nuke', 'purge', 'shutdown', 'bounce', 'publish', 'forward', 'unsubscribeAll'];
   const self = this;
 
   forwardEvents(broker, this);
 
   _.each(methods, (method) => {
-    self[method] = function() {
+    self[method] = function () {
       const args = Array.prototype.slice.call(arguments);
       return new Promise((resolve, reject) => {
-        broker[method](...args.concat((err, result) => {
-          if (err) return reject(err);
-          resolve(result);
-        }));
+        broker[method](
+          ...args.concat((err, result) => {
+            if (err) return reject(err);
+            resolve(result);
+          })
+        );
       });
     };
   });
@@ -46,29 +52,35 @@ function BrokerAsPromised(broker) {
   this.config = broker.config;
   this.getConnections = broker.getConnections;
 
-  this.subscribe = function() {
+  this.subscribe = function () {
     const args = Array.prototype.slice.call(arguments);
     return new Promise((resolve, reject) => {
-      broker.subscribe(...args.concat((err, session) => {
-        if (err) return reject(err);
-        resolve(new SubscriberSessionAsPromised(session));
-      }));
+      broker.subscribe(
+        ...args.concat((err, session) => {
+          if (err) return reject(err);
+          resolve(new SubscriberSessionAsPromised(session));
+        })
+      );
     });
   };
 
-  this.subscribeAll = function() {
+  this.subscribeAll = function () {
     const args = Array.prototype.slice.call(arguments);
     return new Promise((resolve, reject) => {
-      broker.subscribeAll(...args.concat((err, sessions) => {
-        if (err) return reject(err);
-        resolve(sessions.map((session) => {
-          return new SubscriberSessionAsPromised(session);
-        }));
-      }));
+      broker.subscribeAll(
+        ...args.concat((err, sessions) => {
+          if (err) return reject(err);
+          resolve(
+            sessions.map((session) => {
+              return new SubscriberSessionAsPromised(session);
+            })
+          );
+        })
+      );
     });
   };
 
-  this.getFullyQualifiedName = this.qualify = function(vhost, name) {
+  this.getFullyQualifiedName = this.qualify = function (vhost, name) {
     return broker.qualify(vhost, name);
   };
 }

package/lib/amqp/Publication.js

@@ -23,30 +23,29 @@ module.exports = {
 };
 
 function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn, publishFn, config) {
-
   const self = this;
 
   this.name = config.name;
 
-  this.init = function(next) {
+  this.init = function (next) {
     debug('Initialising publication: %s', config.name);
     next(null, self);
   };
 
-  this.publish = function(payload, overrides, next) {
+  this.publish = function (payload, overrides, next) {
     const publishConfig = _.defaultsDeep({}, overrides, config);
     const content = getContent(payload);
     publishConfig.options.contentType = publishConfig.options.contentType || content.type;
     publishConfig.options.messageId = publishConfig.options.messageId || uuid();
 
-    publishConfig.encryption
-      ? _publishEncrypted(content.buffer, publishConfig, next)
-      : _publish(content.buffer, publishConfig, next);
+    publishConfig.encryption ? _publishEncrypted(content.buffer, publishConfig, next) : _publish(content.buffer, publishConfig, next);
   };
 
-  this.forward = function(message, overrides, next) {
+  this.forward = function (message, overrides, next) {
     const originalQueue = message.properties.headers.rascal.originalQueue;
-    const publishConfig = _.defaultsDeep({}, overrides, config, { routingKey: message.fields.routingKey });
+    const publishConfig = _.defaultsDeep({}, overrides, config, {
+      routingKey: message.fields.routingKey,
+    });
 
     publishConfig.options = _.defaultsDeep(publishConfig.options, message.properties);
 
@@ -64,7 +63,7 @@ function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn,
       if (err) return next(err);
       debug('Message was encrypted using encryption profile: %s', encryptionConfig.name);
       _.set(publishConfig, 'options.headers.rascal.encryption.name', encryptionConfig.name);
-      _.set(publishConfig, 'options.headers.rascal.encryption.iv', iv );
+      _.set(publishConfig, 'options.headers.rascal.encryption.iv', iv);
       _.set(publishConfig, 'options.headers.rascal.encryption.originalContentType', publishConfig.options.contentType);
       _.set(publishConfig, 'options.contentType', 'application/octet-stream');
 
@@ -106,12 +105,11 @@ function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn,
             return session.emit('error', err, messageId);
           }
 
-          ok ? returnChannel(channel, errorHandler, returnHandler)
-             : deferReturnChannel(channel, errorHandler, returnHandler);
+          ok ? returnChannel(channel, errorHandler, returnHandler) : deferReturnChannel(channel, errorHandler, returnHandler);
 
           session.emit('success', messageId);
         });
-      } catch(err) {
+      } catch (err) {
         returnChannel(channel, errorHandler, returnHandler);
         return session.emit('error', err, messageId);
       }
@@ -152,11 +150,14 @@ function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn,
   }
 
   function textMessage(payload) {
-    return { buffer: Buffer.from(payload), type : 'text/plain' };
+    return { buffer: Buffer.from(payload), type: 'text/plain' };
   }
 
   function jsonMessage(payload) {
-    return { buffer: Buffer.from(JSON.stringify(payload)), type: 'application/json' };
+    return {
+      buffer: Buffer.from(JSON.stringify(payload)),
+      type: 'application/json',
+    };
   }
 }
 

package/lib/amqp/PublicationSession.js

@@ -7,29 +7,28 @@ module.exports = PublicationSession;
 inherits(PublicationSession, EventEmitter);
 
 function PublicationSession(vhost, messageId) {
-
   const self = this;
   let aborted = false;
 
   this.stats = {};
 
-  this.abort = function() {
+  this.abort = function () {
     aborted = true;
   };
 
-  this.isAborted = function() {
+  this.isAborted = function () {
     return aborted;
   };
 
-  this._removePausedListener = function() {
-    vhost.removeListener('paused',emitPaused);
+  this._removePausedListener = function () {
+    vhost.removeListener('paused', emitPaused);
   };
 
-  this._startPublish = function() {
+  this._startPublish = function () {
     this.started = Date.now();
   };
 
-  this._endPublish = function() {
+  this._endPublish = function () {
     this.stats.duration = Date.now() - this.started;
   };