soajs.controller 4.2.19 → 4.2.30

package/lib/http.js

@@ -19,7 +19,7 @@ const http = require('http');
  *
  * @returns {*}
  */
-http.IncomingMessage.prototype.getClientIP = function() {
+http.IncomingMessage.prototype.getClientIP = function () {
     let x_forwarded_for = this.get('x-forwarded-for') ? this.get('x-forwarded-for').split(',')[0] : '';
     let ip_address = this.get('x-real-ip') || x_forwarded_for || this.connection.remoteAddress;
 

package/lib/request.js

@@ -0,0 +1,381 @@
+"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 http = require('http');
+
+function checkStatus(uri) {
+    return new Promise((resolve, reject) => {
+        let onResponse = false;
+
+        const req = http.get(uri, (res) => {
+            if (res.statusCode === 200) {
+                onResponse = true;
+                resolve(res.statusCode === 200); // Resolve with true if 200, false otherwise
+            }
+            // res.on('data', () => { }); // Consume data to avoid issues (important!)
+
+            res.on('error', (err) => {
+                if (!onResponse) {
+                    onResponse = true;
+                    return reject(err);
+                }
+            });
+            res.on('close', () => {
+                if (!onResponse) {
+                    onResponse = true;
+                    return reject(new Error("Closed"));
+                }
+            });
+        });
+
+        req.on('error', (err) => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(err);
+            }
+        });
+        req.on('close', () => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(new Error("Closed"));
+            }
+        });
+
+
+        req.end();
+    });
+}
+
+function httpRequestLight({ uri, data = null, method = 'GET', headers = null, json = true }) {
+    return new Promise((resolve, reject) => {
+        let onResponse = false;
+        let options = {};
+        const requestDataString = data ? (json ? JSON.stringify(data) : data.toString()) : '';
+
+        try {
+            const urlObj = new URL(uri);
+            options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port,
+                path: urlObj.pathname + urlObj.search,
+                method: method.toUpperCase(), // Ensure method is uppercase
+                headers: {
+                    'Content-Type': json ? 'application/json' : 'application/x-www-form-urlencoded',
+                    'Content-Length': data ? Buffer.byteLength(requestDataString) : 0,
+                },
+            };
+            if (headers) {
+                for (const key in headers) {
+                    if (headers.hasOwnProperty(key)) {
+                        options.headers[key] = headers[key];
+                    }
+                }
+            }
+        } catch (error) {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(error); // Reject with error and null data for request errors
+            }
+        }
+        const req = http.request(options);
+
+        req.on('response', (res) => { // Listen for the 'response' event
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                return reject(new Error(`Status Code: ${res.statusCode}`));
+            }
+
+            let responseData = '';
+
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+
+            res.on('end', () => {
+
+                if (!onResponse) {
+                    onResponse = true;
+                    try {
+                        const parsedData = json ? JSON.parse(responseData) : responseData;
+                        return resolve(parsedData);
+                    } catch (error) {
+                        return resolve(responseData);
+                    }
+                }
+            });
+
+            res.on('error', (err) => {
+                if (!onResponse) {
+                    onResponse = true;
+                    return reject(err);
+                }
+            });
+            res.on('close', () => {
+                if (!onResponse) {
+                    onResponse = true;
+                    return reject(new Error("Closed"));
+                }
+            });
+        });
+
+        req.on('error', (err) => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(err);
+            }
+        });
+        req.on('close', () => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(new Error("Closed"));
+            }
+        });
+
+        if (data) {
+            req.write(requestDataString);
+        }
+
+        req.end();
+    });
+}
+
+function httpRequest({ uri, data = null, method = 'GET', headers = null, json = true }) {
+    return new Promise((resolve, reject) => {
+        let onResponse = false;
+        let options = {};
+
+        const requestDataString = data ? (json ? JSON.stringify(data) : data.toString()) : '';
+        try {
+            const urlObj = new URL(uri);
+
+            options = {
+                "hostname": urlObj.hostname,
+                "port": urlObj.port,
+                "path": urlObj.pathname + urlObj.search,
+                "method": method.toUpperCase(),
+                "headers": {
+                    'Content-Type': json ? 'application/json' : 'application/x-www-form-urlencoded',
+                    'Content-Length': data ? Buffer.byteLength(requestDataString) : 0,
+                },
+            };
+            if (headers) {
+                for (const key in headers) {
+                    if (headers.hasOwnProperty(key)) {
+                        options.headers[key] = headers[key];
+                    }
+                }
+            }
+        } catch (error) {
+            if (!onResponse) {
+                onResponse = true;
+                return reject({ error: error, body: null }); // Reject with error and null data for request errors
+            }
+        }
+        const req = http.request(options);
+
+        req.on('response', (res) => { // Listen for the 'response' event
+            let responseData = '';
+
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+
+            res.on('end', () => {
+                if (!onResponse) {
+                    onResponse = true;
+                    if (res.statusCode < 200 || res.statusCode >= 300) {
+                        const error = new Error(`Status Code: ${res.statusCode}`);
+                        try {
+                            const parsedData = json ? JSON.parse(responseData) : responseData;
+                            return reject({ error: error, body: parsedData }); // Reject with error and data
+                        } catch (parseError) {
+                            return reject({ error: error, body: responseData }); // Reject with error and raw data if parse fails
+                        }
+                    }
+
+                    try {
+                        const parsedData = json ? JSON.parse(responseData) : responseData;
+                        return resolve(parsedData);
+                    } catch (parseError) {
+                        return resolve(responseData);
+                    }
+                }
+            });
+
+            res.on('close', () => {
+                if (!onResponse) {
+                    onResponse = true;
+                    return reject({ error: new Error("Closed"), body: null }); // Reject with error and null data for request errors
+                }
+            });
+            res.on('error', (error) => {
+                if (!onResponse) {
+                    onResponse = true;
+                    return reject({ error: error, body: null }); // Reject with error and null data for request errors
+                }
+            });
+        });
+
+        req.on('close', () => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject({ error: new Error("Closed"), body: null }); // Reject with error and null data for request errors
+            }
+        });
+        req.on('error', (error) => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject({ error: error, body: null }); // Reject with error and null data for request errors
+            }
+        });
+
+        if (data) {
+            req.write(requestDataString);
+        }
+        req.end();
+    });
+}
+
+function proxyRequest(req, res, options, extraOptions = {}) {
+    return new Promise((resolve, reject) => {
+        let onResponse = false;
+
+        const proxyReq = http.request(options);
+        if (extraOptions && extraOptions.fetchProxReq) {
+            extraOptions.fetchProxReq(proxyReq);
+        }
+        proxyReq.on('response', (proxyRes) => {
+            if (extraOptions && extraOptions.resHeaders) {
+                extraOptions.resHeaders.forEach(x => {
+                    proxyRes.headers[x] = extraOptions.resHeaders[x];
+                });
+            }
+            res.writeHead(proxyRes.statusCode, proxyRes.headers); // Forward status code and headers
+            if (options.method !== 'HEAD') {
+
+                proxyRes.on('end', () => {
+                    if (!onResponse) {
+                        onResponse = true;
+                        return resolve(); // Resolve when the proxy response ends
+                    }
+                });
+
+                proxyRes.on('close', () => {
+                    if (!onResponse) {
+                        onResponse = true;
+                        return reject(new Error("Closed")); // Reject if the proxy response encounters an error
+                    }
+                });
+                proxyRes.on('error', (err) => {
+                    if (!onResponse) {
+                        onResponse = true;
+                        return reject(err); // Reject if the proxy response encounters an error
+                    }
+                });
+
+                proxyRes.pipe(res); // Pipe the proxy response to the original response
+            } else {
+                onResponse = true;
+                res.end(); // End response immediately for HEAD requests
+                return resolve();
+            }
+        });
+
+        req.pipe(proxyReq); // Pipe the original request to the proxy request
+
+        proxyReq.on('close', () => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(new Error("Closed")); // Reject if the proxy request encounters an error
+            }
+        });
+        proxyReq.on('error', (err) => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(err); // Reject if the proxy request encounters an error
+            }
+        });
+    });
+}
+
+function proxyRequestMonitor(req, res, options, extraOptions = {}) {
+    return new Promise((resolve, reject) => {
+        let onResponse = false;
+
+        const proxyReq = http.request(options);
+        if (extraOptions && extraOptions.fetchProxReq) {
+            extraOptions.fetchProxReq(proxyReq);
+        }
+        proxyReq.on('response', (proxyRes) => {
+            if (extraOptions && extraOptions.resHeaders) {
+                extraOptions.resHeaders.forEach(x => {
+                    proxyRes.headers[x] = extraOptions.resHeaders[x];
+                });
+            }
+            if (!res.headersSent) {
+                res.writeHead(proxyRes.statusCode, proxyRes.headers); // Forward status code and headers
+            }
+            let resContentType = proxyRes.headers['content-type'];
+
+            if (extraOptions && extraOptions.events && extraOptions.events.response) {
+                extraOptions.events.response(resContentType);
+            }
+
+            if (options.method !== 'HEAD') {
+                if (extraOptions && extraOptions.events && extraOptions.events.data) {
+                    proxyRes.on('data', (chunk) => {
+                        extraOptions.events.data(chunk);
+                    });
+                }
+                proxyRes.on('end', () => {
+                    if (!onResponse) {
+                        onResponse = true;
+                        return resolve(); // Resolve when the proxy response ends
+                    }
+                });
+
+                proxyRes.on('close', () => {
+                    if (!onResponse) {
+                        onResponse = true;
+                        return reject(new Error("Closed")); // Reject if the proxy response encounters an error
+                    }
+                });
+                proxyRes.on('error', (err) => {
+                    if (!onResponse) {
+                        onResponse = true;
+                        return reject(err); // Reject if the proxy response encounters an error
+                    }
+                });
+
+                proxyRes.pipe(res); // Pipe the proxy response to the original response
+            } else {
+                onResponse = true;
+                res.end(); // End response immediately for HEAD requests
+                return resolve();
+            }
+        });
+
+        req.pipe(proxyReq); // Pipe the original request to the proxy request
+
+        proxyReq.on('close', () => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(new Error("Closed")); // Reject if the proxy request encounters an error
+            }
+        });
+        proxyReq.on('error', (err) => {
+            if (!onResponse) {
+                onResponse = true;
+                return reject(err); // Reject if the proxy request encounters an error
+            }
+        });
+    });
+}
+
+module.exports = { checkStatus, httpRequestLight, httpRequest, proxyRequest, proxyRequestMonitor };

