@mojaloop/sdk-scheme-adapter 12.2.1 → 12.3.0

package/src/index.js

@@ -10,14 +10,18 @@
 
 'use strict';
 
+const assert = require('assert/strict');
 const { hostname } = require('os');
 const config = require('./config');
 const EventEmitter = require('events');
+const _ = require('lodash');
 
 const InboundServer = require('./InboundServer');
 const OutboundServer = require('./OutboundServer');
 const OAuthTestServer = require('./OAuthTestServer');
 const TestServer = require('./TestServer');
+const { MetricsServer, MetricsClient } = require('./lib/metrics');
+const ControlAgent = require('./ControlAgent');
 
 // import things we want to expose e.g. for unit tests and users who dont want to use the entire
 // scheme adapter as a service
@@ -25,10 +29,20 @@ const InboundServerMiddleware = require('./InboundServer/middlewares.js');
 const OutboundServerMiddleware = require('./OutboundServer/middlewares.js');
 const Router = require('./lib/router');
 const Validate = require('./lib/validate');
-const RandomPhrase = require('./lib/randomphrase');
 const Cache = require('./lib/cache');
+const check = require('./lib/check');
 const { Logger } = require('@mojaloop/sdk-standard-components');
 
+const LOG_ID = {
+    INBOUND:   { app: 'mojaloop-connector-inbound-api' },
+    OUTBOUND:  { app: 'mojaloop-connector-outbound-api' },
+    TEST:      { app: 'mojaloop-connector-test-api' },
+    OAUTHTEST: { app: 'mojaloop-connector-oauth-test-server' },
+    CONTROL:   { app: 'mojaloop-connector-control-client' },
+    METRICS:   { app: 'mojaloop-connector-metrics' },
+    CACHE:     { component: 'cache' },
+};
+
 /**
  * Class that creates and manages http servers that expose the scheme adapter APIs.
  */
