@sellout/service 0.0.1

package/src/BaseService.ts

@@ -0,0 +1,98 @@
+import { IConnectionManager, ILogManager, IServiceOpts } from "./interfaces";
+import * as Prometheus from 'prom-client';
+import * as express from 'express';
+import {
+  DISABLE_PROMETHEUS,
+  SENTRY_DSN,
+  NODE_ENV,
+  SEGMENT_IO_WRITE_KEY,
+} from "./env";
+import * as Sentry from "@sentry/node";
+import Segment from "./Segment";
+
+/**
+ * Provides the abstract class for all service implementations.
+ */
+class BaseService {
+  public opts: IServiceOpts;
+  public serviceName: string;
+  public connectionMgr: IConnectionManager;
+  public logger: ILogManager;
+  public storage;
+  public segment: Segment;
+  public collectDefaultMetrics;
+
+  constructor(opts: IServiceOpts) {
+    this.opts = opts;
+    this.connectionMgr = this.opts.connectionMgr;
+    this.logger = this.opts.logManager;
+    this.serviceName = this.opts.serviceName;
+    this.storage = this.opts.storageManager;
+    this.segment = new Segment(SEGMENT_IO_WRITE_KEY, this.logger);
+
+    /**
+     * Initialize Sentry
+     */
+    if (SENTRY_DSN) {
+      this.logger.info("Sentry - Initializing with environment ${NODE_ENV}...");
+      Sentry.init({
+        dsn: SENTRY_DSN,
+        environment: NODE_ENV,
+      });
+    } else {
+      this.logger.warn("Sentry - No DSN supplied, skipping initialization...");
+    }
+
+    // Enable/Disable Prometheus
+    if(!DISABLE_PROMETHEUS) {
+      // set up Prometheus client metrics gathering
+      const collectDefaultMetrics = Prometheus.collectDefaultMetrics;
+      // collectDefaultMetrics({ timeout: 5000 });
+      collectDefaultMetrics();
+
+      // initialize Express app
+      const app = express();
+      const metricsPort = 5499; // todo: parameterize this
+
+      // Metrics endpoint
+      app.get('/metrics', (req, res) => {
+        res.set('Content-Type', Prometheus.register.contentType)
+        res.end(Prometheus.register.metrics())
+      });
+
+      app.get('/readiness', (req, res) => {
+        if (this.isReady()) {
+          res.status(200).send('OK');
+        } else {
+          res.status(500).send('Not ready');
+        }
+      });
+
+      // as long as the event loop is running this should run
+      app.get('/liveness', (req, res) => {
+        res.status(200).send('OK');
+      });
+
+      // listen for metrics requests
+      app.listen(metricsPort, () => this.logger.info(`Service '${this.serviceName}' listening for metrics requests on port ${metricsPort}.`));
+    }
+  }
+
+  // override to have derived classes declare non-readiness to k8s
+  public isReady() : boolean {
+    return true;
+  }
+
+  /**
+   * Register message listeners here.
+   */
+  public register() {
+    throw new Error("Not Implemented: register method in Service class.");
+  }
+
+  public run() {
+    throw new Error("Not Implemented: run method in Service class.");
+  }
+}
+
+export default BaseService;

package/src/ConsoleLogManager.ts

@@ -0,0 +1,23 @@
+import { ILogManager, ILogManagerOpts } from "./interfaces";
+
+class ConsoleLogManager implements ILogManager {
+  public opts: ILogManagerOpts;
+
+  constructor(opts: ILogManagerOpts) {
+    this.opts = opts;
+  }
+
+  public info(msg: string, ...params: string[]): void {
+    console.info(msg, ...params);
+  }
+
+  public warn(msg: string, ...params: string[]): void {
+    console.warn(msg, ...params);
+  }
+
+  public error(msg: string, ...params: string[]): void {
+    console.error(msg, ...params);
+  }
+}
+
+export default ConsoleLogManager;

package/src/MongoConnectionManager.ts

