new cache'ing service

Author: paulcruse3

src/apigateway/resolver/cache.js

@@ -0,0 +1,45 @@
+class ResolverCache {
+    constructor(max = 128, mode = 'all') {
+        this.__max = max;
+        this.__mode = mode;
+        this.__cache = new Map();
+    }
+
+    put(routePath, endpointModule, isDynamic = false) {
+        if (!this.__max) {
+            return;
+        }
+        if (this.__mode === 'static' && isDynamic) {
+            return;
+        }
+        if (this.__mode === 'dynamic' && !isDynamic) {
+            return;
+        }
+        if (!this.__cache.has(routePath) && this.__cache.size === this.__max) {
+            const delKey = this.__cache.keys().next().value;
+            this.__cache.delete(delKey);
+        }
+        const entry = {endpointModule, isDynamic};
+        this.__cache.set(routePath, entry);
+    }
+
+    get(routePath) {
+        const entry = this.__cache.get(routePath);
+        if (entry) {
+            this.__cache.delete(routePath);
+            this.__cache.set(routePath, entry);
+            return entry;
+        }
+        return null;
+    }
+
+    delete(routePath) {
+        this.__cache.delete(routePath);
+    }
+
+    clear() {
+        this.__cache.clear();
+    }
+}
+
+module.exports = ResolverCache;

src/apigateway/resolver/index.js

@@ -3,11 +3,14 @@ const ImportManager = require('../import-manager');
 const DirectoryResolver = require('./directory-resolver');
 const ListResolver = require('./list-resolver');
 const PatternResolver = require('./pattern-resolver');
