rascal 13.1.3 → 14.2.0

package/lib/amqp/Publication.js

@@ -1,10 +1,10 @@
-const debug = require("debug")("rascal:Publication");
-const format = require("util").format;
-const _ = require("lodash");
-const uuid = require("uuid").v4;
-const crypto = require("crypto");
-const PublicationSession = require("./PublicationSession");
-const setTimeoutUnref = require("../utils/setTimeoutUnref");
+const debug = require('debug')('rascal:Publication');
+const format = require('util').format;
+const _ = require('lodash');
+const uuid = require('uuid').v4;
+const crypto = require('crypto');
+const PublicationSession = require('./PublicationSession');
+const setTimeoutUnref = require('../utils/setTimeoutUnref');
 
 module.exports = {
   create(vhost, config, next) {
@@ -15,75 +15,30 @@ module.exports = {
     const returnChannel = vhost.returnChannel.bind(vhost);
     const destroyChannel = vhost.destroyChannel.bind(vhost);
 
-    if (
-      Object.prototype.hasOwnProperty.call(config, "exchange") &&
-      config.confirm
-    )
-      return new Publication(
-        vhost,
-        borrowConfirmChannel,
-        returnConfirmChannel,
-        destroyConfirmChannel,
-        publishToConfirmExchange,
-        config
-      ).init(next);
-    if (Object.prototype.hasOwnProperty.call(config, "exchange"))
-      return new Publication(
-        vhost,
-        borrowChannel,
-        returnChannel,
-        destroyChannel,
-        publishToExchange,
-        config
-      ).init(next);
-    if (config.queue && config.confirm)
-      return new Publication(
-        vhost,
-        borrowConfirmChannel,
-        returnConfirmChannel,
-        destroyConfirmChannel,
-        sendToConfirmQueue,
-        config
-      ).init(next);
-    if (config.queue)
-      return new Publication(
-        vhost,
-        borrowChannel,
-        returnChannel,
-        destroyChannel,
-        sendToQueue,
-        config
-      ).init(next);
+    if (Object.prototype.hasOwnProperty.call(config, 'exchange') && config.confirm) return new Publication(vhost, borrowConfirmChannel, returnConfirmChannel, destroyConfirmChannel, publishToConfirmExchange, config).init(next);
+    if (Object.prototype.hasOwnProperty.call(config, 'exchange')) return new Publication(vhost, borrowChannel, returnChannel, destroyChannel, publishToExchange, config).init(next);
+    if (config.queue && config.confirm) return new Publication(vhost, borrowConfirmChannel, returnConfirmChannel, destroyConfirmChannel, sendToConfirmQueue, config).init(next);
+    if (config.queue) return new Publication(vhost, borrowChannel, returnChannel, destroyChannel, sendToQueue, config).init(next);
   },
 };
 
-function Publication(
-  vhost,
-  borrowChannelFn,
-  returnChannelFn,
-  destroyChannelFn,
-  publishFn,
-  config
-) {
+function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn, publishFn, config) {
   const self = this;
 
   this.name = config.name;
 
   this.init = function (next) {
-    debug("Initialising publication: %s", config.name);
+    debug('Initialising publication: %s', config.name);
     next(null, self);
   };
 
   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.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) {
@@ -92,71 +47,28 @@ function Publication(
       routingKey: message.fields.routingKey,
     });
 
-    publishConfig.options = _.defaultsDeep(
-      publishConfig.options,
-      message.properties
-    );
-
-    _.set(
-      publishConfig,
-      "options.headers.rascal.restoreRoutingHeaders",
-      !!publishConfig.restoreRoutingHeaders
-    );
-    _.set(
-      publishConfig,
-      "options.headers.rascal.originalExchange",
-      message.fields.exchange
-    );
-    _.set(
-      publishConfig,
-      "options.headers.rascal.originalRoutingKey",
-      message.fields.routingKey
-    );
-    _.set(
-      publishConfig,
-      "options.CC",
-      _.chain([])
-        .concat(
-          publishConfig.options.CC,
-          format("%s.%s", originalQueue, publishConfig.routingKey)
-        )
-        .uniq()
-        .compact()
-        .value()
-    );
+    publishConfig.options = _.defaultsDeep(publishConfig.options, message.properties);
+
+    _.set(publishConfig, 'options.headers.rascal.restoreRoutingHeaders', !!publishConfig.restoreRoutingHeaders);
+    _.set(publishConfig, 'options.headers.rascal.originalExchange', message.fields.exchange);
+    _.set(publishConfig, 'options.headers.rascal.originalRoutingKey', message.fields.routingKey);
+    _.set(publishConfig, 'options.CC', _.chain([]).concat(publishConfig.options.CC, format('%s.%s', originalQueue, publishConfig.routingKey)).uniq().compact().value());
 
     _publish(message.content, publishConfig, next);
   };
 
   function _publishEncrypted(buffer, publishConfig, next) {
     const encryptionConfig = publishConfig.encryption;
-    encrypt(
-      encryptionConfig.algorithm,
-      encryptionConfig.key,
-      encryptionConfig.ivLength,
-      buffer,
-      (err, iv, encrypted) => {
-        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.originalContentType",
-          publishConfig.options.contentType
-        );
-        _.set(publishConfig, "options.contentType", "application/octet-stream");
-
-        _publish(encrypted, publishConfig, next);
-      }
-    );
+    encrypt(encryptionConfig.algorithm, encryptionConfig.key, encryptionConfig.ivLength, buffer, (err, iv, encrypted) => {
+      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.originalContentType', publishConfig.options.contentType);
+      _.set(publishConfig, 'options.contentType', 'application/octet-stream');
+
+      _publish(encrypted, publishConfig, next);
+    });
   }
 
   function encrypt(algorithm, keyHex, ivLength, unencrypted, next) {
@@ -164,13 +76,13 @@ function Publication(
       if (err) return next(err);
       let encrypted;
       try {
-        const key = Buffer.from(keyHex, "hex");
+        const key = Buffer.from(keyHex, 'hex');
         const cipher = crypto.createCipheriv(algorithm, key, iv);
         encrypted = Buffer.concat([cipher.update(unencrypted), cipher.final()]);
       } catch (err) {
         return next(err);
       }
-      next(null, iv.toString("hex"), encrypted);
+      next(null, iv.toString('hex'), encrypted);
     });
   }
 