@@ -39,14 +53,22 @@ class Server extends EventEmitter {
         this.logger = logger;
         this.cache = new Cache({
             ...conf.cacheConfig,
-            logger: this.logger.push({ component: 'cache' }),
+            logger: this.logger.push(LOG_ID.CACHE),
             enableTestFeatures: conf.enableTestFeatures,
         });
 
+        this.metricsClient = new MetricsClient();
+
+        this.metricsServer = new MetricsServer({
+            port: this.conf.metrics.port,
+            logger: this.logger.push(LOG_ID.METRICS)
+        });
+
         this.inboundServer = new InboundServer(
             this.conf,
-            this.logger.push({ app: 'mojaloop-sdk-inbound-api' }),
-            this.cache
+            this.logger.push(LOG_ID.INBOUND),
+            this.cache,
+            this.metricsClient
         );
         this.inboundServer.on('error', (...args) => {
             this.logger.push({ args }).log('Unhandled error in Inbound Server');
@@ -55,8 +77,9 @@ class Server extends EventEmitter {
 
         this.outboundServer = new OutboundServer(
             this.conf,
-            this.logger.push({ app: 'mojaloop-sdk-outbound-api' }),
-            this.cache
+            this.logger.push(LOG_ID.OUTBOUND),
+            this.cache,
+            this.metricsClient
         );
         this.outboundServer.on('error', (...args) => {
             this.logger.push({ args }).log('Unhandled error in Outbound Server');
@@ -67,16 +90,140 @@ class Server extends EventEmitter {
             clientKey: this.conf.oauthTestServer.clientKey,
             clientSecret: this.conf.oauthTestServer.clientSecret,
             port: this.conf.oauthTestServer.listenPort,
-            logger: this.logger.push({ app: 'mojaloop-sdk-oauth-test-server' }),
+            logger: this.logger.push(LOG_ID.OAUTHTEST),
         });
 
         this.testServer = new TestServer({
-            port: this.conf.testServerPort,
-            logger: this.logger.push({ app: 'mojaloop-sdk-test-api' }),
+            port: this.conf.test.port,
+            logger: this.logger.push(LOG_ID.TEST),
             cache: this.cache,
         });
     }
 
+    async restart(newConf) {
+        // Figuring out what config is necessary in each server and component is a pretty big job
+        // that we'll have to save for later. For now, when the config changes, we'll restart
+        // more than we might have to.
+        // We'll do this by:
+        // 0. creating a new instance of the logger, if necessary
+        // 1. creating a new instance of the cache, if necessary
+        // 2. calling the async reconfigure method of each of the servers as necessary- this will
+        //    return a synchronous function that we can call to swap over the server events and
+        //    object properties to the new ones. It will:
+        //    1. remove the `request` listener for each of the HTTP servers
+        //    2. add the new appropriate `request` listener
+        //    This results in a completely synchronous listener changeover to the new config and
+        //    therefore hopefully avoids any concurrency issues arising from restarting different
+        //    servers or components concurrently.
+        // TODO: in the sense of being able to reason about the code, it would make some sense to
+        // turn the config items or object passed to each server into an event emitter, or pass an
+        // additional event emitter to the server constructor for the server to listen to and act
+        // on changes. Before this, however, it's probably necessary to ensure each server gets
+        // _only_ the config it needs, not the entire config object.
+        // Further: it might be possible to use Object.observe for this functionality.
+        // TODO: what happens if this is run concurrently? I.e. if it is called twice in rapid
+        // succession. This question probably needs to be asked of the reconfigure message on every
+        // server.
+        // Note that it should be possible to reconfigure ports on a running server by reassigning
+        // servers, e.g.
+        //   this.inboundServer._server = createHttpServer();
+        //   this.inboundServer._server.listen(newPort);
+        // If there are conflicts, for example if the new configuration specifies the new inbound
+        // port to be the same value as the old outbound port, this will require either
+        // 1. some juggling of HTTP servers, e.g.
+        //      const oldInboundServer = this.inboundServer._server;
+        //      this.inboundServer._server = this.outboundServer._server;
+        //    .. etc.
+        // 2. some juggling of sockets between servers, if possible
+        // 3. rearchitecting of the servers, perhaps splitting the .start() method on the servers
+        //    to an .init() and .listen() methods, with the latter optionally taking an HTTP server
+        //    as argument
+        // This _might_ introduce some confusion/complexity for existing websocket clients, but as
+        // the event handlers _should_ not be modified this shouldn't be a problem. A careful
+        // analysis of this will be necessary.
+        assert(newConf.inbound.port === this.conf.inbound.port
+            && newConf.outbound.port === this.conf.outbound.port
+            && newConf.test.port === this.conf.test.port
+            && newConf.oauthTestServer.listenPort === this.conf.oauthTestServer.listenPort
+            && newConf.control.mgmtAPIWsPort === this.conf.control.mgmtAPIWsPort,
+        'Cannot reconfigure ports on running server');
+        const doNothing = () => {};
+        const updateLogger = check.notDeepEqual(newConf.logIndent, this.conf.logIndent);
+        if (updateLogger) {
+            this.logger = new Logger.Logger({
+                context: {
+                    // If we're running from a Mojaloop helm chart deployment, we'll have a SIM_NAME
+                    simulator: process.env['SIM_NAME'],
+                    hostname: hostname(),
+                },
+                stringify: Logger.buildStringify({ space: this.conf.logIndent }),
+            });
+        }
+        let oldCache;
+        const updateCache = (
+            updateLogger ||
+            check.notDeepEqual(this.conf.cacheConfig, newConf.cacheConfig) ||
+            check.notDeepEqual(this.conf.enableTestFeatures, newConf.enableTestFeatures)
+        );
+        if (updateCache) {
+            oldCache = this.cache;
+            this.cache = new Cache({
+                ...newConf.cacheConfig,
+                logger: this.logger.push(LOG_ID.CACHE),
+                enableTestFeatures: newConf.enableTestFeatures,
+            });
+            await this.cache.connect();
+        }
+        const confChanged = !check.deepEqual(newConf, this.conf);
+        // TODO: find better naming than "restart", because that's not really what's happening.
+        const [restartInboundServer, restartOutboundServer, restartControlClient] = confChanged
+            ? await Promise.all([
+                this.inboundServer.reconfigure(newConf, this.logger.push(LOG_ID.INBOUND), this.cache),
+                this.outboundServer.reconfigure(newConf, this.logger.push(LOG_ID.OUTBOUND), this.cache, this.metricsClient),
+                this.controlClient.reconfigure({
+                    logger: this.logger.push(LOG_ID.CONTROL),
+                    port: newConf.control.mgmtAPIWsPort,
+                    appConfig: newConf
+                }),
+            ])
+            : [doNothing, doNothing, doNothing];
+        const updateOAuthTestServer = (
+            updateLogger || check.notDeepEqual(newConf.oauthTestServer, this.conf.oauthTestServer)
+        );
+        const restartOAuthTestServer = updateOAuthTestServer
+            ? await this.oauthTestServer.reconfigure({
+                clientKey: this.conf.oauthTestServer.clientKey,
+                clientSecret: this.conf.oauthTestServer.clientSecret,
+                port: this.conf.oauthTestServer.listenPort,
+                logger: this.logger.push(LOG_ID.OAUTHTEST),
+            })
+            : doNothing;
+        const updateTestServer = (
+            updateLogger || updateCache || check.notDeepEqual(newConf.test.port, this.conf.test.port)
+        );
+        const restartTestServer = updateTestServer
+            ? await this.testServer.reconfigure({
+                port: newConf.test.port,
+                logger: this.logger.push(LOG_ID.TEST),
+                cache: this.cache,
+            })
+            : doNothing;
+        // You may not return an async restart function. Perform any required async activity in the
+        // reconfigure function and return a sync restart function. See the note at the top of this
+        // file.
+        [restartTestServer, restartOAuthTestServer, restartInboundServer, restartOutboundServer, restartControlClient]
+            .map(f => assert(Promise.resolve(f) !== f, 'Restart functions must be synchronous'));
+        restartTestServer();
+        restartOAuthTestServer();
+        restartInboundServer();
+        restartOutboundServer();
+        restartControlClient();
+        this.conf = newConf;
+        await Promise.all([
+            oldCache && oldCache.disconnect(),
+        ]);
+    }
+
     async start() {
         await this.cache.connect();
 
@@ -84,9 +231,25 @@ class Server extends EventEmitter {
         const startOauthTestServer = this.conf.oauthTestServer.enabled
             ?  this.oauthTestServer.start()
             : null;
+
+        // We only start the control client if we're running within Mojaloop Payment Manager.
+        // The control server is the Payment Manager Management API Service.
+        // We only start the client to connect to and listen to the Management API service for
+        // management protocol messages e.g configuration changes, certificate updates etc.
+        if (this.conf.pm4mlEnabled) {
+            this.controlClient = await ControlAgent.Client.Create({
+                address: this.conf.control.mgmtAPIWsUrl,
+                port: this.conf.control.mgmtAPIWsPort,
+                logger: this.logger.push(LOG_ID.CONTROL),
+                appConfig: this.conf,
+            });
+            this.controlClient.on(ControlAgent.EVENT.RECONFIGURE, this.restart.bind(this));
+        }
+
         await Promise.all([
             this.inboundServer.start(),
             this.outboundServer.start(),
+            this.metricsServer.start(),
             startTestServer,
             startOauthTestServer,
         ]);
@@ -98,10 +261,23 @@ class Server extends EventEmitter {
             this.outboundServer.stop(),
             this.oauthTestServer.stop(),
             this.testServer.stop(),
+            this.controlClient.stop(),
+            this.metricsServer.stop(),
         ]);
     }
 }
 
+/*
+* Call the Connector Manager in Management API to get the updated config
+*/
+async function _GetUpdatedConfigFromMgmtAPI(conf, logger, client) {
+    logger.log(`Getting updated config from Management API at ${conf.control.mgmtAPIWsUrl}:${conf.control.mgmtAPIWsPort}...`);
+    const clientSendResponse = await client.send(ControlAgent.build.CONFIGURATION.READ());
+    logger.log('client send returned:: ', clientSendResponse);
+    const responseRead = await client.receive();
+    logger.log('client receive returned:: ', responseRead);
+    return responseRead.data;
+}
 
 if(require.main === module) {
     (async () => {
@@ -115,6 +291,18 @@ if(require.main === module) {
             },
             stringify: Logger.buildStringify({ space: config.logIndent }),
         });
+        if(config.pm4mlEnabled) {
+            const controlClient = await ControlAgent.Client.Create({
+                address: config.control.mgmtAPIWsUrl,
+                port: config.control.mgmtAPIWsPort,
+                logger: logger,
+                appConfig: config,
+            });
+            const updatedConfigFromMgmtAPI = await _GetUpdatedConfigFromMgmtAPI(config, logger, controlClient);
+            logger.log(`updatedConfigFromMgmtAPI: ${JSON.stringify(updatedConfigFromMgmtAPI)}`);
+            _.merge(config, updatedConfigFromMgmtAPI);
+            controlClient.terminate();
+        }
         const svr = new Server(config, logger);
         svr.on('error', (err) => {
             logger.push({ err }).log('Unhandled server error');
@@ -140,9 +328,9 @@ if(require.main === module) {
 // scheme adapter as a service
 module.exports = {
     Cache,
+    ControlAgent,
     InboundServerMiddleware,
     OutboundServerMiddleware,
-    RandomPhrase,
     Router,
     Server,
     Validate,

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) => {