rascal 13.1.2 → 13.1.3

package/lib/amqp/tasks/applyBindings.js

@@ -1,40 +1,73 @@
-const debug = require('debug')('rascal:tasks:applyBindings');
-const format = require('util').format;
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:applyBindings");
+const format = require("util").format;
+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) {
   const destination = config.queues[binding.destination];
-  if (!destination) return next(new Error(format('Unknown destination: %s', binding.destination)));
+  if (!destination)
+    return next(
+      new Error(format("Unknown destination: %s", binding.destination))
+    );
 
   const source = config.exchanges[binding.source];
-  if (!source) return next(new Error(format('Unknown source: %s', binding.source)));
+  if (!source)
+    return next(new Error(format("Unknown source: %s", binding.source)));
 
-  debug('Binding queue: %s to exchange: %s with binding key: %s', destination.fullyQualifiedName, source.fullyQualifiedName, binding.bindingKey);
-  channel.bindQueue(destination.fullyQualifiedName, source.fullyQualifiedName, binding.bindingKey, binding.options, next);
+  debug(
+    "Binding queue: %s to exchange: %s with binding key: %s",
+    destination.fullyQualifiedName,
+    source.fullyQualifiedName,
+    binding.bindingKey
+  );
+  channel.bindQueue(
+    destination.fullyQualifiedName,
+    source.fullyQualifiedName,
+    binding.bindingKey,
+    binding.options,
+    next
+  );
 }
 
 function bindExchange(config, channel, binding, next) {
   const destination = config.exchanges[binding.destination];
-  if (!destination) return next(new Error(format('Unknown destination: %s', binding.destination)));
+  if (!destination)
+    return next(
+      new Error(format("Unknown destination: %s", binding.destination))
+    );
 
   const source = config.exchanges[binding.source];
-  if (!source) return next(new Error(format('Unknown source: %s', binding.source)));
+  if (!source)
+    return next(new Error(format("Unknown source: %s", binding.source)));
 
-  debug('Binding exchange: %s to exchange: %s with binding key: %s', destination.fullyQualifiedName, source.fullyQualifiedName, binding.bindingKey);
-  channel.bindExchange(destination.fullyQualifiedName, source.fullyQualifiedName, binding.bindingKey, binding.options, next);
+  debug(
+    "Binding exchange: %s to exchange: %s with binding key: %s",
+    destination.fullyQualifiedName,
+    source.fullyQualifiedName,
+    binding.bindingKey
+  );
+  channel.bindExchange(
+    destination.fullyQualifiedName,
+    source.fullyQualifiedName,
+    binding.bindingKey,
+    binding.options,
+    next
+  );
 }

package/lib/amqp/tasks/assertExchanges.js

@@ -1,18 +1,27 @@
-const debug = require('debug')('rascal:tasks:assertExchanges');
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:assertExchanges");
+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) {
   if (!config.assert) return next();
-  if (config.fullyQualifiedName === '') return next();
-  debug('Asserting exchange: %s', config.fullyQualifiedName);
-  channel.assertExchange(config.fullyQualifiedName, config.type, config.options, next);
+  if (config.fullyQualifiedName === "") return next();
+  debug("Asserting exchange: %s", config.fullyQualifiedName);
+  channel.assertExchange(
+    config.fullyQualifiedName,
+    config.type,
+    config.options,
+    next
+  );
 }

package/lib/amqp/tasks/assertQueues.js

@@ -1,17 +1,21 @@
-const debug = require('debug')('rascal:tasks:assertQueues');
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:assertQueues");
+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) {
   if (!config.assert) return next();
-  debug('Asserting queue: %s', config.fullyQualifiedName);
+  debug("Asserting queue: %s", config.fullyQualifiedName);
   channel.assertQueue(config.fullyQualifiedName, config.options, next);
 }

package/lib/amqp/tasks/assertVhost.js

@@ -1,23 +1,27 @@
-const debug = require('debug')('rascal:tasks:assertVhost');
-const _ = require('lodash');
-const async = require('async');
-const client = require('../../management/client');
+const debug = require("debug")("rascal:tasks:assertVhost");
+const _ = require("lodash");
+const async = require("async");
+const client = require("../../management/client");
 
 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

@@ -1,17 +1,21 @@
-const debug = require('debug')('rascal:tasks:checkExchanges');
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:checkExchanges");
+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) {
   if (!config.check) return next();
-  debug('Checking exchange: %s', config.fullyQualifiedName);
+  debug("Checking exchange: %s", config.fullyQualifiedName);
   channel.checkExchange(config.fullyQualifiedName, next);
 }

package/lib/amqp/tasks/checkQueues.js

@@ -1,17 +1,21 @@
-const debug = require('debug')('rascal:tasks:checkQueues');
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:checkQueues");
+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) {
   if (!config.check) return next();
-  debug('Checking queue: %s', config.fullyQualifiedName);
+  debug("Checking queue: %s", config.fullyQualifiedName);
   channel.checkQueue(config.fullyQualifiedName, next);
 }

package/lib/amqp/tasks/checkVhost.js