@@ -0,0 +1,49 @@
+import wait from '@sellout/utils/.dist/wait';
+
+export default class MongoConnectionManager {
+  public connected: boolean;
+  public mongoConnectionString: string;
+  public isReplicaSet: boolean;
+  private mongoose: any;
+  private mongoConnectionStringInternal: string;
+
+  constructor(mongoose: any, mongoConnectionString: string, username: string = '', password: string = '') {
+    const parsed = new URL(mongoConnectionString);
+
+    parsed.username = username;
+    parsed.password = password;
+    parsed.pathname = '/admin';
+
+    this.connected = false;
+    this.mongoConnectionStringInternal = parsed.toString();
+    this.isReplicaSet = parsed.protocol === 'mongodb+srv:';
+
+    // redact username/password from publicly available connection string
+    parsed.username = '__user__';
+    parsed.password = '__pass__';
+    this.mongoConnectionString = parsed.toString();
+    this.mongoose = mongoose;
+  }
+
+  public async connect() {
+    while(!this.connected) {
+      console.log('Attempting to connect to Mongo...');
+      this.mongoose.connect(this.mongoConnectionStringInternal, {
+        ssl: false,
+        useUnifiedTopology: true,
+        useNewUrlParser: true,
+      })
+        .then(() => {
+          this.connected = true;
+          console.log(`Connected to MongoDB: ${this.mongoConnectionString}`);
+        })
+        .catch((e: any) => {
+          console.error(`There was an error connecting to MongoDB: ${this.mongoConnectionString}`);
+          console.error(e);
+        });
+
+      // wait five seconds before trying again
+      await wait(5000);
+    }
+  }
+}

package/src/NatsConnectionManager.ts