+const ResolverCache = require('./cache');
 
 class RouteResolver {
     constructor(params) {
         this.__params = params;
         this.__importer = new ImportManager();
+        this.__cacher = new ResolverCache(params.cacheSize, params.cacheMode);
+        this.__cacheMisses = 0;
         this.__resolver = null;
         this.__resolvers = {
             pattern: PatternResolver,
@@ -16,6 +19,10 @@ class RouteResolver {
         };
     }
 
+    get cacheMisses() {
+        return this.__cacheMisses;
+    }
+
     autoLoad() {
         this.__setResolverMode();
         this.__resolver.autoLoad();
@@ -30,7 +37,7 @@ class RouteResolver {
         try {
             this.__validateConfigs();
             this.__setResolverMode();
-            const endpointModule = this.__resolver.resolve(request);
+            const endpointModule = this.__getEndpointModule(request);
             if (this.__resolver.hasPathParams) {
                 this.__configurePathParams(endpointModule, request);
             }
@@ -45,6 +52,18 @@ class RouteResolver {
         }
     }
 
+    __getEndpointModule(request) {
+        const cached = this.__cacher.get(request.path);
+        if (cached) {
+            this.__resolver.hasPathParams = cached.isDynamic;
+            return cached.endpointModule;
+        }
+        this.__cacheMisses++;
+        const endpointModule = this.__resolver.resolve(request);
+        this.__cacher.put(request.path, endpointModule, this.__resolver.hasPathParams);
+        return endpointModule;
+    }
+
     __setResolverMode() {
         if (!this.__resolver) {
             const mode = this.__params.routingMode;
@@ -53,7 +72,13 @@ class RouteResolver {
     }
 
     __validateConfigs() {
-        const {routingMode, handlerPath, handlerPattern, handlerList} = this.__params;
+        const {routingMode, handlerPath, handlerPattern, handlerList, cacheSize, cacheMode} = this.__params;
+        if (!Number.isInteger(cacheSize) && cacheSize !== undefined) {
+            this.__importer.raiseRouterConfigError('cacheSize must be an integer');
+        }
+        if (cacheMode !== 'all' && cacheMode !== 'all' && cacheMode !== 'dynamic' && cacheMode !== undefined) {
+            this.__importer.raiseRouterConfigError('cacheMode must be either: all, dynamic, static');
+        }
         if (routingMode !== 'pattern' && routingMode !== 'directory' && routingMode !== 'list') {
             this.__importer.raiseRouterConfigError('routingMode must be either directory, pattern or list');
         }

test/mocks/apigateway/mock-directory-handlers/multi-trailing/index.js

@@ -0,0 +1,10 @@
+exports.requirements = {
+    post: {
+        requiredBody: 'v1-test-request'
+    }
+};
+
+exports.post = async (request, response) => {
+    response.body = {test: true};
+    return response;
+};

test/mocks/apigateway/mock-directory-handlers/multi-trailing/{lots-of-params}/index.js

@@ -0,0 +1,10 @@
+exports.requirements = {
+    get: {
+        requiredPath: 'multi-trailing/{key}/{value}'
+    }
+};
+
+exports.get = async (request, response) => {
+    response.body = {test: true};
+    return response;
+};

test/src/apigateway/resolver/cache.test.js

@@ -0,0 +1,104 @@
+const {assert} = require('chai');
+const ResolverCache = require('../../../../src/apigateway/resolver/cache');
+
+describe('Test Cache: src/apigateway/resolver/cache.js', () => {
+    describe('test simple cache operations', () => {
+        const cacher = new ResolverCache();
+        it('should cache the module sent', () => {
+            const mockModule = {module: true};
+            const dynamic = false;
+            const routePath = '/unit-test/v1/cache-test';
+            cacher.put(routePath, mockModule, dynamic);
+            const results = cacher.get(routePath);
+            assert.deepEqual(results.endpointModule, mockModule);
+            assert.isFalse(results.isDynamic);
+        });
+        it('should delete the module sent', () => {
+            const mockModule = {module: true};
+            const dynamic = false;
+            const routePath = '/unit-test/v1/cache-delete-test';
+            cacher.put(routePath, mockModule, dynamic);
+            cacher.delete(routePath);
+            const result = cacher.get(routePath);
+            assert.equal(result, null);
+        });
+        it('should clear all modules sent', () => {
+            const cacher = new ResolverCache();
+            const mockModule = {module: true};
+            const dynamic = false;
+            const routePath1 = '/unit-test/v1/cache-clear1-test';
+            const routePath2 = '/unit-test/v1/cache-clear2-test';
+            const routePath3 = '/unit-test/v1/cache-clear3-test';
+            cacher.put(routePath1, mockModule, dynamic);
+            cacher.put(routePath2, mockModule, dynamic);
+            cacher.put(routePath3, mockModule, dynamic);
+            cacher.clear();
+            const result1 = cacher.get(routePath1);
+            assert.equal(result1, null);
+            const result2 = cacher.get(routePath2);
+            assert.equal(result2, null);
+            const result3 = cacher.get(routePath3);
+            assert.equal(result3, null);
+        });
+    });
+    describe('test conditional max size', () => {
+        it('should cache nothing', () => {
+            const cacher = new ResolverCache(0);
+            const mockModule = {module: true};
+            const dynamic = false;
+            const routePath = '/unit-test/v1/cache-nothing-test';
+            cacher.put(routePath, mockModule, dynamic);
+            const result = cacher.get(routePath);
+            assert.equal(result, null);
+        });
+        it('should only cache last 2 routes', () => {
+            const cacher = new ResolverCache(2);
+            const mockModule = {module: true};
+            const dynamic = false;
+            const routePath1 = '/unit-test/v1/cache-max1-test';
+            const routePath2 = '/unit-test/v1/cache-max2-test';
+            const routePath3 = '/unit-test/v1/cache-max3-test';
+            cacher.put(routePath1, mockModule, dynamic);
+            cacher.put(routePath2, mockModule, dynamic);
+            cacher.put(routePath3, mockModule, dynamic);
+            const result1 = cacher.get(routePath1);
+            assert.equal(result1, null);
+            const result2 = cacher.get(routePath2);
+            assert.deepEqual(result2.endpointModule, mockModule);
+            const result3 = cacher.get(routePath3);
+            assert.deepEqual(result3.endpointModule, mockModule);
+        });
+    });
+    describe('test conditional modes', () => {
+        it('should cache only static routes', () => {
+            const cacher = new ResolverCache(128, 'static');
+            const mockModule1 = {module: true};
+            const dynamic1 = false;
+            const routePath1 = '/unit-test/v1/cache-static-test';
+            cacher.put(routePath1, mockModule1, dynamic1);
+            const result1 = cacher.get(routePath1);
+            assert.deepEqual(result1.endpointModule, mockModule1);
+            const mockModule2 = {module: true};
+            const dynamic2 = true;
+            const routePath2 = '/unit-test/v1/cache-dynamic-test';
+            cacher.put(routePath2, mockModule2, dynamic2);
+            const result2 = cacher.get(routePath2);
+            assert.equal(result2, null);
+        });
+        it('should cache only dynamic routes', () => {
+            const cacher = new ResolverCache(128, 'dynamic');
+            const mockModule1 = {module: true};
+            const dynamic1 = true;
+            const routePath1 = '/unit-test/v1/cache-dynamic-test';
+            cacher.put(routePath1, mockModule1, dynamic1);
+            const result1 = cacher.get(routePath1);
+            assert.deepEqual(result1.endpointModule, mockModule1);
+            const mockModule2 = {module: true};
+            const dynamic2 = false;
+            const routePath2 = '/unit-test/v1/cache-staic-test';
+            cacher.put(routePath2, mockModule2, dynamic2);
+            const result2 = cacher.get(routePath2);
+            assert.equal(result2, null);
+        });
+    });
+});

test/src/apigateway/resolver/index.test.js

@@ -191,6 +191,19 @@ describe('Test Resolver: src/apigateway/resolver/index.js', () => {
             assert.deepEqual(request.pathParams, {id: '1', org: 'syngenta'});
             assert.equal(request.route, '/unit-test/v1/nested-1/{org}/path-parameters/{id}');
         });
+        it('should find file with multiple trailing path parameters', () => {
+            const basePath = 'unit-test/v1';
+            const routingMode = 'directory';
+            const handlerPath = 'test/mocks/apigateway/mock-directory-handlers';
+            const importer = new ImportManager();
+            const resolver = new RouteResolver({basePath, routingMode, handlerPath}, importer);
+            const mock = mockData.getApiGateWayCustomRouteWithParams('multi-trailing/some-key/some-value', 'get');
+            const request = new Request(mock);
+            const response = new Response();
+            resolver.getEndpoint(request, response);
+            assert.deepEqual(request.pathParams, {key: 'some-key', value: 'some-value'});
+            assert.equal(request.route, '/unit-test/v1/multi-trailing/{key}/{value}');
+        });
     });
     describe('test suffix pattern resolver with path parameters', () => {
         it('should resolve endpoint with trailing path parameter and have path params', () => {
@@ -395,4 +408,66 @@ describe('Test Resolver: src/apigateway/resolver/index.js', () => {
             assert.equal(request.route, '/unit-test/v1/n1/n2/{nested}/basic/{id}');
         });
     });
+    describe('test resolver cache', () => {
+        it('should raise an error when resolver cacheSize is incorrect', () => {
+            const basePath = 'unit-test/v1';
+            const routingMode = 'directory';
+            const handlerPath = 'test/mocks/apigateway/mock-directory-handlers';
+            const cacheSize = 'must-be-string';
+            const mock = mockData.getData();
+            const request = new Request(mock);
+            const response = new Response();
+            const importer = new ImportManager();
+            const resolver = new RouteResolver({basePath, routingMode, handlerPath, cacheSize}, importer);
+            resolver.getEndpoint(request, response);
+            assert.equal(response.body, '{"errors":[{"key_path":"router-config","message":"cacheSize must be an integer"}]}');
+        });
+        it('should raise an error when resolver cacheMode is incorrect', () => {
+            const basePath = 'unit-test/v1';
+            const routingMode = 'directory';
+            const handlerPath = 'test/mocks/apigateway/mock-directory-handlers';
+            const cacheMode = 'must-be-one-of-all-dynamic-static-';
+            const mock = mockData.getData();
+            const request = new Request(mock);
+            const response = new Response();
+            const importer = new ImportManager();
+            const resolver = new RouteResolver({basePath, routingMode, handlerPath, cacheMode}, importer);
+            resolver.getEndpoint(request, response);
+            assert.equal(
+                response.body,
+                '{"errors":[{"key_path":"router-config","message":"cacheMode must be either: all, dynamic, static"}]}'
+            );
+        });
+        it('should not have any cache misses', () => {
+            const basePath = 'unit-test/v1';
+            const routingMode = 'directory';
+            const handlerPath = 'test/mocks/apigateway/mock-directory-handlers';
+            const mock = mockData.getData();
+            const request = new Request(mock);
+            const response = new Response();
+            const importer = new ImportManager();
+            const resolver = new RouteResolver({basePath, routingMode, handlerPath}, importer);
+            resolver.getEndpoint(request, response);
+            resolver.getEndpoint(request, response);
+            resolver.getEndpoint(request, response);
+            resolver.getEndpoint(request, response);
+            assert.equal(resolver.cacheMisses, 1);
+        });
+        it('should have any 4 cache misses', () => {
+            const basePath = 'unit-test/v1';
+            const routingMode = 'directory';
+            const handlerPath = 'test/mocks/apigateway/mock-directory-handlers';
+            const mock = mockData.getData();
+            const cacheSize = 0;
+            const request = new Request(mock);
+            const response = new Response();
+            const importer = new ImportManager();
+            const resolver = new RouteResolver({basePath, routingMode, handlerPath, cacheSize}, importer);
+            resolver.getEndpoint(request, response);
+            resolver.getEndpoint(request, response);
+            resolver.getEndpoint(request, response);
+            resolver.getEndpoint(request, response);
+            assert.equal(resolver.cacheMisses, 4);
+        });
+    });
 });