soajs.controller 4.2.4 → 4.2.5

package/Gruntfile.js

@@ -56,7 +56,7 @@ let lib = {
 module.exports = function (grunt) {
 	//Loading the needed plugins to run the grunt tasks
 	let pluginsRootPath = lib.findRoot();
-	lib.loadTasks(grunt, pluginsRootPath, ['grunt-contrib-jshint', 'grunt-jsdoc', 'grunt-contrib-clean', 'grunt-mocha-test', 'grunt-env', 'grunt-istanbul', 'grunt-coveralls', 'grunt-contrib-copy']);
+	lib.loadTasks(grunt, pluginsRootPath, ['grunt-contrib-jshint', 'grunt-jsdoc', 'grunt-contrib-clean', 'grunt-mocha-test', 'grunt-env', 'grunt-istanbul', 'grunt-coveralls', 'grunt-babel', 'grunt-contrib-copy']);
 	grunt.initConfig({
 		//Defining jshint tasks
 		jshint: {
@@ -65,7 +65,7 @@ module.exports = function (grunt) {
 				"curly": true,
 				"eqeqeq": true,
 				"eqnull": true,
-				"esversion": 6,
+				"esversion": 8,
 				"forin": true,
 				"latedef": "nofunc",
 				"leanswitch": true,
@@ -89,7 +89,7 @@ module.exports = function (grunt) {
 				}
 			},
 			files: {
-				src: ['index.js', '_index.js', 'config.js', 'Gruntfile.js', 'lib/**/*.js', 'modules/driver/*.js', 'modules/driver/kubernetes/*.js', 'modules/driver/kubernetes/bl/*.js', 'modules/driver/kubernetes/model/*.js', 'modules/registry/*.js', 'mw/**/*.js', 'server/**/*.js', 'utilities/**/*.js']
+				src: ['index.js', '_index.js', 'config.js', 'Gruntfile.js', 'lib/**/*.js', 'modules/**/*.js', 'mw/**/*.js', 'server/**/*.js', 'utilities/**/*.js']
 			},
 			gruntfile: {
 				src: 'Gruntfile.js'
@@ -109,7 +109,7 @@ module.exports = function (grunt) {
 				SOAJS_ENV: "dev",
 				SOAJS_TEST: true,
 				SOAJS_PROFILE: __dirname + "/profiles/single.js",
-				APP_DIR_FOR_CODE_COVERAGE: '../test/coverage/instrument/'
+				APP_DIR_FOR_CODE_COVERAGE: '../test/coverage/instrument/test/dist/'
 			}
 		},
 		
@@ -119,23 +119,78 @@ module.exports = function (grunt) {
 			},
 			coverage: {
 				src: ['test/coverage/']
+			},
+			dist: {
+				src: ['test/dist/']
 			}
 		},
 		
+		babel: {
+			options: {
+				sourceMap: true,
+				presets: ['@babel/preset-env'],
+				plugins: ["@babel/plugin-transform-runtime"],
+			},
+			dist: {
+				files: [
+
+					{
+						expand: true,
+						cwd: 'lib/',
+						src: ['*.js'],
+						dest: 'test/dist/lib/'
+					},
+					{
+						expand: true,
+						cwd: 'modules/',
+						src: ['**/*.js'],
+						dest: 'test/dist/modules/'
+					},
+					{
+						expand: true,
+						cwd: 'mw/',
+						src: ['**/*.js'],
+						dest: 'test/dist/mw/'
+					},
+					{
+						expand: true,
+						cwd: 'profiles/',
+						src: ['*.js'],
+						dest: 'test/dist/profiles/'
+					},
+					{
+						expand: true,
+						cwd: 'server/',
+						src: ['*.js'],
+						dest: 'test/dist/server/'
+					},
+					{
+						expand: true,
+						cwd: 'utilities/',
+						src: ['*.js'],
+						dest: 'test/dist/utilities/'
+					},
+					{ 'test/dist/index.js': 'index.js' },
+					{ 'test/dist/_index.js': '_index.js' },
+					{ 'test/dist/config.js': 'config.js' },
+				]
+			}
+		},
+
 		copy: {
 			main: {
 				files: [
-					{expand: true, src: ['package.json'], dest: 'test/coverage/instrument/', filter: 'isFile'},
+					{expand: true, src: ['package.json'], dest: 'test/coverage/instrument/test/dist/', filter: 'isFile'},
 					{
 						cwd: 'modules/driver/kubernetes/model/swagger/',
 						src: '**/*',
-						dest: 'test/coverage/instrument/modules/driver/kubernetes/model/swagger/',
+						dest: 'test/coverage/instrument/test/dist/modules/driver/kubernetes/model/swagger/',
 						expand: true
 					},
 					{
 						cwd: 'modules/driver/kubernetes/model/clients/',  // set working folder / root to copy
 						src: '**/*',
-						dest: 'test/coverage/instrument/modules/driver/kubernetes/model/clients/',    // destination folder
+						dest: 'test/coverage/instrument/test/dist/modules/driver/kubernetes/model/clients/',    // destination folder
 						expand: true           // required when using cwd
 					}
 				]
@@ -143,7 +198,8 @@ module.exports = function (grunt) {
 		},
 		
 		instrument: {
-			files: ['index.js', '_index.js', 'config.js', 'lib/**/*.js', 'modules/driver/*.js', 'modules/driver/kubernetes/*.js', 'modules/driver/kubernetes/bl/*.js', 'modules/driver/kubernetes/model/*.js', 'modules/registry/*.js', 'mw/**/*.js', 'server/**/*.js', 'utilities/**/*.js'],
+			// files: ['index.js', '_index.js', 'config.js', 'lib/**/*.js', 'modules/driver/*.js', 'modules/driver/kubernetes/*.js', 'modules/driver/kubernetes/bl/*.js', 'modules/driver/kubernetes/model/*.js', 'modules/registry/*.js', 'mw/**/*.js', 'server/**/*.js', 'utilities/**/*.js'],
+			files: ['test/dist/index.js', 'test/dist/_index.js', 'test/dist/config.js', 'test/dist/lib/**/*.js', 'test/dist/modules/**/*.js', 'test/dist/mw/**/*.js', 'test/dist/server/**/*.js', 'test/dist/utilities/**/*.js'],
 			options: {
 				lazy: false,
 				basePath: 'test/coverage/instrument/'
@@ -202,11 +258,11 @@ module.exports = function (grunt) {
 	process.env.SHOW_LOGS = grunt.option('showLogs');
 	grunt.registerTask("default", ['jshint']);
 	grunt.registerTask("integration", ['env:mochaTest', 'mochaTest:integration']);
-	grunt.registerTask("integration-coverage", ['clean', 'copy', 'env:coverage', 'instrument', 'mochaTest:integration', 'storeCoverage', 'makeReport']);
+	grunt.registerTask("integration-coverage", ['clean', 'babel', 'copy', 'env:coverage', 'instrument', 'mochaTest:integration', 'storeCoverage', 'makeReport']);
 	grunt.registerTask("unit", ['env:mochaTest', 'mochaTest:unit']);
-	grunt.registerTask("unit-coverage", ['clean', 'copy', 'env:coverage', 'instrument', 'mochaTest:unit', 'storeCoverage', 'makeReport']);
-	grunt.registerTask("test", ['clean', 'copy', 'env:coverage', 'instrument', 'mochaTest:unit', 'mochaTest:integration', 'storeCoverage', 'makeReport']);
-	grunt.registerTask("coverage", ['clean', 'copy', 'env:coverage', 'instrument', 'mochaTest:unit', 'mochaTest:integration', 'storeCoverage', 'makeReport', 'coveralls']);
+	grunt.registerTask("unit-coverage", ['clean', 'babel', 'copy', 'env:coverage', 'instrument', 'mochaTest:unit', 'storeCoverage', 'makeReport']);
+	grunt.registerTask("test", ['clean', 'babel', 'copy', 'env:coverage', 'instrument', 'mochaTest:unit', 'mochaTest:integration', 'storeCoverage', 'makeReport']);
+	grunt.registerTask("coverage", ['clean', 'babel',  'copy', 'env:coverage', 'instrument', 'mochaTest:unit', 'mochaTest:integration', 'storeCoverage', 'makeReport', 'coveralls']);
 	
 };
 

package/mw/traffic/index.js

@@ -8,17 +8,25 @@
  * found in the LICENSE file at the root of this repository
  */
 
+
+const get = (p, o) => p.reduce((xs, x) => (xs && xs[x]) ? xs[x] : null, o);
+const memory = require('./model/memory.js');
+const mongo = require('./model/mongo.js');
+
+let model = {
+	memory, mongo
+};
 /**
  *
  * @param configuration
  * @returns {Function}
  */
-module.exports = function () {
-	
-	// var registryThrottling = {
-	//     "publicAPIStrategy" : "default", // can be null means throttling is off
-	//     "privateAPIStrategy": "heavy", // can be null means throttling is off
-	//     "default": {
+module.exports = function (configuration) {
+
+	// let registry.throttling = {
+	//     'publicAPIStrategy' : 'default', // can be null means throttling is off
+	//     'privateAPIStrategy': 'heavy', // can be null means throttling is off
+	//     'default': {
 	//         'status': 1, // 0=Off, 1=On
 	//         'type': 1, // 0= tenant, 1= tenant -> ip
 	//         'window': 60000,
@@ -26,7 +34,7 @@ module.exports = function () {
 	//         'retries': 2,
 	//         'delay': 1000
 	//     },
-	//     "off": {
+	//     'off': {
 	//         'status': 0, // 0=Off, 1=On
 	//         'type': 1, // 0= tenant, 1= tenant -> ip
 	//         'window': 60000,
@@ -34,7 +42,7 @@ module.exports = function () {
 	//         'retries': 2,
 	//         'delay': 1000
 	//     },
-	//     "heavy": {
+	//     'heavy': {
 	//         'status': 1, // 0=Off, 1=On
 	//         'type': 1, // 0= tenant, 1= tenant -> ip
 	//         'window': 60000,
@@ -43,64 +51,65 @@ module.exports = function () {
 	//         'delay': 1000
 	//     }
 	// };
-	// var provisionThrottling = {
-	//     "publicAPIStrategy" : "default", // can be null means throttling is off, if not set means inherit from registry
-	//     "privateAPIStrategy": null, // can be null means throttling is off, if not set means inherit from registry
+	// let provision.gateway.throttling = {
+	//     'publicAPIStrategy' : 'default', // can be null means throttling is off, if not set means inherit from registry
+	//     'privateAPIStrategy': null, // can be null means throttling is off, if not set means inherit from registry
+	//	   'oauth' : { 
+	//	   		'publicAPIStrategy' : 'default'	
+	//	   }
 	// };
-	
-	let dataHolder = {};
-	let checkThrottling = (obj, cb) => {
+	// let customRegistry.gateway = {
+	// 	"traffic": {
+	// 		"ip2ban": [
+	// 			"::1"
+	// 		],
+	// 		"model": "mongo",
+	// 		"throttling": {
+	// 			"oauth": {
+	// 				"publicAPIStrategy": "test",
+	// 				"apis": [
+	// 					"/token"
+	// 				]
+	// 			}
+	// 		}
+	// 	},
+	// };
+
+	model.memory.initThrottling(configuration.log);
+	model.mongo.initThrottling(configuration.log, configuration.gatewayDB);
+
+	let checkThrottling = async (obj, cb) => {
 		let trafficKey = obj.trafficKey;
 		let throttling = obj.throttling;
-		
-		let throttlingObj = {};
-		
-		if (!dataHolder[trafficKey.l1]) {
-			dataHolder[trafficKey.l1] = {};
-			if (throttling.type === 0) {
-				dataHolder[trafficKey.l1] = {
-					'firstReqTime': new Date(Date.now()),
-					'count': 0
-				};
-			}
-		}
-		
-		if (throttling.type === 1) {
-			if (!dataHolder[trafficKey.l1][trafficKey.l2]) {
-				dataHolder[trafficKey.l1][trafficKey.l2] = {
-					'firstReqTime': new Date(Date.now()),
-					'count': 0
-				};
-			}
-			throttlingObj = dataHolder[trafficKey.l1][trafficKey.l2];
-		} else {
-			throttlingObj = dataHolder[trafficKey.l1];
-		}
-		
+		let strategy = obj.strategy;
+		let modelType = obj.throttling.model || 'memory';
+
+		let throttlingObj = await model[modelType].getThrottling(throttling, trafficKey);
+
 		let remainingLifetime = throttling.window - Math.floor(Date.now() - throttlingObj.firstReqTime.getTime());
-		
+
 		if (remainingLifetime < 1) {
-			throttlingObj.firstReqTime = new Date(Date.now());
-			throttlingObj.count = 0;
+			throttlingObj = await model[modelType].resetThrottling(throttling, trafficKey);
 		}
-		
+		let throttlingCount = throttlingObj.count;
 		if (obj.retry === 0) {
-			throttlingObj.count++;
-			throttlingObj.lastReqTime = new Date(Date.now());
+			throttlingCount = throttlingObj.count + 1;
+			await model[modelType].incrementThrottling(throttling, trafficKey);
 		}
-		
-		if (throttlingObj.count > throttling.limit) {
+
+		if (throttlingCount > throttling.limit) {
 			obj.retry++;
 			if (obj.retry <= throttling.retries) {
 				setTimeout(function () {
-					checkThrottling({'trafficKey': trafficKey, 'throttling': throttling, 'retry': obj.retry}, cb);
+					checkThrottling({ trafficKey, throttling, 'retry': obj.retry, strategy }, cb);
 				}, throttling.delay);
 			} else {
+				await model[modelType].logTooManyRequests(trafficKey, strategy);
 				return cb({
 					'result': false, 'headObj': {
 						'Retry-After': remainingLifetime / 1000,
 						'X-RateLimit-Limit': throttling.limit,
-						'X-RateLimit-Remaining': throttling.limit - throttlingObj.count
+						'X-RateLimit-Remaining': throttling.limit - throttlingCount
 					}
 				});
 			}
@@ -109,43 +118,73 @@ module.exports = function () {
 				'result': true, 'headObj': {
 					'Retry-After': remainingLifetime / 1000,
 					'X-RateLimit-Limit': throttling.limit,
-					'X-RateLimit-Remaining': throttling.limit - throttlingObj.count
+					'X-RateLimit-Remaining': throttling.limit - throttlingCount
 				}
 			});
 		}
 	};
-	
+
 	return (req, res, next) => {
+
+		let ip2ban = get(["soajs", "registry", "custom", "gateway", "value", "traffic", "ip2ban"], req);
+		let clientIP = req.getClientIP();
+
+		if (ip2ban && Array.isArray(ip2ban) && ip2ban.includes(clientIP)) {
+			req.soajs.controllerResponse({
+				'status': 403,
+				'msg': 'banned'
+			});
+			return;
+		}
+
 		if (req && req.soajs && req.soajs.registry && req.soajs.registry.serviceConfig && req.soajs.registry.serviceConfig.throttling && req.soajs.tenant && req.soajs.controller) {
+
 			let serviceName = req.soajs.controller.serviceParams.name;
-			let strategy = (req.soajs.controller.serviceParams.isAPIPublic ? "publicAPIStrategy" : "privateAPIStrategy");
+			let api = req.soajs.controller.serviceParams.path;
+			let strategy = (req.soajs.controller.serviceParams.isAPIPublic ? 'publicAPIStrategy' : 'privateAPIStrategy');
 			let throttlingStrategy = req.soajs.registry.serviceConfig.throttling[strategy];
-			
-			if (req.soajs.servicesConfig && req.soajs.servicesConfig.gateway && req.soajs.servicesConfig.gateway.throttling) {
-				if (req.soajs.servicesConfig.gateway.throttling.hasOwnProperty(strategy)) {
-					throttlingStrategy = req.soajs.servicesConfig.gateway.throttling[strategy];
-				}
-				if (req.soajs.servicesConfig.gateway.throttling[serviceName]) {
-					if (req.soajs.servicesConfig.gateway.throttling[serviceName].hasOwnProperty(strategy)) {
-						throttlingStrategy = req.soajs.servicesConfig.gateway.throttling[strategy];
+
+			let throttlingConfiguration = get(["soajs", "servicesConfig", "gateway", "throttling"], req);
+			if (!throttlingConfiguration) {
+				throttlingConfiguration = get(["soajs", "registry", "custom", "gateway", "value", "traffic", "throttling"], req);
+			}
+			if (throttlingConfiguration) {
+				if (throttlingConfiguration[serviceName]) {
+					if (throttlingConfiguration[serviceName].hasOwnProperty(strategy)) {
+						if (throttlingConfiguration[serviceName].apis && Array.isArray(throttlingConfiguration[serviceName].apis)) {
+							if (throttlingConfiguration[serviceName].apis.includes(api)) {
+								throttlingStrategy = throttlingConfiguration[serviceName][strategy];
+							}
+						} else {
+							throttlingStrategy = throttlingConfiguration[serviceName][strategy];
+						}
 					}
 				}
 			}
+
 			if (!throttlingStrategy) {
 				return next();
 			}
 			let throttling = req.soajs.registry.serviceConfig.throttling[throttlingStrategy];
-			
+
 			if (throttling) {
-				let trafficKey = {"l1": req.soajs.tenant.id, "l2": req.getClientIP()};
-				
-				checkThrottling({'trafficKey': trafficKey, 'throttling': throttling, 'retry': 0}, function (response) {
+				let trafficModel = get(["soajs", "registry", "custom", "gateway", "value", "traffic", "model"], req);
+				if (trafficModel) {
+					throttling.model = trafficModel;
+					if (!model[throttling.model]) {
+						req.soajs.log.warn('Throttling:', 'Unkown model [' + throttling.model + ']. It can only be [memory || mongo]');
+						return next();
+					}
+				}
+				let trafficKey = { 'l1': req.soajs.tenant.id, 'l2': clientIP };
+
+				checkThrottling({ trafficKey, throttling, 'retry': 0, 'strategy': throttlingStrategy }, function (response) {
 					if (response.result) {
 						return next();
 					} else {
 						req.soajs.controllerResponse({
 							'status': 429,
-							'msg': "too many requests",
+							'msg': 'too many requests',
 							'headObj': response.headObj
 						});
 					}

package/mw/traffic/model/memory.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/**
+ * @license
+ * Copyright SOAJS All Rights Reserved.
+ *
+ * Use of this source code is governed by an Apache license that can be
+ * found in the LICENSE file at the root of this repository
+ */
+
+let dataHolder = {};
+
+let model = {
+    'log': null,
+    'initThrottling': (log) => {
+        model.log = log;
+        dataHolder = {};
+    },
+
+    'getThrottling': (throttling, trafficKey) => {
+
+        let throttlingObj = {};
+        if (!dataHolder[trafficKey.l1]) {
+            dataHolder[trafficKey.l1] = {
+                'firstReqTime': new Date(Date.now()),
+                'count': 0
+            };
+        }
+        if (throttling.type === 1) {
+            if (!dataHolder[trafficKey.l1][trafficKey.l2]) {
+                dataHolder[trafficKey.l1][trafficKey.l2] = {
+                    'firstReqTime': new Date(Date.now()),
+                    'count': 0
+                };
+            }
+            throttlingObj = dataHolder[trafficKey.l1][trafficKey.l2];
+        } else {
+            throttlingObj = dataHolder[trafficKey.l1];
+        }
+        return throttlingObj;
+    },
+
+    'resetThrottling': (throttling, trafficKey) => {
+        if (throttling.type === 1) {
+            dataHolder[trafficKey.l1][trafficKey.l2] = {
+                'firstReqTime': new Date(Date.now()),
+                'count': 0
+            };
+            return (dataHolder[trafficKey.l1][trafficKey.l2]);
+        } else {
+            dataHolder[trafficKey.l1] = {
+                'firstReqTime': new Date(Date.now()),
+                'count': 0
+            };
+            return (dataHolder[trafficKey.l1]);
+        }
+    },
+
+    'incrementThrottling': (throttling, trafficKey) => {
+        if (throttling.type === 1) {
+            dataHolder[trafficKey.l1][trafficKey.l2].count++;
+        } else {
+            dataHolder[trafficKey.l1].count++;
+        }
+    },
+
+    'logTooManyRequests': (trafficKey, throttlingStrategy) => {
+        model.log.error('Throttling [' + throttlingStrategy + ']rejected:', 'using tenant id [' + trafficKey.l1 + '] from ip [' + trafficKey.l2 + ']');
+    }
+};
+
+
+module.exports = model;

package/mw/traffic/model/mongo.js

@@ -0,0 +1,115 @@
+'use strict';
+
+/**
+ * @license
+ * Copyright SOAJS All Rights Reserved.
+ *
+ * Use of this source code is governed by an Apache license that can be
+ * found in the LICENSE file at the root of this repository
+ */
+
+const core = require('soajs.core.modules');
+const Mongo = core.mongo;
+
+const throttling_monitor = 'throttling_monitor';
+const throttling_error = 'throttling_error';
+
+let model = {
+    'mongo': null,
+    'log': null,
+
+    'initThrottling': (log, dbConfiguration) => {
+        model.log = log;
+        if (!model.mongo) {
+            model.mongo = new Mongo(dbConfiguration);
+        }
+    },
+
+    'getThrottling': async (throttling, trafficKey) => {
+
+        let condition = {
+            'l1': trafficKey.l1
+        };
+        if (throttling.type === 1) {
+            condition.l2 = trafficKey.l2;
+        } else {
+            condition.l2 = '_ALL_';
+        }
+        let throttlingObj = null;
+        try {
+            throttlingObj = await model.mongo.findOne(throttling_monitor, condition);
+            if (!throttlingObj) {
+                throttlingObj = await model.resetThrottling(throttling, trafficKey);
+            }
+        } catch (e) {
+            model.log.error('Throttling:', e.message);
+            throttlingObj = {
+                'firstReqTime': new Date(Date.now()),
+                'count': 0
+            };
+        }
+        return throttlingObj;
+    },
+
+    'resetThrottling': async (throttling, trafficKey) => {
+        let options = {
+            'upsert': true
+        };
+        let condition = {
+            'l1': trafficKey.l1
+        };
+        if (throttling.type === 1) {
+            condition.l2 = trafficKey.l2;
+        } else {
+            condition.l2 = '_ALL_';
+        }
+        let throttlingObj = {
+            'firstReqTime': new Date(Date.now()),
+            'count': 0
+        };
+        let s = {
+            '$set': throttlingObj
+        };
+        try {
+            await model.mongo.updateOne(throttling_monitor, condition, s, options);
+        } catch (e) {
+            model.log.error('Throttling:', e.message);
+        }
+        return throttlingObj;
+    },
+
+    'incrementThrottling': async (throttling, trafficKey) => {
+        let options = {
+        };
+        let condition = {
+            'l1': trafficKey.l1
+        };
+        if (throttling.type === 1) {
+            condition.l2 = trafficKey.l2;
+        } else {
+            condition.l2 = '_ALL_';
+        }
+        let s = {
+            '$inc': { 'count': 1 }
+        };
+        try {
+            await model.mongo.updateOne(throttling_monitor, condition, s, options);
+        } catch (e) {
+            model.log.error('Throttling:', e.message);
+        }
+    },
+
+    'logTooManyRequests': (trafficKey, strategy) => {
+        let s = {
+            "staregy": strategy,
+            "l1": trafficKey.l1,
+            "l2": trafficKey.l2,
+            "ts": new Date(Date.now())
+        };
+        model.mongo.insertOne(throttling_error, s, {}, () => {
+        });
+    }
+};
+
+
+module.exports = model;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "soajs.controller",
   "description": "soajs multi tenant API gateway",
-  "version": "4.2.4",
+  "version": "4.2.5",
   "author": {
     "name": "soajs team",
     "email": "team@soajs.org"
@@ -35,17 +35,21 @@
     "useragent": "2.3.0"
   },
   "devDependencies": {
+    "@babel/core": "^7.22.5",
+    "@babel/plugin-transform-runtime": "7.19.6",
+    "@babel/preset-env": "7.20.2",
     "express": "4.18.2",
-    "grunt": "1.0.4",
-    "grunt-contrib-clean": "2.0.0",
+    "grunt": "1.5.3",
+    "grunt-babel": "8.0.0",
+    "grunt-contrib-clean": "2.0.1",
     "grunt-contrib-copy": "1.0.0",
-    "grunt-contrib-jshint": "2.1.0",
+    "grunt-contrib-jshint": "3.2.0",
     "grunt-coveralls": "2.0.0",
     "grunt-env": "1.0.1",
     "grunt-istanbul": "0.8.0",
     "grunt-jsdoc": "2.4.0",
     "grunt-mocha-test": "0.13.3",
-    "mocha": "6.2.1",
+    "mocha": "10.2.0",
     "sinon": "7.5.0"
   }
 }

package/server/controller.js

@@ -41,7 +41,7 @@ const traffic_mw = require("../mw/traffic/index");
 const utils = require("../utilities/utils");
 
 let autoRegHost = process.env.SOAJS_SRV_AUTOREGISTERHOST || true;
-if (autoRegHost && typeof(autoRegHost) !== 'boolean') {
+if (autoRegHost && typeof (autoRegHost) !== 'boolean') {
 	autoRegHost = (autoRegHost === 'true');
 }
 let regEnvironment = (process.env.SOAJS_ENV || "dev");
@@ -49,10 +49,10 @@ regEnvironment = regEnvironment.toLowerCase();
 
 function Controller(config) {
 	let _self = this;
-	
+
 	config = config || {};
 	let param = lib.param(config);
-	_self.soajs = {"param": param};
+	_self.soajs = { "param": param };
 }
 
 Controller.prototype.init = function (callback) {
@@ -77,7 +77,7 @@ Controller.prototype.init = function (callback) {
 					log.info("The IP registered for service [" + _self.soajs.param.init.serviceName + "] awareness : ", service.fetched.ip);
 				}
 			}
-			
+
 			let app = connect();
 			app.use(favicon_mw());
 			app.use(soajs_mw({
@@ -85,9 +85,9 @@ Controller.prototype.init = function (callback) {
 				"core": core
 			}));
 			app.use(cors_mw());
-			app.use(response_mw({"controllerResponse": true}));
+			app.use(response_mw({ "controllerResponse": true }));
 			app.use(maintenanceMode_mw()); //NOTE: this is for global maintenance mode
-			
+
 			log.info("Loading Provision ...");
 			let dbConfig = registry.coreDB.provision;
 			if (registry.coreDB.oauth) {
@@ -101,11 +101,11 @@ Controller.prototype.init = function (callback) {
 				if (loaded) {
 					log.info("Service provision loaded.");
 					let server = http.createServer(app);
-					
+
 					// Create maintenance routes
 					let maintenance = require("./maintenance.js");
 					let serverMaintenance = maintenance(core, log, _self.soajs.param.init, service.ip, regEnvironment, awareness_mw, soajsLib, provision);
-					
+
 					// Add gateway middleware
 					app.use(awareness_mw.getMw({
 						"awareness": _self.soajs.param.init.awareness,
@@ -116,7 +116,7 @@ Controller.prototype.init = function (callback) {
 						"serviceIp": service.ip
 					}));
 					log.info("Awareness middleware initialization done.");
-					
+
 					//added mw awarenessEnv so that proxy can use req.soajs.awarenessEnv.getHost('dev', cb)
 					app.use(awarenessEnv_mw.getMw({
 						"awarenessEnv": true,
@@ -126,17 +126,17 @@ Controller.prototype.init = function (callback) {
 						"log": log
 					}));
 					log.info("AwarenessEnv middleware initialization done.");
-					
+
 					app.use(enhancer_mw());
-					
-					app.use(url_mw({"core": core}));
-					
-					app.use(key_mw({"provision": provision, "regEnvironment": regEnvironment}));
-					
+
+					app.use(url_mw({ "core": core }));
+
+					app.use(key_mw({ "provision": provision, "regEnvironment": regEnvironment }));
+
 					//TODO: add maintenance by tenant here req.soajs.controller.serviceParams.keyObj.config
 
 					app.use(keyACL_mw());
-					
+
 					app.use(gotoService_mw({
 						"provision": provision,
 						"serviceName": _self.soajs.param.init.serviceName,
@@ -144,7 +144,7 @@ Controller.prototype.init = function (callback) {
 						"serviceGroup": _self.soajs.param.init.serviceGroup,
 						"core": core
 					}));
-					
+
 					if (registry.serviceConfig.oauth) {
 						let oauth_mw = require("../mw/oauth/index");
 						// NOTE: oauth_mw is set on soajs.oauth and is triggered from inside mt_mw
@@ -153,10 +153,10 @@ Controller.prototype.init = function (callback) {
 							"serviceConfig": registry.serviceConfig,
 							"model": provision.oauthModel
 						});
-						
+
 						log.info("oAuth middleware initialization done.");
 					}
-					
+
 					app.use(mt_mw({
 						"soajs": _self.soajs,
 						"app": app,
@@ -166,14 +166,17 @@ Controller.prototype.init = function (callback) {
 						"provision": provision
 					}));
 					log.info("SOAJS MT middleware initialization done.");
-					
-					app.use(traffic_mw({}));
-					
+
+					app.use(traffic_mw({
+						"log": log,
+						"gatewayDB": registry.coreDB.gateway || registry.coreDB.provision
+					}));
+
 					app.use((req, res, next) => {
 						setImmediate(() => {
 							req.soajs.controller.gotoservice(req, res, next);
 						});
-						
+
 						req.on("error", (error) => {
 							req.soajs.log.error("Error @ controller:", error);
 							if (req.soajs.controller.redirectedRequest) {
@@ -181,7 +184,7 @@ Controller.prototype.init = function (callback) {
 								req.soajs.controller.redirectedRequest = null;
 							}
 						});
-						
+
 						req.on("close", () => {
 							if (req.soajs.controller.redirectedRequest) {
 								req.soajs.log.info("Request closed:", req.url);
@@ -190,11 +193,11 @@ Controller.prototype.init = function (callback) {
 							}
 						});
 					});
-					
+
 					app.use(utils.logErrors);
 					app.use(utils.controllerClientErrorHandler);
 					app.use(utils.controllerErrorHandler);
-					
+
 					callback(registry, log, service, server, serverMaintenance);
 				} else {
 					log.error('Unable to load provision. controller will not start :(');
@@ -217,13 +220,13 @@ Controller.prototype.start = function (registry, log, service, server, serverMai
 				log.error(err.message);
 			}
 		});
-		
+
 		let getAwarenessInfo = (terminate, cb) => {
 			let tmp = registryModule.get();
 			if (tmp && (tmp.services || tmp.daemons)) {
 				let awarenessStatData = {
 					"ts": Date.now(),
-					"data": soajsUtils.cloneObj({"services": tmp.services, "daemons": tmp.daemons})
+					"data": soajsUtils.cloneObj({ "services": tmp.services, "daemons": tmp.daemons })
 				};
 				if (terminate) {
 					for (let serviceName in awarenessStatData.data.services) {
@@ -252,7 +255,7 @@ Controller.prototype.start = function (registry, log, service, server, serverMai
 				}, cb);
 			}
 		};
-		
+
 		server.listen(registry.services.controller.port, (err) => {
 			if (err) {
 				log.error(err.message);
@@ -268,7 +271,7 @@ Controller.prototype.start = function (registry, log, service, server, serverMai
 					}, registry, (registered) => {
 						if (registered) {
 							log.info("Host IP [" + service.ip + "] for service [" + _self.soajs.param.init.serviceName + "@" + _self.soajs.param.init.serviceVersion + "] successfully registered.");
-							
+
 							//update the database with the awareness Response generated.
 							setTimeout(() => {
 								getAwarenessInfo(false, (error) => {
@@ -277,7 +280,7 @@ Controller.prototype.start = function (registry, log, service, server, serverMai
 									}
 								});
 							}, registry.serviceConfig.awareness.healthCheckInterval);
-							
+
 							//update the database with the awareness Response generated.
 							//controller has been terminated.
 							process.on('SIGINT', () => {
@@ -313,7 +316,7 @@ Controller.prototype.start = function (registry, log, service, server, serverMai
 				log.info(_self.soajs.param.init.serviceName + " service maintenance is listening on port: " + maintenancePort);
 			}
 		});
-		
+
 	}
 };
 
@@ -321,7 +324,7 @@ Controller.prototype.stop = function (registry, log, service, server, serverMain
 	let maintenancePort = registry.services.controller.port + registry.serviceConfig.ports.maintenanceInc;
 	log.info('stopping Server on port:', registry.services.controller.port);
 	log.info('stopping MaintenanceServer on port:', maintenancePort);
-	
+
 	server.close((err) => {
 		serverMaintenance.close(() => {
 			if (callback) {

package/test/unit/mw/traffic/index.js

@@ -9,6 +9,9 @@ describe("Unit test for: mw - traffic", () => {
     it("success - default from environment", (done) => {
         let res = {};
         let req = {
+            getClientIP: () => {
+                return "127.0.0.1"
+            },
             soajs: {
                 registry: {
                     serviceConfig: {