@@ -0,0 +1,268 @@
+'use strict';
+import * as NATS from 'nats';
+import { IConnectionManager, ILogManager, ISubscriptionRoutes } from '@sellout/models/.dist/interfaces';
+
+const BROADCAST_PREFIX = 'BROADCAST'; /* Prefix for broadcast messages */
+
+/**
+ * Exposes connection operations for NATS.
+ */
+class NatsConnectionManager implements IConnectionManager {
+
+  /**
+   * Exception representing an error that occurred during invocation of
+   * a message handler.
+   *
+   */
+  public static MESSAGE_HANDLER_ERROR = class extends Error {
+    public errors;
+
+    constructor(errors, messageSubject: string) {
+      super(`Error from message handler for '${messageSubject}'. Reason = ${JSON.stringify(errors)}`);
+      this.errors = errors;
+    }
+  };
+
+  /**
+   * Exception caused by request timeout.
+   */
+  public static TIMEOUT_ERROR = class extends Error {
+    public errors;
+
+    constructor(errors) {
+      super('NATS Timeout');
+      this.errors = errors;
+    }
+  };
+
+  public natsServers: string[];
+  private verbose: boolean;
+  private defaultRequestTimeout: number;
+
+  private conn: NATS.Client;
+  private logPrefix = 'NatsConnectionManager';
+  private logger;
+
+  /**
+   * Manages connections to NATS servers.
+   * @constructor
+   *
+   * @param {boolean} verbose - Log all events if true
+   */
+  constructor(natsServers: string[], logger: ILogManager, verbose = false, defaultRequestTimeout = 60000) {
+    this.logger = logger;
+    this.natsServers = natsServers;
+    this.verbose = verbose;
+    if (process.env.NATS_TIMEOUT) {
+      this.defaultRequestTimeout = parseInt(process.env.NATS_TIMEOUT, 10);
+    } else {
+      this.defaultRequestTimeout = defaultRequestTimeout;
+    }    
+  }
+
+  /**
+   * Connect to one of the specified servers.
+   *
+   * @param {string[]} servers - Array of server URLs for NATS (server is randomly chosen)
+   */
+  public connect(waitForConnect = true) {
+    const opts: NATS.ClientOpts = {};
+    opts.servers = this.natsServers;
+    opts.preserveBuffers = true;
+    opts.verbose = this.verbose;
+    opts.waitOnFirstConnect = waitForConnect;
+    opts.maxReconnectAttempts = -1;  /* Infinite reconnect attempts */
+
+    this.conn = NATS.connect(opts);
+    this.enableLogging();
+  }
+
+  /**
+   * Close active connections.
+   */
+  public close() {
+    this.conn.close();
+  }
+
+  /**
+   * Expose event system of Nats client.
+   *
+   * @param event
+   * @callback cb
+   */
+  public on(event: string, cb: (...args: any[]) => void) {
+    this.conn.on(event, cb);
+  }
+
+  /**
+   * Subscribes a service listener to its methods within a NATS queue.
+   *
+   * IMPORTANT: Ensure service message handlers are defined via arrow functions
+   *            to ensure instance variables of the class are accessible within
+   *            the scope of the handlers.
+   *
+   * @param service - Service Id of listener
+   * @param @optional {string} - Optional name of queue to subscribe
+   * @param {SubscriptionRoutes} routes - Mapping of method Ids to handlers
+   */
+  public subscribe(serviceId: string, queue: string, routes: ISubscriptionRoutes) {
+    this.logMessage(`Subscribing handlers for service='${serviceId}', queue='${queue}'`);
+    const topic = [serviceId, '>'].join('.');
+    return this.subscribeTopic(topic, queue, routes); /* Match all topics containing Service Id */
+  }
+
+  public subscribeBroadcast(serviceId: string, routes: ISubscriptionRoutes) {
+    const routeNames = Object.keys(routes);
+    this.logMessage(`Subscribing handlers for broadcast: [${routeNames.join(', ')}]`);
+    routeNames.forEach((r) => {
+      const topic = [BROADCAST_PREFIX, r].join('.');
+      const queue = `${serviceId}-${r}`;
+      this.subscribeTopic(topic, queue, { [r]: routes[r] });
+    });
+  }
+
+  public subscribeTopic(topicQualifier: string, queue: string | undefined, routes: ISubscriptionRoutes) {
+    const opts: NATS.SubscribeOptions = {};
+    opts.queue = queue;
+    this.conn.subscribe(topicQualifier, opts, (req, reply, subject: string) => {
+      const method = subject.substring(subject.indexOf('.') + 1);
+      const handler = routes[method];
+      this.logMessage(`Receive message: full subject=${subject}, method=${method}, replyTo=${reply} `);
+
+      handler.process(req).then(
+        (resp: Buffer) => {
+          if (reply) {
+            this.logMessage(`Publishing reply: ${reply}`);
+            this.conn.publish(reply, resp);
+          } else {
+            this.logMessage('No reply required');
+          }
+        },
+        (reason) => {
+          this.logMessage(`Handler failed. Reason= ${reason}`, false);
+          throw new NatsConnectionManager.MESSAGE_HANDLER_ERROR(reason, subject);
+        });
+    });
+  }
+
+  /**
+   * Publish request for service.
+   *
+   * @param {string} serviceId - Service Id of receipient
+   * @param {string} method - Id of method to call
+   * @param {Buffer} req - Request buffer
+   * @callback cb - Reply callback
+   * @param { number}  [timeout] - Register a default timeout for requests
+   */
+  // tslint:disable-next-line:max-line-length
+  public send = (serviceId: string, method: string, req: Buffer, cb: (error, reply) => void, timeout?: number): void => {
+
+    const subject = [serviceId, method].join('.');
+
+    const msgId = this.conn.requestOne(
+      subject,
+      req,
+      {},
+      timeout == null ? this.defaultRequestTimeout : timeout,
+      (reply) => {
+
+        this.logMessage(`Sending message: ${subject} (${msgId})`);
+
+        if (reply.code && reply.code === NATS.REQ_TIMEOUT) {
+
+          this.logMessage(`Reply for (${msgId}): ${JSON.stringify(reply)}`, true);
+
+          const error = new NatsConnectionManager.TIMEOUT_ERROR({
+            message: `Timeout sending request: ${subject} (${msgId})`,
+          });
+          cb(error, null);
+          return;
+        }
+
+        this.logMessage(`Received reply: ${subject} (${msgId})`);
+        cb(null, reply);
+      },
+    );
+  }
+
+  /**
+   * Publish a broadcast message
+   */
+  public sendBroadcast = (messageId: string, req: Buffer, cb: (error, reply) => void): void => {
+    return this.sendAsync(BROADCAST_PREFIX, messageId, req, cb);
+  }
+
+  /**
+   * Publish asynchronous request for service.
+   *
+   * @param {string} serviceId - Service Id of receipient
+   * @param {string} method - Id of method to call
+   * @param {Buffer} req - Request buffer
+   * @callback cb - Reply callback
+   */
+  public sendAsync = (serviceId: string, method: string, req: Buffer, cb: (error, reply) => void): void => {
+
+    const subject = [serviceId, method].join('.');
+
+    this.conn.publish(
+      subject,
+      req,
+      (reply) => {
+        this.logMessage(`Queued message: ${subject}`);
+
+        // NATS always returns "undefined" for publish, since reply is N/A.
+        // Protobuf Services require _some_ kind of Type (cannot be undefined or void).
+        // thus, return an empty `<Buffer >` here, which can be marshalled to the `google.protobuf.Empty` type.
+        const empty = Buffer.from([]);
+        cb(null, empty);
+      });
+  }
+
+  /**
+   * Register for logged connection events
+   */
+  private enableLogging(): void {
+    /**
+     * GENERIC ERROR LOGGING
+     */
+    this.conn.on('error', (err) => {
+      this.logMessage(err, false);
+    });
+
+    if (!this.verbose) {
+      return;
+    }
+
+    /**
+     * VERBOSE EVENT LOGGING
+     */
+    this.conn.on('connect', (conn) => {
+      this.logMessage(`Connection established to ${conn.currentServer.url.host}`);
+    });
+
+    this.conn.on('disconnect', () => {
+      this.logMessage('Disconnected', false);
+    });
+
+    this.conn.on('reconnect', () => {
+      this.logMessage('Reconnected', false);
+    });
+
+    this.conn.on('close', () => {
+      this.logMessage('Connection closed');
+    });
+  }
+
+  /**
+   * Log a message
+   *
+   * @param msg
+   */
+  private logMessage(msg, info = true): void {
+    if (!info || this.verbose) {
+      this.logger.info(`(${this.logPrefix}) ${msg}`);
+    }
+  }
+}
+
+export default NatsConnectionManager;