@@ -1,23 +1,27 @@
-const debug = require('debug')('rascal:tasks:checkVhost');
-const _ = require('lodash');
-const async = require('async');
-const client = require('../../management/client');
+const debug = require("debug")("rascal:tasks:checkVhost");
+const _ = require("lodash");
+const async = require("async");
+const client = require("../../management/client");
 
 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

@@ -1,9 +1,8 @@
-const debug = require('debug')('rascal:tasks:closeChannel');
-const _ = require('lodash');
+const debug = require("debug")("rascal:tasks:closeChannel");
+const _ = require("lodash");
 
 module.exports = _.curry((config, ctx, next) => {
-
-  debug('Closing channel');
+  debug("Closing channel");
 
   ctx.channel.close((err) => {
     if (err) return next(err, config, ctx);

package/lib/amqp/tasks/closeConnection.js

@@ -1,8 +1,8 @@
-const debug = require('debug')('rascal:tasks:checkQueues');
-const _ = require('lodash');
+const debug = require("debug")("rascal:tasks:checkQueues");
+const _ = require("lodash");
 
 module.exports = _.curry((config, ctx, next) => {
-  debug('Closing connection: %s', ctx.connectionConfig.loggableUrl);
+  debug("Closing connection: %s", ctx.connectionConfig.loggableUrl);
   if (!ctx.connection) return next(null, config, ctx);
   ctx.connection.close((err) => {
     next(err, config, ctx);

package/lib/amqp/tasks/createChannel.js

@@ -1,9 +1,8 @@
-const debug = require('debug')('rascal:tasks:createChannel');
-const _ = require('lodash');
+const debug = require("debug")("rascal:tasks:createChannel");
+const _ = require("lodash");
 
 module.exports = _.curry((config, ctx, next) => {
-
-  debug('Creating channel');
+  debug("Creating channel");
 
   ctx.connection.createChannel((err, channel) => {
     if (err) return next(err, config, ctx);

package/lib/amqp/tasks/createConnection.js

@@ -1,72 +1,90 @@
-const debug = require('debug')('rascal:tasks:createConnection');
-const _ = require('lodash');
-const amqplib = require('amqplib/callback_api');
-const async = require('async');
-const format = require('util').format;
-const uuid = require('uuid').v4;
+const debug = require("debug")("rascal:tasks:createConnection");
+const _ = require("lodash");
+const amqplib = require("amqplib/callback_api");
+const async = require("async");
+const format = require("util").format;
+const uuid = require("uuid").v4;
 
 module.exports = _.curry((config, ctx, next) => {
   const candidates = config.connections;
 
-  async.retry(candidates.length, (cb) => {
-    const connectionConfig = candidates[ctx.connectionIndex];
-    connect(connectionConfig, (err, connection) => {
-      if (err) {
-        ctx.connectionIndex = (ctx.connectionIndex + 1) % candidates.length;
-        return cb(err);
-      }
-      ctx.connection = connection;
-      ctx.connectionConfig = connectionConfig;
-      cb();
-    });
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.retry(
+    candidates.length,
+    (cb) => {
+      const connectionConfig = candidates[ctx.connectionIndex];
+      connect(connectionConfig, (err, connection) => {
+        if (err) {
+          ctx.connectionIndex = (ctx.connectionIndex + 1) % candidates.length;
+          return cb(err);
+        }
+        ctx.connection = connection;
+        ctx.connectionConfig = connectionConfig;
+        cb();
+      });
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function connect(connectionConfig, cb) {
-  debug('Connecting to broker using url: %s', connectionConfig.loggableUrl);
+  debug("Connecting to broker using url: %s", connectionConfig.loggableUrl);
 
   // See https://github.com/guidesmiths/rascal/issues/17
   const once = _.once(cb);
   let invocations = 0;
 
-  amqplib.connect(connectionConfig.url, connectionConfig.socketOptions, (err, connection) => {
+  amqplib.connect(
+    connectionConfig.url,
+    connectionConfig.socketOptions,
+    (err, connection) => {
+      invocations++;
 
-    invocations++;
-
-    if (err) {
-      const betterMessage = format('Failed to connect to: %s. Original message was:', connectionConfig.loggableUrl, err.message);
-      err.message = betterMessage;
-      return once(err);
-    }
+      if (err) {
+        const betterMessage = format(
+          "Failed to connect to: %s. Original message was:",
+          connectionConfig.loggableUrl,
+          err.message
+        );
+        err.message = betterMessage;
+        return once(err);
+      }
 
-    connection._rascal_id = uuid();
-    debug('Obtained connection: %s', connection._rascal_id);
+      connection._rascal_id = uuid();
+      debug("Obtained connection: %s", connection._rascal_id);
 
-    /*
-     * If an error occurs during initialisation (e.g. if checkExchanges fails),
-     * and no error handler has been bound to the connection, then the error will bubble up
-     * to the UncaughtException handler, potentially crashing the node process.
-     *
-     * By adding an error handler now, we ensure that instead of being emitted as events
-     * errors will be passed via the callback chain, so they can still be handled by the caller
-     *
-     * This error handle is removed in the vhost after the initialiation has complete
-     */
-    connection.on('error', (err) => {
-      debug('Received error: %s from %s', err.message, connectionConfig.loggableUrl);
-      once(err);
-    });
+      /*
+       * If an error occurs during initialisation (e.g. if checkExchanges fails),
+       * and no error handler has been bound to the connection, then the error will bubble up
+       * to the UncaughtException handler, potentially crashing the node process.
+       *
+       * By adding an error handler now, we ensure that instead of being emitted as events
+       * errors will be passed via the callback chain, so they can still be handled by the caller
+       *
+       * This error handle is removed in the vhost after the initialiation has complete
+       */
+      connection.on("error", (err) => {
+        debug(
+          "Received error: %s from %s",
+          err.message,
+          connectionConfig.loggableUrl
+        );
+        once(err);
+      });
 
-    // See https://github.com/squaremo/amqp.node/issues/388
-    if (invocations > 1) {
-      debug('Closing superfluous connection: %s previously reported as errored', connection._rascal_id);
-      return connection.close();
-    }
+      // See https://github.com/squaremo/amqp.node/issues/388
+      if (invocations > 1) {
+        debug(
+          "Closing superfluous connection: %s previously reported as errored",
+          connection._rascal_id
+        );
+        return connection.close();
+      }
 
-    connection.setMaxListeners(0);
+      connection.setMaxListeners(0);
 
-    once(null, connection);
-  });
+      once(null, connection);
+    }
+  );
 }

package/lib/amqp/tasks/deleteExchanges.js

@@ -1,17 +1,21 @@
-const debug = require('debug')('rascal:tasks:deleteExchanges');
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:deleteExchanges");
+const _ = require("lodash");
+const async = require("async");
 
 module.exports = _.curry((config, ctx, next) => {
-  async.eachSeries(_.keys(config.exchanges), (name, callback) => {
-    deleteExchange(ctx.channel, config.exchanges[name], callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.keys(config.exchanges),
+    (name, callback) => {
+      deleteExchange(ctx.channel, config.exchanges[name], callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function deleteExchange(channel, config, next) {
-  if (config.fullyQualifiedName === '') return next();
-  debug('Deleting exchange: %s', config.fullyQualifiedName);
+  if (config.fullyQualifiedName === "") return next();
+  debug("Deleting exchange: %s", config.fullyQualifiedName);
   channel.deleteExchange(config.fullyQualifiedName, {}, next);
 }

package/lib/amqp/tasks/deleteQueues.js

@@ -1,16 +1,20 @@
-const debug = require('debug')('rascal:tasks:deleteQueues');
-const _ = require('lodash');
-const async = require('async');
+const debug = require("debug")("rascal:tasks:deleteQueues");
+const _ = require("lodash");
+const async = require("async");
 
 module.exports = _.curry((config, ctx, next) => {
-  async.eachSeries(_.keys(config.queues), (name, callback) => {
-    deleteQueue(ctx.channel, config.queues[name], callback);
-  }, (err) => {
-    next(err, config, ctx);
-  });
+  async.eachSeries(
+    _.keys(config.queues),
+    (name, callback) => {
+      deleteQueue(ctx.channel, config.queues[name], callback);
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });
 
 function deleteQueue(channel, config, next) {
-  debug('Deleting queue: %s', config.fullyQualifiedName);
+  debug("Deleting queue: %s", config.fullyQualifiedName);
   channel.deleteQueue(config.fullyQualifiedName, {}, next);
 }

package/lib/amqp/tasks/deleteVhost.js

@@ -1,7 +1,7 @@
-const debug = require('debug')('rascal:tasks:deleteVhost');
-const _ = require('lodash');
-const async = require('async');
-const client = require('../../management/client');
+const debug = require("debug")("rascal:tasks:deleteVhost");
+const _ = require("lodash");
+const async = require("async");
+const client = require("../../management/client");
 
 module.exports = _.curry((config, ctx, next) => {
   const vhostConfig = config.vhosts[ctx.vhost.name];
@@ -9,17 +9,26 @@ module.exports = _.curry((config, ctx, next) => {
 
   const candidates = vhostConfig.connections;
 
-  async.retry(candidates.length, (cb) => {
-    const connectionConfig = candidates[ctx.vhost.connectionIndex];
-    client.deleteVhost(vhostConfig.name, connectionConfig.management, (err) => {
-      if (err) {
-        ctx.vhost.connectionIndex = (ctx.vhost.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.vhost.connectionIndex];
+      client.deleteVhost(
+        vhostConfig.name,
+        connectionConfig.management,
+        (err) => {
+          if (err) {
+            ctx.vhost.connectionIndex =
+              (ctx.vhost.connectionIndex + 1) % candidates.length;
+            return cb(err);
+          }
+          ctx.connectionConfig = connectionConfig;
+          cb();
+        }
+      );
+    },
+    (err) => {
+      next(err, config, ctx);
+    }
+  );
 });

package/lib/amqp/tasks/forewarnVhost.js

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