account-lookup-service 17.10.3 → 17.11.0-snapshot.0

package/config/default.json

@@ -80,7 +80,20 @@
       "DISABLED": false,
       "TIMEXP": "*/30 * * * * *",
       "TIMEZONE": "UTC",
-      "BATCH_SIZE": 100
+      "BATCH_SIZE": 100,
+      "DIST_LOCK": {
+        "enabled": false,
+        "lockTimeout": 10000,
+        "acquireTimeout": 5000,
+        "driftFactor": 0.01,
+        "retryCount": 3,
+        "retryDelay": 200,
+        "retryJitter": 100,
+        "redisConfigs": [{
+          "type": "redis-cluster",
+          "cluster": [{ "host": "localhost", "port": 6379 }]
+        }]
+      }
     }
   },
   "SWITCH_ENDPOINT": "http://localhost:3001",

package/docker/account-lookup-service/default.json

@@ -79,7 +79,19 @@
       "DISABLED": false,
       "TIMEXP": "*/10 * * * * *",
       "TIMEZONE": "UTC",
-      "BATCH_SIZE": 100
+      "BATCH_SIZE": 100,
+      "DIST_LOCK": {
+        "enabled": true,
+        "lockTimeout": 10000,
+        "driftFactor": 0.01,
+        "retryCount": 3,
+        "retryDelay": 200,
+        "retryJitter": 100,
+        "redisConfigs": [{
+          "type": "redis-cluster",
+          "cluster": [{ "host": "redis-node-0", "port": 6379 }]
+        }]
+      }
     }
   },
   "SWITCH_ENDPOINT": "http://central-ledger:3001",

package/docker-compose.yml

@@ -68,6 +68,8 @@ services:
       - "sh"
       - "-c"
       - "node src/handlers/index.js h --timeout"
+    environment:
+      - LOG_LEVEL=debug
     depends_on:
       account-lookup-service:
         condition: service_healthy

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "17.10.3",
+  "version": "17.11.0-snapshot.0",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -68,6 +68,7 @@
     "seed:run": "knex seed:run $npm_package_config_knex",
     "seed:create": "knex seed:make $npm_package_config_knex",
     "regenerate": "yo swaggerize:test --framework hapi --apiPath './config/api_swagger.json'",
+    "dc:up:als-toh": ". ./test/integration/env.sh && docker compose $npm_package_config_env_file up account-lookup-service-handlers",
     "dc:build": "docker compose $npm_package_config_env_file build",
     "dc:up": ". ./test/integration/env.sh && docker compose $npm_package_config_env_file up -d  &&  docker ps",
     "dc:down": ". ./test/integration/env.sh && docker compose $npm_package_config_env_file down -v",
@@ -94,13 +95,13 @@
     "@mojaloop/central-services-health": "15.1.0",
     "@mojaloop/central-services-logger": "11.9.0",
     "@mojaloop/central-services-metrics": "12.6.0",
-    "@mojaloop/central-services-shared": "18.28.3",
-    "@mojaloop/central-services-stream": "11.7.0",
+    "@mojaloop/central-services-shared": "18.29.0-snapshot.0",
+    "@mojaloop/central-services-stream": "11.8.0",
     "@mojaloop/database-lib": "11.2.0",
     "@mojaloop/event-sdk": "14.6.1",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.6.0",
     "@mojaloop/ml-schema-transformer-lib": "2.7.1",
-    "@mojaloop/sdk-standard-components": "19.15.2",
+    "@mojaloop/sdk-standard-components": "19.16.0",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",
     "ajv-keywords": "5.1.0",
@@ -165,7 +166,7 @@
     "axios": "1.10.0",
     "axios-retry": "^4.5.0",
     "docdash": "2.0.2",
-    "dotenv": "^16.5.0",
+    "dotenv": "^17.0.1",
     "get-port": "5.1.1",
     "ioredis-mock": "^8.9.0",
     "jest": "29.7.0",

package/src/constants.js

@@ -43,8 +43,11 @@ const HANDLER_TYPES = Object.freeze({
   TIMEOUT: 'timeout'
 })
 
+const TIMEOUT_HANDLER_DIST_LOCK_KEY = 'mutex:als-timeout-handler'
+
 module.exports = {
   API_TYPES,
   ERROR_MESSAGES,
-  HANDLER_TYPES
+  HANDLER_TYPES,
+  TIMEOUT_HANDLER_DIST_LOCK_KEY
 }

package/src/handlers/TimeoutHandler.js

@@ -34,10 +34,12 @@ const CronJob = require('cron').CronJob
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const TimeoutService = require('../domain/timeout')
 const Config = require('../lib/config')
+const { createDistLock } = require('../lib')
 
 let timeoutJob
 let isRegistered
 let isRunning