package/src/PbAsyncMessageHandler.ts

@@ -0,0 +1,28 @@
+import * as pb from "@sellout/models/.dist/sellout-proto";
+import { PbMessageHandler } from './PbMessageHandler';
+
+
+/* Message handler wrapper method for unidirectional calls */
+function invokeWithEmptyResponse(method) {
+  return (req: Buffer) => method(req).then(() => Promise.resolve(pb.google.protobuf.Empty.create()));
+}
+
+/**
+ * Provides a wrapper around asynchronous Protobuf messages that don't return a response.
+ * Incoming buffers are decoded, the handler method is called using staticly-compiled
+ * Protobuf definitions.
+ */
+export class PbAsyncMessageHandler extends PbMessageHandler {
+
+  /**
+   * @constructor
+   * @param method - Message handler method to be invoked
+   * @param requestCls - Request class provided by Protobuf
+   */
+  constructor(method, requestCls) {
+    super(invokeWithEmptyResponse(method), requestCls, pb.google.protobuf.Empty);
+  }
+
+}
+
+export default PbAsyncMessageHandler;

package/src/PbBroadcastProxy.ts

@@ -0,0 +1,41 @@
+import { Broadcast } from "@sellout/models/.dist/sellout-proto";
+import { IConnectionManager } from '@sellout/models/.dist/interfaces';
+import { PbServiceProxy } from './PbServiceProxy';
+
+export default class PbBroadcastProxy extends PbServiceProxy<Broadcast.Publisher> {
+  constructor(conn: IConnectionManager) {
+    super(conn, 'BROADCAST');
+  }
+
+  public activate(svc = Broadcast.Publisher): Broadcast.Publisher {
+    return super.activate(svc, true);
+  }
+
+  /**
+   * Provides handler logic for RPC sender. Note: use of arrow function
+   * required to maintain instance context.
+   *
+   * @param method
+   * @param requestData
+   * @param callback
+   */
+  protected sendRpcImpl = (method, requestData, callback) => {
+    throw('PbBroadcastProxy does not support synchronous calls');
+  }
+
+  /**
+   * Provides handler logic for RPC sender. Note: use of arrow function
+   * required to maintain instance context.
+   *
+   * @param method
+   * @param requestData
+   * @param callback
+   */
+  protected sendRpcImplAsync = (method, requestData, callback) => {
+    try {
+      this.conn.sendBroadcast(method.name, requestData, callback);
+    } catch (e) {
+      callback(e, null);
+    }
+  }
+}

package/src/PbMessageHandler.ts