@@ -179,12 +91,10 @@ function Publication(
     const session = new PublicationSession(vhost, messageId);
     borrowChannelFn((err, channel) => {
       session._removePausedListener();
-      if (err) return session.emit("error", err, messageId);
+      if (err) return session.emit('error', err, messageId);
       if (session.isAborted()) return abortPublish(channel, messageId);
-      const errorHandler = _.once(
-        handleChannelError.bind(null, channel, messageId, session, config)
-      );
-      const returnHandler = session.emit.bind(session, "return");
+      const errorHandler = _.once(handleChannelError.bind(null, channel, messageId, session, config));
+      const returnHandler = session.emit.bind(session, 'return');
       addListeners(channel, errorHandler, returnHandler);
       try {
         session._startPublish();
@@ -192,18 +102,16 @@ function Publication(
           session._endPublish();
           if (err) {
             destroyChannel(channel, errorHandler, returnHandler);
-            return session.emit("error", err, messageId);
+            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);
+          session.emit('success', messageId);
         });
       } catch (err) {
         returnChannel(channel, errorHandler, returnHandler);
-        return session.emit("error", err, messageId);
+        return session.emit('error', err, messageId);
       }
     });
 
@@ -211,7 +119,7 @@ function Publication(
   }
 
   function abortPublish(channel, messageId) {
-    debug("Publication of message: %s was aborted", messageId);
+    debug('Publication of message: %s was aborted', messageId);
     returnChannelFn(channel);
   }
 
