soajs.controller 4.2.20 → 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/awarenessEnv/custom.js

@@ -8,10 +8,10 @@
  * found in the LICENSE file at the root of this repository
  */
 
-const request = require('request');
 const async = require('async');
 
 const registryModule = require("./../../modules/registry");
+const { checkStatus } = require("../../lib/request.js");
 
 let gatewayServiceName = null;
 let regEnvironment = (process.env.SOAJS_ENV || "dev");
@@ -34,7 +34,7 @@ let fetchControllerHosts = function (core, log, next) {
 		setTimeout(() => {
 			fetchControllerHosts(core, log);
 		}, registry.serviceConfig.awareness.autoRelaodRegistry);
-		
+
 		if (next && typeof next === "function") {
 			next();
 		}
@@ -43,7 +43,7 @@ let fetchControllerHosts = function (core, log, next) {
 
 let awareness_healthCheck = function (core, log) {
 	registry = registryModule.get();
-	
+
 	let resume = () => {
 		if (controllerHosts && Array.isArray(controllerHosts) && controllerHosts.length > 0) {
 			let controllerPort = registry.services.controller.port;
@@ -53,7 +53,7 @@ let awareness_healthCheck = function (core, log) {
 						serviceAwarenessObj[sObj.env] = {};
 					}
 					if (!serviceAwarenessObj[sObj.env][sObj.name]) {
-						serviceAwarenessObj[sObj.env][sObj.name] = {"healthy": {}, "indexes": {}, "latest": 1};
+						serviceAwarenessObj[sObj.env][sObj.name] = { "healthy": {}, "indexes": {}, "latest": 1 };
 					}
 					if (!serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version]) {
 						serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version] = [];
@@ -61,17 +61,18 @@ let awareness_healthCheck = function (core, log) {
 					if (!serviceAwarenessObj[sObj.env][sObj.name].indexes[sObj.version]) {
 						serviceAwarenessObj[sObj.env][sObj.name].indexes[sObj.version] = 0;
 					}
-					request({
-						'uri': 'http://' + sObj.ip + ':' + (controllerPort + registry.serviceConfig.ports.maintenanceInc) + '/heartbeat'
-					}, function (error, response) {
-						if (serviceAwarenessObj[sObj.env][sObj.name].latest < sObj.version) {
-							serviceAwarenessObj[sObj.env][sObj.name].latest = sObj.version;
-						}
-						if (!error && response.statusCode === 200) {
+
+					if (serviceAwarenessObj[sObj.env][sObj.name].latest < sObj.version) {
+						serviceAwarenessObj[sObj.env][sObj.name].latest = sObj.version;
+					}
+					checkStatus('http://' + sObj.ip + ':' + (controllerPort + registry.serviceConfig.ports.maintenanceInc) + '/heartbeat')
+						.then(() => {
 							if (serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].indexOf(sObj.ip) === -1) {
 								serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].push(sObj.ip);
 							}
-						} else {
+							callback();
+						})
+						.catch(() => {
 							if (serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].indexOf(sObj.ip) !== -1) {
 								//TODO: if we guarantee uniqueness we will not need the for loop
 								for (let ii = 0; ii < serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].length; ii++) {
@@ -80,9 +81,30 @@ let awareness_healthCheck = function (core, log) {
 									}
 								}
 							}
-						}
-						callback();
-					});
+							callback();
+						});
+					// request({
+					// 	'uri': 'http://' + sObj.ip + ':' + (controllerPort + registry.serviceConfig.ports.maintenanceInc) + '/heartbeat'
+					// }, function (error, response) {
+					// 	if (serviceAwarenessObj[sObj.env][sObj.name].latest < sObj.version) {
+					// 		serviceAwarenessObj[sObj.env][sObj.name].latest = sObj.version;
+					// 	}
+					// 	if (!error && response.statusCode === 200) {
+					// 		if (serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].indexOf(sObj.ip) === -1) {
+					// 			serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].push(sObj.ip);
+					// 		}
+					// 	} else {
+					// 		if (serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].indexOf(sObj.ip) !== -1) {
+					// 			//TODO: if we guarantee uniqueness we will not need the for loop
+					// 			for (let ii = 0; ii < serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].length; ii++) {
+					// 				if (serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version][ii] === sObj.ip) {
+					// 					serviceAwarenessObj[sObj.env][sObj.name].healthy[sObj.version].splice(ii, 1);
+					// 				}
+					// 			}
+					// 		}
+					// 	}
+					// 	callback();
+					// });
 				}, function (err) {
 					if (err) {
 						log.warn('Unable to build awareness ENV structure for controllers: ' + err);
@@ -93,13 +115,13 @@ let awareness_healthCheck = function (core, log) {
 			awareness_healthCheck(core, log);
 		}, registry.serviceConfig.awareness.healthCheckInterval);
 	};
-	
+
 	if (timeLoaded !== registry.timeLoaded) {
 		fetchControllerHosts(core, log, resume);
 	} else {
 		resume();
 	}
-	
+
 	timeLoaded = registry.timeLoaded;
 };
 
@@ -123,7 +145,7 @@ function roundRobin() {
 			env = arguments[2];
 			break;
 	}
-	
+
 	env = env || regEnvironment;
 	s = gatewayServiceName;
 	if (env && s && serviceAwarenessObj[env] && serviceAwarenessObj[env][s] && serviceAwarenessObj[env][s].healthy) {