@@ -0,0 +1,49 @@
+/**
+ * Provides a wrapper around Protobuf messages. Incoming buffers are decoded, the
+ * handler method is called using staticly-compiled Protobuf definitions, and returned
+ * reponse objects are encoded and marshalled into Buffer.
+ */
+export class PbMessageHandler {
+
+  public method;
+  public requestCls;
+  public responseCls;
+
+  /**
+   * @constructor
+   * @param method - Message handler method to be invoked
+   * @param requestCls - Request class provided by Protobuf
+   * @param responseCls - Response class provided by Protobuf
+   */
+  constructor(method, requestCls, responseCls) {
+    this.method = method;
+    this.requestCls = requestCls;
+    this.responseCls = responseCls;
+  }
+
+  /**
+   * Invoke registered message handler.
+   *
+   * @param {Buffer} req - Incoming request
+   * @returns {Promise<Buffer>} - Promise for buffer containing encoded response object
+   */
+  public process(req: Buffer): Promise<Buffer> {
+    return new Promise<Buffer>((resolve, reject) => {
+      const decoded = this.requestCls.decode(req);
+      // Pass plain JS object. I think this is a good idea? 
+      // Idk about the performance but we'll see :)
+       // TODO: enable defaults when decoding messages
+      const reqObj = this.requestCls.toObject(decoded);
+      this.method(reqObj).then((respObj) => {
+        const respEncoded = this.responseCls.encode(respObj).finish();
+        resolve(respEncoded);
+      })
+        .catch((e) => {
+          console.log(`Error processing message for method = ${this.method}`);
+          reject(e);
+        });
+    });
+  }
+}
+
+export default PbMessageHandler;

package/src/PbServiceProxy.ts

@@ -0,0 +1,66 @@
+import { IConnectionManager } from "./interfaces";
+
+/**
+ * Provides a client proxy that wraps a Service definition generated by staticly compiled Protobuf definition.
+ */
+export class PbServiceProxy<T> {
+  protected conn: IConnectionManager;
+  protected serviceName: string;
+
+  /**
+   * @coonstructor
+   * @param conn - Connection manager to handle outbound requests
+   * @param serviceName
+   */
+  public constructor(conn: IConnectionManager, serviceName: string) {
+    this.conn = conn;
+    this.serviceName = serviceName;
+  }
+
+  /**
+   *
+   * @param svc Create and activate an instance of a service
+   */
+  public activate(svc, async?): T {
+    if (async === true) {
+      return svc.create(this.sendRpcImplAsync);
+    } else {
+      // tslint:disable-line
+      return svc.create(this.sendRpcImpl);
+    }
+  }
+
+  /**
+   * Provides handler logic for RPC sender. Note: use of arrow function
+   * required to maintain instance context.
+   *
+   * @param method
+   * @param requestData
+   * @param callback
+   */
+  protected sendRpcImpl = (method, requestData, callback) => {
+    try {
+      this.conn.send(this.serviceName, method.name, requestData, callback);
+    } catch (e) {
+      callback(e, null);
+    }
+  };
+
+  /**
+   * Provides handler logic for RPC sender. Note: use of arrow function
+   * required to maintain instance context.
+   *
+   * @param method
+   * @param requestData
+   * @param callback
+   */
+  protected sendRpcImplAsync = (method, requestData, callback) => {
+    try {
+      this.conn.sendAsync(this.serviceName, method.name, requestData, callback);
+    } catch (e) {
+      callback(e, null);
+    }
+  };
+}
+
+export default PbServiceProxy;

package/src/Segment.ts

@@ -0,0 +1,35 @@
+import { ILogManager } from "./interfaces";
+
+const Analytics = require('analytics-node');
+
+/**
+ * Segment class to allow for 
+ * tracking only in production
+ */
+export default class Segment {
+  private segment: any;
+  private logger: ILogManager
+  constructor(SEGMENT_IO_WRITE_KEY: string | undefined, logger: ILogManager) {
+    this.segment = null;
+    this.logger = logger;
+
+    if(SEGMENT_IO_WRITE_KEY) {
+      this.logger.info("Segment - Initializing...");
+      this.segment = new Analytics(SEGMENT_IO_WRITE_KEY);
+    } else {
+      this.logger.warn("Segment - No write key supplied, skipping initialization...");
+    }
+  } 
+  track(params) {
+    if (this.segment) {
+      this.logger.info(`Segment - Tracking event ${params.event}.`);
+      this.segment.track(params);
+    }
+  }
+  identify(params) {
+    if (this.segment) {
+      this.logger.info(`Segment - Identified user.`);
+      this.segment.identify(params);
+    }
+  }
+}