@mojaloop/sdk-scheme-adapter 12.2.2 → 13.0.0

package/src/lib/cache.js

@@ -21,8 +21,8 @@ const CONN_ST = {
 };
 
 /**
- * A shared cache abstraction over a REDIS distributed key/value store
- */
+  * A shared cache abstraction over a REDIS distributed key/value store
+  */
 class Cache {
     constructor(config) {
         this._config = config;
@@ -53,12 +53,12 @@ class Cache {
     }
 
     /**
-     * Connects to a redis server and waits for ready events
-     * Note: We create two connections. One for get, set and publish commands
-     * and another for subscribe commands. We do this as we are not supposed
-     * to issue any non-pub/sub related commands on a connection used for sub
-     * See: https://redis.io/topics/pubsub
-     */
+      * Connects to a redis server and waits for ready events
+      * Note: We create two connections. One for get, set and publish commands
+      * and another for subscribe commands. We do this as we are not supposed
+      * to issue any non-pub/sub related commands on a connection used for sub
+      * See: https://redis.io/topics/pubsub
+      */
     async connect() {
         switch(this._connectionState) {
             case CONN_ST.CONNECTED:
@@ -74,7 +74,6 @@ class Cache {
                 await this._inProgressDisconnection;
                 break;
         }
-
         this._connectionState = CONN_ST.CONNECTING;
         this._inProgressConnection = Promise.all([this._getClient(), this._getClient()]);
         [this._client, this._subscriptionClient] = await this._inProgressConnection;
@@ -82,15 +81,19 @@ class Cache {
         // hook up our sub message handler
         this._subscriptionClient.on('message', this._onMessage.bind(this));
 
+        if (this._config.enableTestFeatures) {
+            this.setTestMode(true);
+        }
+
         this._inProgressConnection = null;
         this._connectionState = CONN_ST.CONNECTED;
     }
 
     /**
-     * Configure Redis to emit keyevent events. This corresponds to the application test mode, and
-     * enables us to listen for changes on callback_* and request_* keys.
-     * Docs: https://redis.io/topics/notifications
-     */
+      * Configure Redis to emit keyevent events. This corresponds to the application test mode, and
+      * enables us to listen for changes on callback_* and request_* keys.
+      * Docs: https://redis.io/topics/notifications
+      */
     async setTestMode(enable) {
         // See for modes: https://redis.io/topics/notifications#configuration
         // This mode, 'Es$' is:
@@ -100,7 +103,7 @@ class Cache {
         const mode = enable ? 'Es$' : '';
         this._logger
             .push({ 'notify-keyspace-events': mode })
-            .log('REDIS client Configured to emit keyspace-events');
+            .log('Configuring Redis to emit keyevent events');
         this._client.config('SET', 'notify-keyspace-events', mode);
     }
 
@@ -133,12 +136,12 @@ class Cache {
 
 
     /**
-     * Subscribes to a channel
-     *
-     * @param channel {string} - The channel name to subscribe to
-     * @param callback {function} - Callback function to be executed when messages arrive on the specified channel
-     * @returns {Promise} - Promise that resolves with an integer callback Id to submit in unsubscribe request
-     */
+      * Subscribes to a channel
+      *
+      * @param channel {string} - The channel name to subscribe to
+      * @param callback {function} - Callback function to be executed when messages arrive on the specified channel
+      * @returns {Promise} - Promise that resolves with an integer callback Id to submit in unsubscribe request
+      */
     async subscribe(channel, callback) {
         return new Promise((resolve, reject) => {
             this._subscriptionClient.subscribe(channel, (err) => {
@@ -168,11 +171,11 @@ class Cache {
 
 
     /**
-     * Unsubscribes a callback from a channel
-     *
-     * @param channel {string} - name of the channel to unsubscribe from
-     * @param callbackId {integer} - id of the callback to remove
-     */
+      * Unsubscribes a callback from a channel
+      *
+      * @param channel {string} - name of the channel to unsubscribe from
+      * @param callbackId {integer} - id of the callback to remove
+      */
     async unsubscribe(channel, callbackId) {
         return new Promise((resolve, reject) => {
             if(this._callbacks[channel] && this._callbacks[channel][callbackId]) {
@@ -196,8 +199,8 @@ class Cache {
 
 
     /**
-     * Handler for published messages
-     */
+      * Handler for published messages
+      */
     async _onMessage(channel, msg) {
         if(this._callbacks[channel]) {
             // we have some callbacks to make
@@ -219,16 +222,16 @@ class Cache {
 
 
     /**
-     * Returns a new redis client
-     *
-     * @returns {object} - a connected REDIS client
-     * */
+      * Returns a new redis client
+      *
+      * @returns {object} - a connected REDIS client
+      * */
     async _getClient() {
         return new Promise((resolve, reject) => {
             const client = redis.createClient(this._config);
 
             client.on('error', (err) => {
-                this._logger.push({ err }).log('REDIS client Error');
+                this._logger.push({ err }).log('Error from REDIS client getting subscriber');
                 return reject(err);
             });
 
@@ -247,25 +250,25 @@ class Cache {
                 }
             });
 
-            client.on('ready', () => {
-                this._logger.log(`REDIS client ready at: ${this._config.host}:${this._config.port}`);
-                return resolve(client);
-            });
-
             client.on('connect', () => {
                 this._logger.log(`REDIS client connected at: ${this._config.host}:${this._config.port}`);
             });
+
+            client.on('ready', () => {
+                this._logger.log(`Connected to REDIS at: ${this._config.host}:${this._config.port}`);
+                return resolve(client);
+            });
         });
     }
 
 
     /**
-     * Publishes the specified message to the specified channel
-     *
-     * @param channelName {string} - channel name to publish to
-     * @param value - any type that will be converted to a JSON string (unless it is already a string) and published as the message
-     * @returns {Promise} - Promise that will resolve with redis replies or reject with an error
-     */
+      * Publishes the specified message to the specified channel
+      *
+      * @param channelName {string} - channel name to publish to
+      * @param value - any type that will be converted to a JSON string (unless it is already a string) and published as the message
+      * @returns {Promise} - Promise that will resolve with redis replies or reject with an error
+      */
     async publish(channelName, value) {
         return new Promise((resolve, reject) => {
             if(typeof(value) !== 'string') {
@@ -288,11 +291,11 @@ class Cache {
 
 
     /**
-     * Sets a value in the cache
-     *
-     * @param key {string} - cache key
-     * @param value {stirng} - cache value
-     */
+      * Sets a value in the cache
+      *
+      * @param key {string} - cache key
+      * @param value {stirng} - cache value
+      */
     async set(key, value) {
         return new Promise((resolve, reject) => {
             //if we are given an object, turn it into a string
@@ -313,10 +316,65 @@ class Cache {
     }
 
     /**
-     * Gets a value from the cache
-     *
-     * @param key {string} - cache key
-     */
+      * Add the specified value to the set stored at key
+      *
+      * @param key {string} - cache key
+      * @param value {string} - cache value
+      */
+    async add(key, value) {
+        return new Promise((resolve, reject) => {
+            //if we are given an object, turn it into a string
+            if(typeof(value) !== 'string') {
+                value = JSON.stringify(value);
+            }
+
+            this._client.sadd(key, value, (err, replies) => {
+                if(err) {
+                    this._logger.push({ key, value, err }).log(`Error setting cache key: ${key}`);
+                    return reject(err);
+                }
+
+                this._logger.push({ key, value, replies }).log(`Add cache key: ${key}`);
+                return resolve(replies);
+            });
+        });
+    }
+
+    /**
+      * Returns all the members of the set value stored at key
+      *
+      * @param key {string} - cache key
+      */
+    async members(key) {
+        return new Promise((resolve, reject) => {
+            this._client.smembers(key, (err, value) => {
+                if(err) {
+                    this._logger.push({ key, err }).log(`Error getting cache key: ${key}`);
+                    return reject(err);
+                }
+
+                this._logger.push({ key, value }).log(`Got cache key: ${key}`);
+
+                if(typeof(value) === 'string') {
+                    try {
+                        value = JSON.parse(value);
+                    }
+                    catch(err) {
+                        this._logger.push({ err }).log('Error parsing JSON cache value');
+                        return reject(err);
+                    }
+                }
+
+                return resolve(value);
+            });
+        });
+    }
+
+    /**
+      * Gets a value from the cache
+      *
+      * @param key {string} - cache key
+      */
     async get(key) {
         return new Promise((resolve, reject) => {
             this._client.get(key, (err, value) => {

package/src/lib/metrics.js

@@ -0,0 +1,148 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2019 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       James Bush - james.bush@modusbox.com                             *
+ **************************************************************************/
+
+'use strict';
+
+const http = require('http');
+const Koa = require('koa');
+const koaBody = require('koa-body');
+const PrometheusClient = require('prom-client');
+
+
+/**
+  * A utility class that abstracts the underlying metrics implementation (Prometheus)
+  * from the consumer. This may be premature if Prometheus is never swapped out...but
+  * who can tell what the Universe will bring us.
+  *
+  * This object exposes methods for getting different types of measurement construct
+  * in order for consuming code to record metrics. The constructs are quite tightly
+  * coupled to Prometheus view of metrics, although that is fairly abstract so the
+  * risk appears low that this will cause conflicts in future.
+  *
+  * The metrics client is intended to be used as a singleton in a process and keeps a
+  * 'per name' cache of metrics to avoid duplicates. Not sure if this is strictly
+  * necessary but I dont have time to dig into the prom-client code to see what
+  * happens if you create the same metric twice.
+  */
+class MetricsClient {
+    constructor() {
+        this._prometheusRegister = PrometheusClient.register;
+        this._metrics = {};
+
+        this._counterPrefix = 'cntr_';
+        this._histogramPrefix = 'hist_';
+        this._gaugePrefix = 'gage_';
+    }
+
+
+    getHistogram(name, description, buckets) {
+        const metricName = `${this._histogramPrefix}${name}`;
+
+        let conf = {
+            name: name,
+            help: description,
+        };
+
+        if(buckets) {
+            conf.buckets = buckets;
+        }
+
+        if(!this._metrics[metricName]) {
+            this._metrics[metricName] = new PrometheusClient.Histogram(conf);
+        }
+
+        return this._metrics[metricName];
+    }
+
+
+    getCounter(name, description) {
+        const metricName = `${this._counterPrefix}${name}`;
+
+        if(!this._metrics[metricName]) {
+            this._metrics[metricName] = new PrometheusClient.Counter({
+                name: name,
+                help: description
+            });
+        }
+
+        return this._metrics[metricName];
+    }
+
+
+    getGauge(name, description) {
+        const metricName = `${this._counterPrefix}${name}`;
+
+        if(!this._metrics[metricName]) {
+            this._metrics[metricName] = new PrometheusClient.Gauge({
+                name: name,
+                help: description
+            });
+        }
+
+        return this._metrics[metricName];
+    }
+}
+
+
+/**
+  * Exposes an HTTP endpoint for metrics to be scraped by some external daemon
+  */
+class MetricsServer {
+    /**
+      * @param {number} port metrics server listen port
+      * @param {Logger} logger Logger
+      * @param {Object} prometheusClient Prometheus client instance
+      */
+    constructor({ port, logger }) {
+        this._port = port;
+        this._logger = logger;
+        this._prometheusClient = PrometheusClient;
+        this._prometheusRegister = PrometheusClient.register;
+        this._api = this.setupApi();
+        this._server = http.createServer(this._api.callback());
+    }
+
+    async start() {
+        if (this._server.listening) {
+            return;
+        }
+        this._prometheusClient.collectDefaultMetrics({
+            prefix: 'mojaloop_connector_default_'
+        });
+
+        await new Promise((resolve) => this._server.listen(this._port, resolve));
+        this._logger.push({ port: this._port }).log('Serving Metrics');
+    }
+
+    async stop() {
+        await new Promise(resolve => this._server.close(resolve));
+        this._logger.log('Metrics Server shut down complete');
+    }
+
+    setupApi() {
+        const result = new Koa();
+
+        result.use(koaBody());
+        result.use(async ctx => {
+            this._logger.log('Metrics request received');
+
+            ctx.response.set('Content-Type', this._prometheusRegister.contentType);
+            ctx.response.body = this._prometheusRegister.metrics();
+        });
+
+        return result;
+    }
+}
+
+
+module.exports = {
+    MetricsServer,
+    MetricsClient
+};

package/src/lib/model/AccountsModel.js

@@ -36,7 +36,10 @@ class AccountsModel {
             logger: this._logger,
             peerEndpoint: config.alsEndpoint,
             dfspId: config.dfspId,
-            tls: config.tls,
+            tls: {
+                enabled: config.outbound.tls.mutualTLS.enabled,
+                creds: config.outbound.tls.creds,
+            },
             jwsSign: config.jwsSign,
             jwsSigningKey: config.jwsSigningKey,
             wso2: config.wso2,
@@ -130,20 +133,23 @@ class AccountsModel {
 
 
     async _executeCreateAccountsRequest(request) {
+        const accountRequest = request;
+
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
-            const requestKey = `ac_${request.requestId}`;
+            const requestKey = `ac_${accountRequest.requestId}`;
 
             const subId = await this._cache.subscribe(requestKey, async (cn, msg, subId) => {
                 try {
                     let error;
-                    let message = JSON.parse(msg);
+                    const message = JSON.parse(msg);
+                    this._data.postAccountsResponse = message.data;
 
                     if (message.type === 'accountsCreationErrorResponse') {
-                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(message.data)}`, 500);
-                        error.mojaloopError = message.data;
+                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(this._data.postAccountsResponse.body)}`, 500);
+                        error.mojaloopError = this._data.postAccountsResponse.body;
                     } else if (message.type !== 'accountsCreationSuccessfulResponse') {
-                        this._logger.push({ message }).log(
+                        this._logger.push(util.inspect(this._data.postAccountsResponse)).log(
                             `Ignoring cache notification for request ${requestKey}. ` +
                             `Unknown message type ${message.type}.`
                         );
@@ -164,7 +170,7 @@ class AccountsModel {
                         return reject(error);
                     }
 
-                    const response = message.data;
+                    const response = this._data.postAccountsResponse;
                     this._logger.push({ response }).log('Account creation response received');
                     return resolve(response);
                 }
@@ -175,7 +181,7 @@ class AccountsModel {
 
             // set up a timeout for the request
             const timeout = setTimeout(() => {
-                const err = new BackendError(`Timeout waiting for response to account creation request ${request.requestId}`, 504);
+                const err = new BackendError(`Timeout waiting for response to account creation request ${accountRequest.requestId}`, 504);
 
                 // we dont really care if the unsubscribe fails but we should log it regardless
                 this._cache.unsubscribe(requestKey, subId).catch(e => {
@@ -188,7 +194,7 @@ class AccountsModel {
             // now we have a timeout handler and a cache subscriber hooked up we can fire off
             // a POST /participants request to the switch
             try {
-                const res = await this._requests.postParticipants(request);
+                const res = await this._requests.postParticipants(accountRequest);
                 this._logger.push({ res }).log('Account creation request sent to peer');
             }
             catch(err) {
@@ -215,11 +221,11 @@ class AccountsModel {
     }
 
     _buildClientResponse(response) {
-        return response.partyList.map(party => ({
+        return response.body.partyList.map(party => ({
             idType: party.partyId.partyIdType,
             idValue: party.partyId.partyIdentifier,
             idSubValue: party.partyId.partySubIdOrType,
-            ...!response.currency && {
+            ...!response.body.currency && {
                 error: {
                     statusCode: Errors.MojaloopApiErrorCodes.CLIENT_ERROR.code,
                     message: 'Provided currency not supported',
@@ -292,7 +298,6 @@ class AccountsModel {
                 resp.currentState = stateEnum.ERROR_OCCURRED;
                 break;
         }
-
         return resp;
     }
 

package/src/lib/model/Async2SyncModel.js

@@ -228,7 +228,10 @@ function generate({
                         transfersEndpoint: config.transfersEndpoint,
                         transactionRequestsEndpoint: config.transactionRequestsEndpoint,
                         dfspId: config.dfspId,
-                        tls: config.tls,
+                        tls: {
+                            enabled: config.outbound.tls.mutualTLS.enabled,
+                            creds: config.outbound.tls.creds,
+                        },
                         jwsSign: config.jwsSign,
                         jwsSignPutParties: config.jwsSignPutParties,
                         jwsSigningKey: config.jwsSigningKey,