@@ -221,7 +129,7 @@ function Publication(
   }
 
   function deferReturnChannel(channel, errorHandler, returnHandler) {
-    channel.once("drain", () => {
+    channel.once('drain', () => {
       returnChannel(channel, errorHandler, returnHandler);
     });
   }
@@ -242,122 +150,74 @@ function Publication(
   }
 
   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",
+      type: 'application/json',
     };
   }
 }
 
 function addListeners(channel, errorHandler, returnHandler) {
-  channel.on("error", errorHandler);
-  channel.on("return", returnHandler);
-  channel.connection.once("error", errorHandler);
-  channel.connection.once("close", errorHandler);
+  channel.on('error', errorHandler);
+  channel.on('return', returnHandler);
+  channel.connection.once('error', errorHandler);
+  channel.connection.once('close', errorHandler);
 }
 
 function removeListeners(channel, errorHandler, returnHandler) {
-  channel.removeListener("error", errorHandler);
-  channel.removeListener("return", returnHandler);
-  channel.connection.removeListener("error", errorHandler);
-  channel.connection.removeListener("close", errorHandler);
+  channel.removeListener('error', errorHandler);
+  channel.removeListener('return', returnHandler);
+  channel.connection.removeListener('error', errorHandler);
+  channel.connection.removeListener('close', errorHandler);
 }
 
 function publishToExchange(channel, content, config, next) {
-  debug(
-    "Publishing %d bytes to exchange: %s with routingKeys: %s",
-    content.length,
-    config.exchange,
-    _.compact(
-      [].concat(config.routingKey, config.options.CC, config.options.BCC)
-    ).join(", ")
-  );
-  const ok = channel.publish(
-    config.destination,
-    config.routingKey,
-    content,
-    config.options
-  );
+  debug('Publishing %d bytes to exchange: %s with routingKeys: %s', content.length, config.exchange, _.compact([].concat(config.routingKey, config.options.CC, config.options.BCC)).join(', '));
+  const ok = channel.publish(config.destination, config.routingKey, content, config.options);
   next(null, ok);
 }
 
 function publishToConfirmExchange(channel, content, config, next) {
-  debug(
-    "Publishing %d bytes to confirm exchange: %s with routingKeys: %s",
-    content.length,
-    config.exchange,
-    _.compact(
-      [].concat(config.routingKey, config.options.CC, config.options.BCC)
-    ).join(", ")
-  );
+  debug('Publishing %d bytes to confirm exchange: %s with routingKeys: %s', content.length, config.exchange, _.compact([].concat(config.routingKey, config.options.CC, config.options.BCC)).join(', '));
 
   const once = _.once(next);
-  const timeout = config.timeout
-    ? setConfirmationTimeout(config.timeout, config.destination, once)
-    : null;
-
-  const ok = channel.publish(
-    config.destination,
-    config.routingKey,
-    content,
-    config.options,
-    (err) => {
-      clearTimeout(timeout);
-      once(err, ok);
-    }
-  );
+  const timeout = config.timeout ? setConfirmationTimeout(config.timeout, config.destination, once) : null;
+
+  const ok = channel.publish(config.destination, config.routingKey, content, config.options, (err) => {
+    clearTimeout(timeout);
+    once(err, ok);
+  });
 }
 
 function sendToQueue(channel, content, config, next) {
-  debug("Publishing %d bytes to queue: %s", content.length, config.queue);
+  debug('Publishing %d bytes to queue: %s', content.length, config.queue);
   const ok = channel.sendToQueue(config.destination, content, config.options);
   next(null, ok);
 }
 
 function sendToConfirmQueue(channel, content, config, next) {
-  debug("Publishing %d bytes to queue: %s", content.length, config.queue);
+  debug('Publishing %d bytes to queue: %s', content.length, config.queue);
 
   const once = _.once(next);
-  const timeout = config.timeout
-    ? setConfirmationTimeout(config.timeout, config.destination, once)
-    : null;
-
-  const ok = channel.sendToQueue(
-    config.destination,
-    content,
-    config.options,
-    (err) => {
-      clearTimeout(timeout);
-      next(err, ok);
-    }
-  );
+  const timeout = config.timeout ? setConfirmationTimeout(config.timeout, config.destination, once) : null;
+
+  const ok = channel.sendToQueue(config.destination, content, config.options, (err) => {
+    clearTimeout(timeout);
+    next(err, ok);
+  });
 }
 
 function setConfirmationTimeout(timeout, destination, next) {
   return setTimeoutUnref(() => {
-    next(
-      new Error(
-        format(
-          "Timedout after %dms waiting for broker to confirm publication to: %s",
-          timeout,
-          destination
-        )
-      )
-    );
+    next(new Error(format('Timedout after %dms waiting for broker to confirm publication to: %s', timeout, destination)));
   }, timeout);
 }
 
 function handleChannelError(borked, messageId, emitter, config, err) {
-  debug(
-    "Channel error: %s during publication of message: %s to %s using channel: %s",
-    err.message,
-    messageId,
-    config.name,
-    borked._rascal_id
-  );
-  emitter.emit("error", err, messageId);
+  debug('Channel error: %s during publication of message: %s to %s using channel: %s', err.message, messageId, config.name, borked._rascal_id);
+  emitter.emit('error', err, messageId);
 }

package/lib/amqp/PublicationSession.js

@@ -1,6 +1,6 @@
-const debug = require("debug")("rascal:SubscriberSession");
-const EventEmitter = require("events").EventEmitter;
-const inherits = require("util").inherits;
+const debug = require('debug')('rascal:SubscriberSession');
+const EventEmitter = require('events').EventEmitter;
+const inherits = require('util').inherits;
 
 module.exports = PublicationSession;
 
@@ -21,7 +21,7 @@ function PublicationSession(vhost, messageId) {
   };
 
   this._removePausedListener = function () {
-    vhost.removeListener("paused", emitPaused);
+    vhost.removeListener('paused', emitPaused);
   };
 
   this._startPublish = function () {
@@ -33,13 +33,13 @@ function PublicationSession(vhost, messageId) {
   };
 
   function emitPaused() {
-    self.emit("paused", messageId);
+    self.emit('paused', messageId);
   }
 
-  vhost.on("paused", emitPaused);
+  vhost.on('paused', emitPaused);
 
-  self.on("newListener", (event) => {
-    if (event !== "paused") return;
+  self.on('newListener', (event) => {
+    if (event !== 'paused') return;
     if (vhost.isPaused()) emitPaused();
   });
 }