@mojaloop/sdk-scheme-adapter 12.2.2 → 13.0.0

package/src/OutboundServer/index.js

@@ -28,18 +28,19 @@ const middlewares = require('./middlewares');
 const endpointRegex = /\/.*/g;
 
 class OutboundApi extends EventEmitter {
-    constructor(conf, logger, cache, validator) {
+    constructor(conf, logger, cache, validator, metricsClient) {
         super({ captureExceptions: true });
         this._logger = logger;
         this._api = new Koa();
         this._conf = conf;
         this._cache = cache;
+        this._metricsClient = metricsClient;
 
         this._wso2 = {
             auth: new WSO2Auth({
                 ...this._conf.wso2.auth,
                 logger: this._logger,
-                tlsCreds: this._conf.mutualTLS.outboundRequests.enabled && this._conf.mutualTLS.outboundRequests.creds,
+                tlsCreds: this._conf.outbound.tls.mutualTLS.enabled && this._conf.outbound.tls.creds,
             }),
             retryWso2AuthFailureTimes: conf.wso2.requestAuthFailureRetryTimes,
         };
@@ -54,7 +55,7 @@ class OutboundApi extends EventEmitter {
         this._api.use(middlewares.createErrorHandler(this._logger));
         this._api.use(middlewares.createRequestIdGenerator());
         this._api.use(koaBody()); // outbound always expects application/json
-        this._api.use(middlewares.applyState({ cache, wso2: this._wso2, conf }));
+        this._api.use(middlewares.applyState({ cache, wso2: this._wso2, conf, metricsClient }));
         this._api.use(middlewares.createLogger(this._logger));
 
         //Note that we strip off any path on peerEndpoint config after the origin.
@@ -67,7 +68,7 @@ class OutboundApi extends EventEmitter {
                 proxyConfig: conf.proxyConfig,
                 logger: this._logger,
                 wso2Auth: this._wso2.auth,
-                tls: conf.mutualTLS.outboundRequests,
+                tls: conf.outbound.tls,
             }));
         }
 
@@ -91,7 +92,7 @@ class OutboundApi extends EventEmitter {
 }
 
 class OutboundServer extends EventEmitter {
-    constructor(conf, logger, cache) {
+    constructor(conf, logger, cache, metricsClient) {
         super({ captureExceptions: true });
         this._validator = new Validate();
         this._conf = conf;
@@ -101,7 +102,8 @@ class OutboundServer extends EventEmitter {
             conf,
             this._logger.push({ component: 'api' }),
             cache,
-            this._validator
+            this._validator,
+            metricsClient
         );
         this._api.on('error', (...args) => {
             this.emit('error', ...args);
@@ -111,14 +113,11 @@ class OutboundServer extends EventEmitter {
 
     async start() {
         await this._api.start();
-
         const specPath = path.join(__dirname, 'api.yaml');
         const apiSpecs = yaml.load(fs.readFileSync(specPath));
         await this._validator.initialise(apiSpecs);
-
-        await new Promise((resolve) => this._server.listen(this._conf.outboundServerPort, resolve));
-
-        this._logger.log(`Serving outbound API on port ${this._conf.outboundServerPort}`);
+        await new Promise((resolve) => this._server.listen(this._conf.outbound.port, resolve));
+        this._logger.log(`Serving outbound API on port ${this._conf.outbound.port}`);
     }
 
     async stop() {

package/src/config.js

@@ -58,17 +58,29 @@ const env = from(process.env, {
 
 module.exports = {
     __parseResourceVersion: parseResourceVersions,
-    mutualTLS: {
-        inboundRequests: {
-            enabled: env.get('INBOUND_MUTUAL_TLS_ENABLED').default('false').asBool(),
+    control: {
+        mgmtAPIWsUrl: env.get('MGMT_API_WS_URL').default('127.0.0.1').asString(),
+        mgmtAPIWsPort: env.get('MGMT_API_WS_PORT').default('4005').asPortNumber()
+    },
+    inbound: {
+        port: env.get('INBOUND_LISTEN_PORT').default('4000').asPortNumber(),
+        tls: {
+            mutualTLS: {
+                enabled: env.get('INBOUND_MUTUAL_TLS_ENABLED').default('false').asBool(),
+            },
             creds: {
                 ca: env.get('IN_CA_CERT_PATH').asFileListContent(),
                 cert: env.get('IN_SERVER_CERT_PATH').asFileContent(),
                 key: env.get('IN_SERVER_KEY_PATH').asFileContent(),
             },
         },
-        outboundRequests: {
-            enabled: env.get('OUTBOUND_MUTUAL_TLS_ENABLED').default('false').asBool(),
+    },
+    outbound: {
+        port: env.get('OUTBOUND_LISTEN_PORT').default('4001').asPortNumber(),
+        tls: {
+            mutualTLS: {
+                enabled: env.get('OUTBOUND_MUTUAL_TLS_ENABLED').default('false').asBool(),
+            },
             creds: {
                 ca: env.get('OUT_CA_CERT_PATH').asFileListContent(),
                 cert: env.get('OUT_CLIENT_CERT_PATH').asFileContent(),
@@ -76,9 +88,9 @@ module.exports = {
             },
         },
     },
-    inboundServerPort: env.get('INBOUND_LISTEN_PORT').default('4000').asPortNumber(),
-    outboundServerPort: env.get('OUTBOUND_LISTEN_PORT').default('4001').asPortNumber(),
-    testServerPort: env.get('TEST_LISTEN_PORT').default('4002').asPortNumber(),
+    test: {
+        port: env.get('TEST_LISTEN_PORT').default('4002').asPortNumber(),
+    },
     peerEndpoint: env.get('PEER_ENDPOINT').required().asString(),
     alsEndpoint: env.get('ALS_ENDPOINT').asString(),
     quotesEndpoint: env.get('QUOTES_ENDPOINT').asString(),
@@ -93,6 +105,9 @@ module.exports = {
     checkIlp: env.get('CHECK_ILP').default('true').asBool(),
     expirySeconds: env.get('EXPIRY_SECONDS').default('60').asIntPositive(),
 
+    multiplePartiesResponse: env.get('MULTIPLE_PARTIES_RESPONSE').default('false').asBool(),
+    multiplePartiesResponseSeconds: env.get('MULTIPLE_PARTIES_RESPONSE_SECONDS').default('30').asIntPositive(),
+
     autoAcceptQuotes: env.get('AUTO_ACCEPT_QUOTES').default('true').asBool(),
     autoAcceptParty: env.get('AUTO_ACCEPT_PARTY').default('true').asBool(),
     autoAcceptR2PBusinessQuotes: env.get('AUTO_ACCEPT_R2P_BUSINESS_QUOTES').default('false').asBool(),
@@ -153,17 +168,19 @@ module.exports = {
 
     proxyConfig: env.get('PROXY_CONFIG_PATH').asYamlConfig(),
     reserveNotification: env.get('RESERVE_NOTIFICATION').default('false').asBool(),
+    sendFinalNotificationIfRequested: env.get('SEND_FINAL_NOTIFICATION_IF_REQUESTED').default('false').asBool(),
+
     // resourceVersions config should be string in format: "resourceOneName=1.0,resourceTwoName=1.1"
     resourceVersions: env.get('RESOURCE_VERSIONS').default('').asResourceVersions(),
 
+    metrics: {
+        port: env.get('METRICS_SERVER_LISTEN_PORT').default('4004').asPortNumber()
+    },
+
     // in 3PPI DFSP's generate their own `transferId` which is associated with
     // a transactionRequestId. this option decodes the ilp packet for
     // the `transactionId` to retrieve the quote from cache
     allowDifferentTransferTransactionId: env.get('ALLOW_DIFFERENT_TRANSFER_TRANSACTION_ID').default('false').asBool(),
 
     pm4mlEnabled: env.get('PM4ML_ENABLED').default('false').asBool(),
-    control: {
-        mgmtAPIWsUrl: env.get('MGMT_API_WS_URL').default('127.0.0.1').asString(),
-        mgmtAPIWsPort: env.get('MGMT_API_WS_PORT').default('4005').asPortNumber()
-    },
 };

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,