@sera4/essentia 1.1.65 → 3.0.6

package/prompts/index.js

@@ -1,78 +0,0 @@
-/* Essentia Common Prompt Functions */
-// This file contains common prompt functions that are used in CLI scripts
-//  that are run in the each project.  These functions are used to
-//  prompt the user for input and to wait for the user to press enter
-//  before continuing.  This is useful for scripts that are run in the
-//  command line and need to wait for the user to do something before
-//  continuing.
-
-import logger from "../logger/s4-logger.js";
-import { ArgumentParser } from 'argparse'
-import prompt from "prompt";
-
-// New common argument parser which makes parsing and setting up commandline options easier
-const setupCLIParser = (description) => {
-  logger.info(description)
-  return new ArgumentParser({ description });
-}
-
-// a common init function which waits for the command prompt to be delivered
-// a common use is for the awaiting of the queues to initialize before running
-const commonCLIInit = async(options) => {
-  //add in defaults to options if they have not been specified or object is {}
-  options = { asyncFcns: [], extraFcns: [], sleepTime: 1000, ...options };
-
-  // Sleep for 1 second to allow the prompt to be displayed
-  // at the end of bootstrap logs
-  await cliSleep(options.sleepTime);
-
-  options.extraFcns.forEach(fcn => {
-    fcn();
-  });
-
-  for (const fcn of options.asyncFcns) {
-    await fcn();
-  }
-}
-
-const promptCLIAsync = async (options) => {
-  return new Promise((resolve, reject) => {
-    prompt.start();
-    prompt.get(options, (err, res) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(res);
-      }
-    })
-  });
-}
-
-// A predefined waitPrompt for use at the end of the scripts that use
-//  message queues.  Message Queues often take a bit to fire
-const waitCLIPrompt = {
-  "Push <enter> when done" : {
-    type: "boolean"
-  }
-};
-
-const continueCLIPrompt = {
-  "Push <enter> to continue" : {
-    type: "boolean"
-  }
-};
-
-const cliSleep = async(ms) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-export {
-  commonCLIInit,
-  continueCLIPrompt,
-  promptCLIAsync,
-  setupCLIParser,
-  cliSleep,
-  waitCLIPrompt
-};

package/queue/index.js

