@sera4/essentia 1.0.19 → 1.0.21

package/index.js

@@ -7,6 +7,7 @@ module.exports = {
   lastCommit : require("./last_commit"),
   halDecorator : require("./hal"),
   formatter : require("./formatter"),
-  healthCheck: require("./health")
+  healthCheck : require("./health"),
+  queue : require("./queue")
 }
 //console.log(module.exports.formatter.formatError({ status: 200, error: ["error1"] }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sera4/essentia",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "A library of utilities for Teleporte Web Services",
   "main": "index.js",
   "scripts": {
@@ -25,6 +25,7 @@
     "sinon": "^5.0.1"
   },
   "dependencies": {
+    "amqplib": "^0.5.5",
     "async": "^2.6.1",
     "fast-safe-stringify": "^2.0.6",
     "git-rev": "^0.2.1",

package/queue/index.js

@@ -0,0 +1,196 @@
+"use strict";
+const amqp = require("amqplib/callback_api");
+const logger = require("./queue-logger");
+const { Publisher } = require("./publisher");
+const { Subscriber } = require("./subscriber");
+
+/**
+ * An interface to AMQP service
+ */
+class S4Queue {
+  constructor() {
+    this.connection = null;
+    this.retry = 10;
+    this.pubs = {};
+    this.subs = {};
+  }
+
+  /**
+   * Opens a connection to AMQP server.
+   * @param {Object} options Connection parameters. At the very least options.connectionUrl must be present.
+   */
+  async openConnection(options) {
+    logger.setEnabled(options.logEnabled);
+
+    if (this.connection) {
+      logger.warn("Already initialized");
+      return;
+    }
+
+    const retry = parseInt(options.retryInterval);
+    this.retry = retry || 10;
+
+    logger.debug("Attempting connection...");
+
+    // The docs say there is amqp.connect returning
+    // a promise, but this version doesn't seem to like
+    // when a callback isn't provided, therefore run
+    // in a new Promise
+    return new Promise((resolve, reject) => {
+      amqp.connect(options.connectionUrl, (err, conn) => {
+
+        if (err) {
+          return reject(err);
+        }
+
+        this.connection = conn;
+        if (!this.connection) {
+          return reject(new Error("Failed to obtain connection"));
+        }
+
+        this.connection.on("error", (err) => {
+          logger.error("connection error", err);
+          // Do not attempt to reconnect as the
+          // 'close' event will also be emitted
+          // if this error closes the connection
+        });
+
+        this.connection.on("close", (err) => {
+          logger.error("connection closed");
+          this.connection = null;
+          if (err) {
+            logger.debug("connection closed due to error:", err);
+            logger.debug("Reconnecting in", this.retry, "seconds");
+            setTimeout(() => this.openConnection(options), this.retry * 1000);
+          } else {
+            // If there was no error, it is us who closed
+            // this connection, thus a reconnection will not
+            // be attempted.
+            logger.debug("Will not re-attempt");
+          }
+        });
+
+        logger.debug("Connected");
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Closes the connection to AMQP server
+   * and clears the registered publishers
+   * and subscribers
+   */
+  async closeConnection() {
+    return new Promise((resolve, reject) => {
+      if (!this.connection) {
+        return resolve();
+      }
+      this.connection.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.subs = {};
+          this.pubs = {};
+          this.connection = null;
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Returns whether we have an active connection
+   * or not.
+   */
+  isConnected() {
+    return this.connection != null && typeof(this.connection) != 'undefined';
+  }
+
+  /**
+   * Registers a new direct publisher on the given exchange.
+   * If exchange doesn't exist, one will be created.
+   * @param {String} exchange the name of the exchange on AMQP service.
+   */
+  async registerDirectPublisher(exchange) {
+    const name = exchange;
+    if (Object.keys(this.pubs).includes(name)) {
+      throw new Error(`Publisher ${name} already registered`);
+    }
+
+    const p = new Publisher(exchange, 'direct', true, name);
+    await p.init(this.connection);
+    this.pubs[name] = p;
+  }
+
+  /**
+   * Registers a new direct subscriber on a given exchange and queue.
+   * If exchange and queue don't exists, they'll be created
+   * and bound through the provided routing key.
+   * @param {String} exchange the name of the exchange.
+   * @param {String} queue the name of the queue.
+   * @param {String} key the name of the routing key.
+   */
+  async registerDirectSubscriber(exchange, queue, key) {
+    const name = `${exchange}-${queue}-${key}`;
+    if (Object.keys(this.subs).includes(name)) {
+      throw new Error(`Subscriber ${name} already registered`);
+    }
+
+    const s = new Subscriber(exchange, queue, 'direct', true, key, name);
+    await s.init(this.connection);
+    this.subs[name] = s;
+  }
+
+  /**
+   * Publishes a message on a given exchange with routing key.
+   * @param {String} exchange the name of the exchange.
+   * @param {String} key the name of the routing key.
+   * @param {Object} msg a JSON object as the message.
+   */
+  publishDirectMessage(exchange, key, msg) {
+    const p = this.pubs[exchange];
+
+    if (!key) {
+      throw(new Error(`Direct message require a key`));
+    }
+
+    if (!p) {
+      throw(new Error(`No PUB for ${exchange} found`));
+    }
+
+    if (p.type !== 'direct') {
+      throw(new Error(`PUB ${exchange} is not direct`));
+    }
+
+    let content = msg;
+    if (content.constructor !== ({}).constructor) {
+      // if not in JSON format, let's make it so
+      content = {
+        msg: msg
+      }
+    }
+
+    p.publish({key, content});
+
+  }
+
+  /**
+   * Adds a listener for a specific key.
+   * If a subscriber that was regitered was found
+   * with that key, the listener is added, otherwise
+   * it's ignored
+   * @param {*} key AMQP routing key
+   * @param {*} listener callback
+   */
+  addMessageListener(key, listener) {
+    Object.keys(this.subs).forEach(k => {
+      const s = this.subs[k];
+      if (s.key === key) {
+        s.registerCallback(listener);
+      }
+    });
+  }
+}
+
+module.exports = new S4Queue();

package/queue/publisher.js

@@ -0,0 +1,77 @@
+const logger = require("./queue-logger");
+
+/**
+ * A publisher for AMQP service
+ */
+class Publisher {
+
+  /**
+   * 
+   * @param {String} exchange AMQP exchange name.
+   * @param {String} type direct|fanout| etc (supported types by RabbitMQ).
+   * @param {boolean} durable true if the messages should persist service restarts.
+   * @param {String} name a name to identify this publisher in the logs.
+   */
+  constructor(exchange, type, durable, name) {
+    this.exchange = exchange;
+    this.type = type;
+    this.durable = durable;
+    this.name = name;
+    this.channel = null;
+  }
+
+  /**
+   * Initializes this publisher with a connection
+   * and asserts the exchange exists
+   * @param {Object} conn amqp connection object
+   */
+  async init (conn) {
+    logger.debug(`Initializing PUB channel for ${this.name}`);
+    
+    if(this.channel) {
+      logger.warn(`PUB channel for ${this.name} already initialized`);
+      return;
+    }
+
+    this.channel = await conn.createConfirmChannel();
+    if (!this.channel) {
+      throw(new Error(`Cannot create PUB channel for ${this.name}`));
+    }
+
+    logger.debug(`Initialized PUB channel for ${this.name}`);
+    await this.channel.assertExchange(this.exchange, this.type, {durable: this.durable});
+
+    this.channel.on("error", (err) => {
+      logger.debug(`Connection error for ${this.name}`, err);
+      this.channel = null;
+    });
+
+    this.channel.on("close", () => {
+      logger.debug(`Connection closed for ${this.name}`);
+      this.channel = null;
+    });
+  }
+
+  /**
+   * Publishes a message to AMQP
+   * @param {Objecgt} msg A json object to be published to AMQP
+   */
+  publish(msg) {
+    if (!this.channel) {
+      throw(new Error(`No channel for ${this.name} to publish`));
+    }
+    logger.debug("Publishing message", msg);
+    const content = Buffer.from(JSON.stringify(msg.content));
+    this.channel.publish(this.exchange, msg.key, content, {persistent: true}, (err, ok) => {
+      if (err) {
+        logger.error(`An error occured publishing message to ${this.name}`);
+      } else {
+        logger.debug("Message delivered:", msg);
+      }
+    });
+  }
+}
+
+module.exports = {
+  Publisher
+}

package/queue/queue-logger.js

@@ -0,0 +1,38 @@
+const logger = require("../logger/s4-logger");
+let enabled = false;
+
+module.exports = {
+  debug(...args) {
+    if (enabled) {
+      logger.debug(":: AMQP ::", args);
+    }
+  },
+
+  log(...args) {
+    if (enabled) {
+      logger.debug(":: AMQP ::", args);
+    }
+  },
+
+  warn(...args) {
+    if (enabled) {
+      logger.warn(":: AMQP ::", args);
+    }
+  },
+
+  info(...args) {
+    if (enabled) {
+      logger.info(":: AMQP ::", args);
+    }
+  },
+
+  error(...args) {
+    if (enabled) {
+      logger.error(":: AMQP ::", args);
+    }
+  },
+
+  setEnabled(e) {
+    enabled = e;
+  }
+}

package/queue/subscriber.js

@@ -0,0 +1,88 @@
+const logger = require("./queue-logger");
+
+/**
+ * A subscriber for AMQP service
+ */
+class Subscriber {
+
+  /**
+   * Builds a subscriber
+   * @param {String} exchange name of the AMQP exchange.
+   * @param {String} queue name of the AMQP service.
+   * @param {String} type direct|fanout or other supported connection types.
+   * @param {boolean} durable durable connection or not.
+   * @param {String} key routing key. This will be used to bind the queue to the exchange.
+   * @param {String} name a usefull name to be printed in the logs.
+   */
+  constructor(exchange, queue, type, durable, key, name) {
+    this.exchange = exchange;
+    this.queue = queue;
+    this.type = type;
+    this.durable = durable;
+    this.key = key;
+    this.name = name;
+    this.channel = null;
+    this.callbacks = [];
+  }
+
+  /**
+   * Initializes the subscriber on the given connection.
+   * During this call, the exchange and the queues are asserted
+   * and bound via the key provided in the constructor.
+   * @param {Objecgt} conn aqmp connection object
+   */
+  async init (conn) {
+    logger.debug(`Initializing SUB channel for ${this.name}`);
+    
+    if(this.channel) {
+      logger.warn(`SUB channel for ${this.name} already initialized`);
+      return;
+    }
+
+    this.channel = await conn.createChannel();
+    if (!this.channel) {
+      throw(new Error(`Cannot create SUB channel for ${this.name}`));
+    }
+
+    this.channel.on("error", (err) => {
+      logger.debug(`Connection error for ${this.name}`, err);
+      this.channel = null;
+    });
+
+    this.channel.on("close", () => {
+      logger.debug(`Connection closed for ${this.name}`);
+      this.channel = null;
+    });
+
+    logger.debug(`Initialized SUB channel for ${this.name}`);
+    await this.channel.assertExchange(this.exchange, this.type, {durable: this.durable});
+    await this.channel.assertQueue(this.queue, { durable: this.durable });
+    
+    logger.debug(`Binding queue ${this.queue} on ${this.exchange} exchange for ${this.key} key`);
+    await this.channel.bindQueue(this.queue, this.exchange, this.key);
+    
+    this.channel.consume(this.queue, (msg) => {
+      const { fields, content } = msg;
+      const payload = JSON.parse(content.toString());
+      logger.debug(`Got message from exchange '${fields.exchange}' with key '${fields.routingKey}'`);
+      logger.debug("Content", payload);
+      this.callbacks.forEach(cb => {
+        cb(payload);
+      });
+      this.channel.ack(msg);
+    }, { noAck: false });
+  }
+
+  /**
+   * Register a new callback to recive message through this
+   * subscriber object
+   * @param {function} cb A callback to be called when a message arrives
+   */
+  registerCallback(cb) {
+    this.callbacks.push(cb);
+  }
+}
+
+module.exports = {
+  Subscriber
+}