+let distLock
 
 const timeout = async (options) => {
   if (isRunning) return
@@ -45,24 +47,26 @@ const timeout = async (options) => {
 
   try {
     isRunning = true
+    if (!await distLock?.acquireLock()) return
     await TimeoutService.timeoutInterschemePartiesLookups(options)
     await TimeoutService.timeoutProxyGetPartiesLookups(options)
     logger.verbose('ALS timeout handler is done')
   } catch (err) {
     logger.error('error in timeout: ', err)
   } finally {
+    await distLock?.releaseLock()
     isRunning = false
   }
 }
 
 const register = async (options) => {
   if (Config.HANDLERS_TIMEOUT_DISABLED) return false
-
   const { logger } = options
 
   try {
     if (isRegistered) {
-      await stop()
+      logger.info('Timeout handler already registered')
+      return false
     }
     timeoutJob = CronJob.from({
       start: false,
@@ -70,6 +74,7 @@ const register = async (options) => {
       cronTime: Config.HANDLERS_TIMEOUT_TIMEXP,
       timeZone: Config.HANDLERS_TIMEOUT_TIMEZONE
     })
+    distLock = createDistLock(Config.HANDLERS_TIMEOUT?.DIST_LOCK, logger)
     timeoutJob.start()
     isRegistered = true
     logger.info('Timeout handler registered')
@@ -83,7 +88,8 @@ const register = async (options) => {
 const stop = async () => {
   if (isRegistered) {
     await timeoutJob.stop()
-    isRegistered = undefined
+    // await distLock?.releaseLock()
+    isRegistered = false
   }
 }
 

package/src/handlers/register.js

@@ -70,7 +70,7 @@ const registerHandlers = async (handlers, options) => {
 const registerAllHandlers = async (options) => {
   options.logger.debug('Registering all handlers')
   await init(options)
-  TimeoutHandler.register(options)
+  await TimeoutHandler.register(options)
 }
 
 const stopAllHandlers = async (options) => {

package/src/lib/config.js

@@ -162,6 +162,7 @@ const config = {
   HANDLERS_TIMEOUT_TIMEXP: RC.HANDLERS.TIMEOUT.TIMEXP,
   HANDLERS_TIMEOUT_TIMEZONE: RC.HANDLERS.TIMEOUT.TIMEZONE,
   HANDLERS_TIMEOUT_BATCH_SIZE: RC.HANDLERS.TIMEOUT.BATCH_SIZE,
+  HANDLERS_TIMEOUT_DIST_LOCK_ENABLED: RC.HANDLERS.TIMEOUT?.DIST_LOCK?.enabled,
   ERROR_HANDLING: RC.ERROR_HANDLING,
   SWITCH_ENDPOINT: RC.SWITCH_ENDPOINT,
   INSTRUMENTATION_METRICS_DISABLED: RC.INSTRUMENTATION.METRICS.DISABLED,

package/src/lib/createDistLock.js

@@ -0,0 +1,74 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { distLock } = require('@mojaloop/central-services-shared').Util
+const { TIMEOUT_HANDLER_DIST_LOCK_KEY } = require('../constants')
+
+const createDistLock = (distLockConfig, logger) => {
+  const distLockKey = TIMEOUT_HANDLER_DIST_LOCK_KEY
+  const distLockTtl = distLockConfig?.lockTimeout || 10000
+  const distLockAcquireTimeout = distLockConfig?.acquireTimeout || 5000
+
+  const lock = distLockConfig?.enabled
+    ? distLock.createLock(distLockConfig, logger)
+    : null
+
+  const acquireLock = async () => {
+    if (lock) {
+      try {
+        return !!(await lock.acquire(distLockKey, distLockTtl, distLockAcquireTimeout))
+      } catch (err) {
+        logger.error('error acquiring distributed lock:', err)
+        // should this be added to metrics?
+        return false
+      }
+    }
+    logger.info('distributed lock not configured or disabled, running without distributed lock')
+    return true
+  }
+
+  const releaseLock = async () => {
+    if (lock) {
+      try {
+        await lock.release()
+        logger.verbose('distributed lock released')
+      } catch (error) {
+        logger.error('error releasing distributed lock:', error)
+        // should this be added to metrics?
+      }
+    } else {
+      logger.verbose('distributed lock not configured or disabled')
+    }
+  }
+
+  return {
+    acquireLock,
+    releaseLock
+  }
+}
+
+module.exports = createDistLock

package/src/lib/index.js

@@ -1,10 +1,12 @@
 const { loggerFactory, asyncStorage } = require('@mojaloop/central-services-logger/src/contextLogger')
 const { TransformFacades } = require('@mojaloop/ml-schema-transformer-lib')
+const createDistLock = require('./createDistLock')
 
 const logger = loggerFactory('ALS') // global logger without context
 
 module.exports = {
   logger,
   asyncStorage,
-  TransformFacades
+  TransformFacades,
+  createDistLock
 }

package/test/unit/handlers/TimeoutHandler.test.js

@@ -31,11 +31,23 @@
 
 'use strict'
 
+let mockDistLock
+jest.mock('@mojaloop/central-services-shared', () => ({
+  ...jest.requireActual('@mojaloop/central-services-shared'),
+  Util: {
+    ...jest.requireActual('@mojaloop/central-services-shared').Util,
+    distLock: {
+      createLock: jest.fn().mockImplementation(() => mockDistLock)
+    }
+  }
+}))
+
 const CronJob = require('cron').CronJob
 const TimeoutHandler = require('../../../src/handlers/TimeoutHandler')
 const TimeoutService = require('../../../src/domain/timeout')
 const Config = require('../../../src/lib/config')
 const { logger } = require('../../../src/lib')
+
 const DefaultConfig = { ...Config }
 
 const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms))
@@ -48,8 +60,19 @@ describe('TimeoutHandler', () => {
       start: jest.fn(),
       stop: jest.fn()
     })
-    const mockProxyCache = { processExpiredAlsKeys: jest.fn() }
-    mockOptions = { proxyCache: mockProxyCache, batchSize: 10, logger }
+    const mockProxyCache = {
+      processExpiredAlsKeys: jest.fn(),
+      processExpiredProxyGetPartiesKeys: jest.fn()
+    }
+    mockOptions = {
+      proxyCache: mockProxyCache,
+      batchSize: 10,
+      logger
+    }
+    mockDistLock = {
+      acquire: jest.fn().mockResolvedValue(true),
+      release: jest.fn().mockResolvedValue()
+    }
   })
 
   afterEach(async () => {
@@ -57,13 +80,20 @@ describe('TimeoutHandler', () => {
   })
 
   describe('timeout', () => {
+    afterEach(async () => {
+      await TimeoutHandler.stop()
+    })
+
     it('should execute timout service', async () => {
+      await TimeoutHandler.register(mockOptions)
       jest.spyOn(TimeoutService, 'timeoutInterschemePartiesLookups').mockResolvedValue()
-      await expect(TimeoutHandler.timeout(mockOptions)).resolves.toBeUndefined()
+      await TimeoutHandler.timeout(mockOptions)
       expect(TimeoutService.timeoutInterschemePartiesLookups).toHaveBeenCalled()
     })
 
-    it('should not run if isRunning is true', async () => {
+    it('should not run if isRunning is true (distLock disabled)', async () => {
+      await TimeoutHandler.register(mockOptions)
+      Config.HANDLERS_TIMEOUT_DIST_LOCK_ENABLED = false
       jest.spyOn(TimeoutService, 'timeoutInterschemePartiesLookups').mockImplementation(async () => {
         await wait(1000)
       })
@@ -73,6 +103,30 @@ describe('TimeoutHandler', () => {
       ])
       expect(TimeoutService.timeoutInterschemePartiesLookups).toHaveBeenCalledTimes(1)
     })
+
+    it('should use distributed lock when enabled', async () => {
+      Config.HANDLERS_TIMEOUT.DIST_LOCK = { enabled: true }
+      jest.spyOn(TimeoutService, 'timeoutProxyGetPartiesLookups').mockResolvedValue()
+      await TimeoutHandler.register(mockOptions)
+
+      await TimeoutHandler.timeout(mockOptions)
+      expect(mockDistLock.acquire).toHaveBeenCalledTimes(1)
+      expect(mockDistLock.release).toHaveBeenCalledTimes(1)
+      expect(TimeoutService.timeoutProxyGetPartiesLookups).toHaveBeenCalled()
+    })
+
+    it('should not run if distributed lock cannot be acquired', async () => {
+      mockDistLock.acquire = jest.fn().mockResolvedValue(false)
+      Config.HANDLERS_TIMEOUT.DIST_LOCK = { enabled: true }
+      jest.spyOn(TimeoutService, 'timeoutProxyGetPartiesLookups').mockResolvedValue()
+      await TimeoutHandler.register(mockOptions)
+
+      await TimeoutHandler.timeout(mockOptions)
+
+      expect(mockDistLock.acquire).toHaveBeenCalledTimes(1)
+      expect(mockDistLock.release).toHaveBeenCalled() // todo: think if we need .release() to have been called
+      expect(TimeoutService.timeoutProxyGetPartiesLookups).not.toHaveBeenCalled()
+    })
   })
 
   describe('register', () => {