@@ -1,414 +0,0 @@
-"use strict";
-import amqp from "amqplib/callback_api.js";
-import logger from "./queue-logger.js";
-import urlParse from "url-parse";
-import { Publisher } from "./publisher.js";
-import { Subscriber } from "./subscriber.js";
-
-/**
- * An interface to AMQP service
- */
-class S4Queue {
-  constructor() {
-    this.connection = null;
-    this.retry = 10;
-    this.pubs = {};
-    this.subs = {};
-  }
-
-  /**
-   * Tests the connection to the service.
-   * Internally, the same connection is used for test
-   * and production code, but a separate channel is opened.
-   * Once the channel is obtained, there is an assert on the
-   * existence of a topic exchange called '--health-check--'.
-   * The following must be satisfied for the test to pass
-   * 1. must be connected
-   * 2. must have a test channel
-   * 3. must assert the exchange
-   */
-  async testConnection() {
-    if (!this.isConnected()) {
-      this.connectionTestChannel = null;
-      throw("queue service not connected")
-    }
-
-    this.connectionTestChannel = this.connectionTestChannel || await this.connection.createChannel();
-    if (!this.connectionTestChannel) {
-      throw("queue service failed to obtain a channel")
-    }
-
-    await this.connectionTestChannel.assertExchange("--health-check--", "topic", {durable: false});
-  }
-
-  /**
-   * 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) => {
-      // We may run into issues with SNI TLS if
-      // we host with 3rd parties using our own certs.
-      // To avoid any issues, let's parse the url
-      // and provide the server name in the socket options
-      const urlParts = urlParse(options.connectionUrl);
-      const socketOptions = {servername: urlParts.hostname};
-
-      amqp.connect(options.connectionUrl, socketOptions, (err, conn) => {
-
-        if (err) {
-          logger.error("Error while connecting", err)
-          logger.error("Attempting again in", this.retry, "seconds");
-          return setTimeout(() => this.openConnection(options), this.retry * 1000);
-        }
-
-        this.connection = conn;
-        if (!this.connection) {
-          return reject(new Error("Failed to obtain connection"));
-        } else {
-          this.updatePubsAndSubsConnectionRef(conn);
-        }
-
-        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.error("connection closed due to error:", err);
-            logger.error("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';
-  }
-
-  /**
-   * @deprecated Use registerPublisher
-   * 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) {
-    return this.registerPublisher({exchange: {name: exchange, type: "direct"}});
-  }
-
-  /**
-   * @deprecated Use registerPublisher
-   * Registers a new topic 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 registerTopicPublisher(exchange) {
-    return this.registerPublisher({exchange: {name: exchange, type: "topic"}});
-  }
-
-  /**
-   * @deprecated Use registerPublisher
-   * Registers a new fanout 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 registerFanoutPublisher(exchange) {
-    return this.registerPublisher({exchange: {name: exchange, type: "fanout"}});
-  }
-
-    /**
-   * Registers a new publisher
-   * @param {Object} options connection options.
-   */
-  async registerPublisher(options) {
-    const { exchange } = options;
-    const { name } = exchange;
-    if (Object.keys(this.pubs).includes(name)) {
-      throw new Error(`Publisher ${name} already registered`);
-    }
-
-    const p = new Publisher(exchange, name);
-    await p.init(this.connection);
-    this.pubs[name] = p;
-  }
-
-  /**
-   * Checks whether or not a publisher with given parameters
-   * has been registered already
-   * @param {String} exchange the name of the exchange.
-   * @returns true if registered already, false otherwise
-   */
-  hasPublisher(exchange) {
-    return Object.keys(this.pubs).includes(exchange);
-  }
-
-  /**
-   * Removes a previously registered publisher
-   * @param {Object} options
-   */
-  async unregisterPublisher(options) {
-    const { exchange } = options;
-    const { name } = exchange;
-    if (!Object.keys(this.pubs).includes(name)) {
-      throw new Error(`Publisher ${name} not registered`);
-    }
-    const p = this.pubs[name];
-    await p.closeChannel();
-
-    delete this.pubs[name];
-    logger.debug("Unregistered publisher", name);
-  }
-
-  /**
-   * @deprecated Use registerSubscriber
-   * 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 options = {
-      key,
-      exchange: { name: exchange, type: "direct" },
-      queue: { name: queue }
-    }
-    return this.registerSubscriber(options);
-  }
-
-  /**
-   * @deprecated Use registerSubscriber
-   * Registers a new topic 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 registerTopicSubscriber(exchange, queue, key) {
-    const options = {
-      key,
-      exchange: { name: exchange, type: "topic" },
-      queue: { name: queue }
-    }
-    return this.registerSubscriber(options);
-  }
-
-  /**
-   * An overloaded version of registering a subscriber
-   * allowing for more fine tuned parameters
-   * @param {Object} options subscribing options
-   */
-  async registerSubscriber(options) {
-    const {exchange, queue, key} = options;
-    const name = `${exchange.name}-${queue.name}-${key}`;
-
-    if (Object.keys(this.subs).includes(name)) {
-      throw new Error(`Subscriber ${name} already registered`);
-    }
-
-    const s = new Subscriber(exchange, queue, key, name);
-    await s.init(this.connection);
-    this.subs[name] = s;
-  }
-
-  /**
-   * Checks whether or not a subscriber with given parameters
-   * has been registered already
-   * @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.
-   * @returns true if registered already, false otherwise
-   */
-  hasSubscriber(exchange, queue, key) {
-    const name = `${exchange}-${queue}-${key}`;
-    return Object.keys(this.subs).includes(name);
-  }
-
-  /**
-   * Removes a previously registered subscriber
-   * @param {OBject} options
-   */
-   async unregisterSubscriber(options) {
-    const {exchange, queue, key} = options;
-    const name = `${exchange.name}-${queue.name}-${key}`;
-
-    if (!Object.keys(this.subs).includes(name)) {
-      throw new Error(`Subscriber ${name} not registered`);
-    }
-    const s = this.subs[name];
-    await s.closeChannel();
-
-    delete this.subs[name];
-    logger.debug("Unregistered subscriber", name);
-  }
-
-  /**
-   * 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.
-   */
-  async publishDirectMessage(exchange, key, msg) {
-    return this.publishMessage(exchange, key, msg)
-  }
-
-  /**
-   * Publishes a message on a given exchange with a topic.
-   * @param {String} exchange the name of the exchange.
-   * @param {String} topic the name of the topic.
-   * @param {Object} msg a JSON object as the message.
-   */
-  async publishTopicMessage(exchange, topic, msg) {
-    return this.publishMessage(exchange, topic, msg)
-  }
-
-  /**
-   * Publish a message to the exchange
-   * @param {String} exchange name of exchange
-   * @param {String} key name of the key or topic
-   * @param {Object} msg payload to be published
-   */
-  async publishMessage(exchange, key, msg) {
-    if (!key) {
-      throw(new Error(`Key argument not defined`));
-    }
-
-    const p = this.pubs[exchange];
-    if (!p) {
-      throw(new Error(`No PUB for ${exchange} found`));
-    }
-
-    let content = msg;
-    if (content.constructor !== ({}).constructor) {
-      // if not in JSON format, let's make it so
-      content = {
-        msg: msg
-      }
-    }
-
-    return await p.publish({key, content});
-  }
-
-  /**
-   * Binds an exchange to a queue
-   * @param {String} exchange the name of the exchange.
-   * @param {String} queue the name of the queue.
-   * @param {pattern} (optional) pattern for routing key
-  */
-  async bindQueueToExchange(exchange, queue, pattern) {
-    const p = this.pubs[exchange];
-
-    if (!p) {
-      throw(new Error(`No PUB for ${exchange} found`));
-    }
-
-    if (!queue) {
-      throw(new Error(`Binding a queue requires a queue name`));
-    }
-
-    return await p.bindQueue(queue, pattern)
-  }
-
-  /**
-   * 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);
-      }
-    });
-  }
-
-  /**
-   * Updates the connection reference to all the previously
-   * registered publishers and subscribers.
-   * After we successfully establish a connection and register pubs/subs,
-   * it's possible for the connection to break. This object will try
-   * to re-establish a new connection every 3 seconds (or whatever configuration is set)
-   * and if a new connection is established, we need to pass that connection to
-   * all our pubs/subs, otherwise they'll be operating with old/stale references
-   * @param {Object} connRef a new connection reference to the AMQP service
-   */
-  updatePubsAndSubsConnectionRef(connRef) {
-    Object.keys(this.pubs).forEach(k => {
-      logger.debug(`Updating publisher ${k} with a new connection object`);
-      const p = this.pubs[k];
-      p.init(connRef);
-    });
-    Object.keys(this.subs).forEach(k => {
-      logger.debug(`Updating subscriber ${k} with a new connection object`);
-      const s = this.subs[k];
-      s.init(connRef);
-    });
-  }
-}
-
-const queue = new S4Queue();
-export default queue;