package/mw/awareness/custom.js

@@ -9,8 +9,8 @@
  */
 
 const registryModule = require("./../../modules/registry");
+const { checkStatus } = require("../../lib/request.js");
 
-const request = require('request');
 const async = require('async');
 
 let registry = null;
@@ -32,7 +32,7 @@ let awareness_healthCheck = function (core, log) {
 		for (let s in registry.services) {
 			if (Object.hasOwnProperty.call(registry.services, s)) {
 				if (!serviceAwarenessObj[s]) {
-					serviceAwarenessObj[s] = {"healthy": {}, "indexes": {}};
+					serviceAwarenessObj[s] = { "healthy": {}, "indexes": {} };
 				}
 				if (!serviceAwarenessObj[s].healthy) {
 					serviceAwarenessObj[s].healthy = {};
@@ -64,11 +64,11 @@ let awareness_healthCheck = function (core, log) {
 				}
 			}
 		}
-		
+
 		for (let s in registry.daemons) {
 			if (Object.hasOwnProperty.call(registry.daemons, s)) {
 				if (!serviceAwarenessObj[s]) {
-					serviceAwarenessObj[s] = {"healthy": {}, "indexes": {}};
+					serviceAwarenessObj[s] = { "healthy": {}, "indexes": {} };
 				}
 				if (!serviceAwarenessObj[s].healthy) {
 					serviceAwarenessObj[s].healthy = {};
@@ -103,24 +103,32 @@ let awareness_healthCheck = function (core, log) {
 	}
 	async.each(awarenessHosts.servicesArr,
 		function (sObj, callback) {
-			
+
 			let checkForHeartBeat = function (host, port, path, callback) {
-				request({
-					'uri': 'http://' + host + ':' + port + path
-				}, function (error, response) {
-					if (!error && response.statusCode === 200) {
-						callback(true);
-					} else {
-						callback(false);
-					}
+				checkStatus ('http://' + host + ':' + port + path)
+				.then (()=>{
+					callback(true);
+				})
+				.catch (()=>{
+					callback(false);
 				});
+
+				// request({
+				// 	'uri': 'http://' + host + ':' + port + path
+				// }, function (error, response) {
+				// 	if (!error && response.statusCode === 200) {
+				// 		callback(true);
+				// 	} else {
+				// 		callback(false);
+				// 	}
+				// });
 			};
-			
+
 			let nextStep = function (found) {
 				if (registry[sObj.what][sObj.name] && !registry[sObj.what][sObj.name].awarenessStats) {
 					registry[sObj.what][sObj.name].awarenessStats = {};
 				}
-				let statusObj = {"lastCheck": new Date().getTime(), "healthy": false, "version": sObj.version};
+				let statusObj = { "lastCheck": new Date().getTime(), "healthy": false, "version": sObj.version };
 				if (found) {
 					statusObj.healthy = true;
 					if (serviceAwarenessObj[sObj.name].healthy[sObj.version].indexOf(sObj.host) === -1) {
@@ -134,7 +142,7 @@ let awareness_healthCheck = function (core, log) {
 						statusObj.downSince = statusObj.lastCheck;
 						statusObj.downCount = 0;
 					}
-					
+
 					let stopLoggingAfter = registry.serviceConfig.awareness.maxLogCount;
 					if (statusObj.downCount <= stopLoggingAfter) {
 						log.warn("Self Awareness health check for service [" + sObj.name + "] for host [" + sObj.host + "] is NOT healthy");
@@ -148,13 +156,13 @@ let awareness_healthCheck = function (core, log) {
 						}
 					}
 				}
-				
+
 				if (registry[sObj.what][sObj.name] && registry[sObj.what][sObj.name].awarenessStats) {
 					registry[sObj.what][sObj.name].awarenessStats[sObj.host] = statusObj;
 				}
 				callback();
 			};
-			
+
 			if (registry.services[sObj.name] && registry.services[sObj.name].maintenance && registry.services[sObj.name].maintenance.readiness && registry.services[sObj.name].maintenance.port) {
 				let port = sObj.port;
 				let path = registry.services[sObj.name].maintenance.readiness;

package/mw/awareness/ha.js

@@ -24,7 +24,7 @@ let awarenessCache = {};
 
 let lib = {
 	"getInfraToken": (envCode, cb) => {
-		registryModule.loadByEnv({envCode: envCode}, (err, envRecord) => {
+		registryModule.loadByEnv({ envCode: envCode }, (err, envRecord) => {
 			if (err) {
 				return cb(err);
 			}
@@ -55,7 +55,7 @@ let lib = {
 			}
 		});
 	},
-	
+
 	"getHostFromCache": function (serviceName, version) {
 		if (awarenessCache[serviceName] &&
 			awarenessCache[serviceName][version] &&
@@ -63,10 +63,10 @@ let lib = {
 			param.log.debug('Got ' + serviceName + ' - ' + version + ' - ' + awarenessCache[serviceName][version].host + ' from awareness cache');
 			return awarenessCache[serviceName][version].host;
 		}
-		
+
 		return null;
 	},
-	
+
 	"getHostFromAPI": function (serviceName, version, cb) {
 		if (!version) {
 			lib.getInfraToken(regEnvironment, (error, configuration) => {
@@ -94,7 +94,7 @@ let lib = {
 		} else {
 			getHost(version);
 		}
-		
+
 		function getHost(version) {
 			lib.getInfraToken(regEnvironment, (error, configuration) => {
 				if (error) {
@@ -105,7 +105,7 @@ let lib = {
 				let options = null;
 				let input = {
 					"configuration": configuration,
-					"item": {"name": serviceName, "version": version, "env": regEnvironment}
+					"item": { "name": serviceName, "version": version, "env": regEnvironment }
 				};
 				param.infraModule.kubernetes.get.host(param, input, options, (error, host) => {
 					if (error) {
@@ -126,7 +126,7 @@ let lib = {
 			});
 		}
 	},
-	
+
 	"rebuildAwarenessCache": function () {
 		lib.getInfraToken(regEnvironment, (error, configuration) => {
 			if (error) {
@@ -155,11 +155,11 @@ let lib = {
 					if (oneService.metadata.labels && oneService.metadata.labels['soajs.service.version']) {
 						version = oneService.metadata.labels['soajs.service.version'];
 					}
-					
+
 					if (oneService.metadata.labels && oneService.metadata.labels['soajs.service.name']) {
 						serviceName = oneService.metadata.labels['soajs.service.name'];
 					}
-					
+
 					if (!serviceName) {
 						return callback();
 					}
@@ -177,7 +177,7 @@ let lib = {
 					awarenessCache = myCache;
 					param.log.debug("Awareness cache rebuilt successfully");
 					param.log.debug(JSON.stringify(awarenessCache));
-					
+
 					let cacheTTL = registryModule.get().serviceConfig.awareness.cacheTTL;
 					if (cacheTTL) {
 						if (timeout) {
@@ -197,7 +197,7 @@ let ha = {
 		param = _param;
 		lib.rebuildAwarenessCache();
 	},
-	
+
 	"getServiceHost": function () {
 		let env = regEnvironment;
 		let serviceName = param.serviceName, version = null, cb = arguments[arguments.length - 1];
@@ -206,20 +206,20 @@ let ha = {
 			case 2:
 				serviceName = arguments[0];
 				break;
-			
+
 			//controller, 1, cb
 			case 3:
 				serviceName = arguments[0];
 				version = arguments[1];
 				break;
-			
+
 			//controller, 1, dash, cb [dash is ignored]
 			case 4:
 				serviceName = arguments[0];
 				version = arguments[1];
 				break;
 		}
-		
+
 		if (serviceName === param.serviceName) {
 			if (process.env.SOAJS_DEPLOY_HA === 'kubernetes') {
 				serviceName += "-v" + param.serviceVersion + "-service";
@@ -239,16 +239,21 @@ let ha = {
 			if (hostname) {
 				return cb(hostname);
 			} else {
-				lib.getHostFromAPI(serviceName, version, cb);
+				if (process.env.SOAJS_DEPLOY_HA === 'kubernetes' && serviceName && version) {
+					serviceName += "-v" + version + "-service";
+					return cb(env + "-" + serviceName + "-v" + version + "-service");
+				} else {
+					lib.getHostFromAPI(serviceName, version, cb);
+				}
 			}
 		}
 	},
-	
+
 	"getLatestVersion": function (name, cb) {
 		if (!awarenessCache[name]) {
 			return cb(null);
 		}
-		
+
 		let serviceVersions = Object.keys(awarenessCache[name]);
 		if (serviceVersions.length === 0) {
 			return cb(null);
@@ -263,7 +268,7 @@ let ha = {
 			return cb(null);
 		}
 	},
-	
+
 	"getLatestVersionFromCluster": function (name, cb) {
 		lib.getInfraToken(regEnvironment, (error, configuration) => {
 			if (error) {