package/queue/publisher.js

@@ -1,96 +0,0 @@
-import logger from "./queue-logger.js";
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * A publisher for AMQP service
- */
-export class Publisher {
-  /**
-   * @param {Object} exchange AMQP exchange name.
-   * @param {String} name a name to identify this publisher in the logs.
-   */
-  constructor(exchange, name) {
-    this.exchange = exchange;
-    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}`);
-    const {name, type, options} = this.exchange;
-    await this.channel.assertExchange(name, type, options);
-
-    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 {Object} msg A json object to be published to AMQP.
-   * A tracking uuid for the message will be returned.
-   */
-  async publish(msg) {
-    if (!this.channel) {
-      throw(new Error(`No channel for ${this.name} to publish`));
-    }
-
-    const parcel = {
-      tracking_id: uuidv4(),
-      timestamp: new Date(),
-      data: msg.content
-    }
-    logger.debug("Publishing message");
-    logger.debug("Key", msg.key);
-    logger.debug("Data", parcel);
-
-    const content = Buffer.from(JSON.stringify(parcel));
-    const res = await this.channel.publish(this.exchange.name, msg.key, content, {persistent: true});
-
-    if (!res) {
-      throw(new Error("Channel write buffer is full"));
-    }
-
-    return parcel.tracking_id;
-  }
-
-  /**
-   * Closes the channel
-   * @returns promise
-   */
-  async closeChannel() {
-    if (this.channel) {
-      logger.debug("Closing publishing channel", this.name);
-      return this.channel.close();
-    } else {
-      logger.error("Can't close a null publishing channel");
-    }
-  }
-
-  async bindQueue(queue, pattern, args) {
-    await this.channel.bindQueue(queue, this.exchange, pattern, args)
-  }
-}

package/queue/queue-logger.js

@@ -1,40 +0,0 @@
-import logger from "../logger/s4-logger.js";
-let enabled = false;
-
-const helpers = {
-  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;
-  }
-}
-
-export default helpers;