cloudcms-server 3.2.287 → 3.2.289

package/index.js

@@ -48,6 +48,13 @@ if (process.env.DEFAULT_HTTP_TIMEOUT_MS)
     }
 }
 
+// dns fix for Node 17 +
+// see: https://nodejs.org/api/dns.html#dnssetdefaultresultorderorder
+var dns = require("dns");
+if (typeof(dns.setDefaultResultOrder) !== "undefined") {
+    dns.setDefaultResultOrder("ipv4first");
+}
+
 // default agents
 var HttpKeepAliveAgent = require('agentkeepalive');
 var HttpsKeepAliveAgent = require('agentkeepalive').HttpsAgent;

package/package.json

@@ -1,12 +1,12 @@
 {
   "author": {
     "name": "Gitana Software, Inc.",
-    "email": "info@cloudcms.com",
-    "url": "https://www.cloudcms.com"
+    "email": "info@gitana.io",
+    "url": "https://gitana.io"
   },
   "name": "cloudcms-server",
   "description": "Cloud CMS Application Server Module",
-  "version": "3.2.287",
+  "version": "3.2.289",
   "repository": {
     "type": "git",
     "url": "git://github.com/gitana/cloudcms-server.git"
@@ -40,12 +40,12 @@
     "express-session": "^1.17.3",
     "express-useragent": "^1.0.15",
     "extend-with-super": "^2.0.0",
+    "fast-proxy": "^2.2.0",
     "finalhandler": "^1.2.0",
     "gitana": "^1.0.322",
     "handlebars": "^4.4.2",
     "hbs": "^4.0.5",
     "helmet": "^4.6.0",
-    "http2-proxy": "^5.0.53",
     "ioredis": "4.28.5",
     "json5": "^1.0.1",
     "jsonwebtoken": "^8.5.1",

package/util/auth.js

@@ -327,23 +327,29 @@ var syncProfile = exports.syncProfile = function(req, res, strategy, domainId, p
                 }
 
                 _LOCK([CACHE_IDENTIFIER], function(err, releaseLockFn) {
+                    
+                    if (err) {
+                        try { releaseLockFn(); } catch (e) { }
+                        return callback(err);
+                    }
+                    
                     _handleSyncUser(req, strategy, settings, key, domainId, providerId, providerUserId, token, refreshToken, userObject, groupsArray, function (err, gitanaUser) {
 
                         if (err) {
-                            releaseLockFn();
+                            try { releaseLockFn(); } catch (e) { }
                             return callback(err);
                         }
 
                         // no user found
                         if (!gitanaUser) {
-                            releaseLockFn();
+                            try { releaseLockFn(); } catch (e) { }
                             return callback();
                         }
 
                         _handleConnectAsUser(req, key, gitanaUser, function (err, platform, appHelper, key) {
 
                             if (err) {
-                                releaseLockFn();
+                                try { releaseLockFn(); } catch (e) { }
                                 return callback(err);
                             }
 
@@ -354,8 +360,8 @@ var syncProfile = exports.syncProfile = function(req, res, strategy, domainId, p
                                 "appHelper": appHelper,
                                 "key": key
                             });
-
-                            releaseLockFn();
+    
+                            try { releaseLockFn(); } catch (e) { }
 
                             callback(err, gitanaUser, platform, appHelper, key, platform.getDriver());
                         }, gitanaUser);

package/util/proxy-factory.http2-proxy.js

@@ -0,0 +1,281 @@
+var http = require("http");
+var https = require("https");
+var path = require("path");
+
+var auth = require("./auth");
+var util = require("./util");
+
+var oauth2 = require("./oauth2")();
+
+var urlTool = require("url");
+const finalhandler = require("finalhandler");
+
+var LRU = require("lru-cache");
+
+var exports = module.exports;
+
+var _LOCK = function(lockIdentifiers, workFunction)
+{
+    var name = lockIdentifiers.join("_");
+    process.locks.lock(name, workFunction);
+};
+
+var NAMED_PROXY_HANDLERS_CACHE = new LRU({
+    max: 200,
+    ttl: 1000 * 60 * 60 // 60 minutes
+});
+
+var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pathPrefix, callback)
+{
+    var name = path.join(proxyTarget, (pathPrefix || "/"));
+
+    // is it already in LRU cache?
+    // if so hand it back
+    var _cachedHandler = NAMED_PROXY_HANDLERS_CACHE[name];
+    if (_cachedHandler)
+    {
+        return callback(null, _cachedHandler);
+    }
+    
+    // take out a thread lock
+    _LOCK(["acquireProxyHandler", name], function(err, releaseLockFn) {
+        
+        if (err)
+        {
+            console.log("Failed to acquire proxy handler: " + name + ", err: ", err);
+            
+            // failed to acquire lock
+            return callback(err);
+        }
+
+        // second check to make sure another thread didn't create the handler in the meantime
+        _cachedHandler = NAMED_PROXY_HANDLERS_CACHE[name];
+        if (_cachedHandler)
+        {
+            releaseLockFn();
+            return callback(null, _cachedHandler);
+        }
+
+        // create the proxy handler and cache it into LRU cache
+        //console.log("Acquiring proxy handler: " + name + ", for target: " + proxyTarget + " and prefix: " + pathPrefix);
+        _cachedHandler = createProxyHandler(proxyTarget, pathPrefix);
+    
+        // store back into LRU cache
+        NAMED_PROXY_HANDLERS_CACHE[name] = _cachedHandler;
+
+        releaseLockFn();
+        callback(null, _cachedHandler);
+    });
+};
+
+
+
+
+var createProxyHandler = function(proxyTarget, pathPrefix)
+{
+    const proxy = require("http2-proxy");
+    const finalhandler = require('finalhandler')
+    
+    const defaultWebHandler = function(err, req, res) {
+        if (err)
+        {
+            console.log("A web proxy error was caught, path: " + req.path + ", err: ", err);
+            try { res.status(500); } catch (e) { }
+            try { res.end('Something went wrong while proxying the request.'); } catch (e) { }
+        }
+    
+        finalhandler(req, res)(err);
+    };
+    
+    // const defaultWsHandler = function(err, req, socket, head) {
+    //     if (err) {
+    //         console.error('proxy error (ws)', err);
+    //         socket.destroy();
+    //     }
+    // };
+    
+    //console.log("Proxy Target: " + proxyTarget);
+    
+    var hostname = urlTool.parse(proxyTarget).hostname;
+    var port = urlTool.parse(proxyTarget).port;
+    var protocol = urlTool.parse(proxyTarget).protocol;
+    
+    // web
+    var webConfig = {};
+    webConfig.hostname = hostname;
+    webConfig.port = port;
+    webConfig.protocol = protocol;
+    //webConfig.path = null;
+    webConfig.timeout = 120000;
+    webConfig.proxyTimeout = 120000;
+    webConfig.proxyName = "Cloud CMS UI Proxy";
+    webConfig.onReq = function(req, options) {
+
+        if (!options.headers) {
+            options.headers = {};
+        }
+        var headers = options.headers;
+
+        if (options.path && options.path.startsWith("/proxy")) {
+            options.path = options.path.substring(6);
+        }
+    
+        if (pathPrefix) {
+            options.path = path.join(pathPrefix, options.path);
+        }
+        
+        // used to auto-assign the client header for /oauth/token requests
+        oauth2.autoProxy(req);
+    
+        // copy domain host into "x-cloudcms-domainhost"
+        if (req.domainHost) {
+            headers["x-cloudcms-domainhost"] = req.domainHost; // this could be "localhost"
+        }
+    
+        // copy virtual host into "x-cloudcms-virtualhost"
+        if (req.virtualHost) {
+            headers["x-cloudcms-virtualhost"] = req.virtualHost; // this could be "root.cloudcms.net" or "abc.cloudcms.net"
+        }
+    
+        // copy deployment descriptor info
+        if (req.descriptor)
+        {
+            if (req.descriptor.tenant)
+            {
+                if (req.descriptor.tenant.id)
+                {
+                    headers["x-cloudcms-tenant-id"] = req.descriptor.tenant.id;
+                }
+            
+                if (req.descriptor.tenant.title)
+                {
+                    headers["x-cloudcms-tenant-title"] = req.descriptor.tenant.title;
+                }
+            }
+        
+            if (req.descriptor.application)
+            {
+                if (req.descriptor.application.id)
+                {
+                    headers["x-cloudcms-application-id"] = req.descriptor.application.id;
+                }
+            
+                if (req.descriptor.application.title)
+                {
+                    headers["x-cloudcms-application-title"] = req.descriptor.application.title;
+                }
+            }
+        }
+    
+        // set optional "x-cloudcms-origin" header
+        var cloudcmsOrigin = null;
+        if (req.virtualHost)
+        {
+            cloudcmsOrigin = req.virtualHost;
+        }
+        if (cloudcmsOrigin)
+        {
+            headers["x-cloudcms-origin"] = cloudcmsOrigin;
+        }
+    
+        // set x-cloudcms-server-version header
+        headers["x-cloudcms-server-version"] = process.env.CLOUDCMS_APPSERVER_PACKAGE_VERSION;
+    
+        // keep alive
+        //req.headers["connection"] = "keep-alive";
+    
+        // if the incoming request didn't have an "Authorization" header
+        // and we have a logged in Gitana User via Auth, then set authorization header to Bearer Access Token
+        if (!req.headers["authorization"])
+        {
+            if (req.gitana_user)
+            {
+                headers["authorization"] = "Bearer " + req.gitana_user.getDriver().http.accessToken();
+            }
+            else if (req.gitana_proxy_access_token)
+            {
+                headers["authorization"] = "Bearer " + req.gitana_proxy_access_token;
+            }
+        }
+    };
+    webConfig.onRes = function(req, res, proxyRes) {
+    
+        if (req.gitana_user)
+        {
+            var chunks = [];
+            
+            // triggers on data receive
+            proxyRes.on('data', function(chunk) {
+                // add received chunk to chunks array
+                chunks.push(chunk);
+            });
+
+            proxyRes.on("end", function () {
+
+                if (proxyRes.statusCode === 401)
+                {
+                    var text = "" + Buffer.concat(chunks);
+                    if (text && (text.indexOf("invalid_token") > -1) || (text.indexOf("invalid_grant") > -1))
+                    {
+                        var identifier = req.identity_properties.provider_id + "/" + req.identity_properties.user_identifier;
+
+                        _LOCK([identifier], function(err, releaseLockFn) {
+
+                            if (err)
+                            {
+                                // failed to acquire lock
+                                console.log("FAILED TO ACQUIRE LOCK", err);
+                                req.log("FAILED TO ACQUIRE LOCK", err);
+                                try { releaseLockFn(); } catch (e) { }
+                                return;
+                            }
+
+                            var cleanup = function (full)
+                            {
+                                delete Gitana.APPS[req.identity_properties.token];
+                                delete Gitana.PLATFORM_CACHE[req.identity_properties.token];
+
+                                if (full) {
+                                    auth.removeUserCacheEntry(identifier);
+                                }
+                            };
+
+                            // null out the access token
+                            // this will force the refresh token to be used to get a new one on the next request
+                            req.gitana_user.getDriver().http.refresh(function (err) {
+
+                                if (err) {
+                                    cleanup(true);
+                                    req.log("Invalidated auth state for gitana user: " + req.identity_properties.token);
+                                    return releaseLockFn();
+                                }
+
+                                req.gitana_user.getDriver().reloadAuthInfo(function () {
+                                    cleanup(true);
+                                    req.log("Refreshed token for gitana user: " + req.identity_properties.token);
+                                    releaseLockFn();
+                                });
+                            });
+                        });
+                    }
+
+                }
+            });
+        }
+        
+        //res.setHeader('x-powered-by', 'cloudcms');
+        res.writeHead(proxyRes.statusCode, proxyRes.headers)
+        proxyRes.pipe(res)
+    };
+    
+    var proxyRequestHandler = function(req, res) {
+        proxy.web(req, res, webConfig, function(err, req, res) {
+            defaultWebHandler(err, req, res);
+        });
+    };
+    
+    // cookie domain rewrite?
+    // not needed - this is handled intrinsically by http2-proxy
+
+    return proxyRequestHandler;
+};

package/util/proxy-factory.js

@@ -1,15 +1,12 @@
-var http = require("http");
-var https = require("https");
+// var http = require("http");
+// var https = require("https");
 var path = require("path");
 
 var auth = require("./auth");
-var util = require("./util");
+// var util = require("./util");
 
 var oauth2 = require("./oauth2")();
 
-var urlTool = require("url");
-const finalhandler = require("finalhandler");
-
 var LRU = require("lru-cache");
 
 var exports = module.exports;
@@ -73,59 +70,95 @@ var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pa
 
 var createProxyHandler = function(proxyTarget, pathPrefix)
 {
-    const proxy = require("http2-proxy");
-    const finalhandler = require('finalhandler')
+    const { proxy, close } = require('fast-proxy')({
+        base: proxyTarget,
+        cacheURLs: 0,
+        http2: true,
+        //undici: true
+    });
     
-    const defaultWebHandler = function(err, req, res) {
-        if (err)
+    var proxyOptions = {};
+    proxyOptions.onResponse = function(req, res, stream) {
+        
+        if (req.gitana_user)
         {
-            console.log("A web proxy error was caught, path: " + req.path + ", err: ", err);
-            try { res.status(500); } catch (e) { }
-            try { res.end('Something went wrong while proxying the request.'); } catch (e) { }
-        }
-    
-        finalhandler(req, res)(err);
-    };
-    
-    // const defaultWsHandler = function(err, req, socket, head) {
-    //     if (err) {
-    //         console.error('proxy error (ws)', err);
-    //         socket.destroy();
-    //     }
-    // };
-    
-    //console.log("Proxy Target: " + proxyTarget);
-    
-    var hostname = urlTool.parse(proxyTarget).hostname;
-    var port = urlTool.parse(proxyTarget).port;
-    var protocol = urlTool.parse(proxyTarget).protocol;
+            var chunks = [];
+        
+            // triggers on data receive
+            stream.on('data', function(chunk) {
+                console.log("DATA!");
+                // add received chunk to chunks array
+                chunks.push(chunk);
+            });
     
-    // web
-    var webConfig = {};
-    webConfig.hostname = hostname;
-    webConfig.port = port;
-    webConfig.protocol = protocol;
-    //webConfig.path = null;
-    webConfig.timeout = 120000;
-    webConfig.proxyTimeout = 120000;
-    webConfig.proxyName = "Cloud CMS UI Proxy";
-    webConfig.onReq = function(req, options) {
-
-        if (!options.headers) {
-            options.headers = {};
-        }
-        var headers = options.headers;
-
-        if (options.path && options.path.startsWith("/proxy")) {
-            options.path = options.path.substring(6);
+            stream.on("end", function () {
+                
+                if (stream.statusCode === 401)
+                {
+                    var text = "" + Buffer.concat(chunks);
+                    if (text && (text.indexOf("invalid_token") > -1) || (text.indexOf("invalid_grant") > -1))
+                    {
+                        var identifier = req.identity_properties.provider_id + "/" + req.identity_properties.user_identifier;
+                    
+                        _LOCK([identifier], function(err, releaseLockFn) {
+                        
+                            if (err)
+                            {
+                                // failed to acquire lock
+                                console.log("FAILED TO ACQUIRE LOCK", err);
+                                req.log("FAILED TO ACQUIRE LOCK", err);
+                                try { releaseLockFn(); } catch (e) { }
+                                return;
+                            }
+                        
+                            var cleanup = function (full)
+                            {
+                                delete Gitana.APPS[req.identity_properties.token];
+                                delete Gitana.PLATFORM_CACHE[req.identity_properties.token];
+                            
+                                if (full) {
+                                    auth.removeUserCacheEntry(identifier);
+                                }
+                            };
+                        
+                            // null out the access token
+                            // this will force the refresh token to be used to get a new one on the next request
+                            req.gitana_user.getDriver().http.refresh(function (err) {
+                            
+                                if (err) {
+                                    cleanup(true);
+                                    req.log("Invalidated auth state for gitana user: " + req.identity_properties.token);
+                                    return releaseLockFn();
+                                }
+                            
+                                req.gitana_user.getDriver().reloadAuthInfo(function () {
+                                    cleanup(true);
+                                    req.log("Refreshed token for gitana user: " + req.identity_properties.token);
+                                    releaseLockFn();
+                                });
+                            });
+                        });
+                    }
+                
+                }
+            });
         }
     
-        if (pathPrefix) {
-            options.path = path.join(pathPrefix, options.path);
+        //res.setHeader('x-powered-by', 'cloudcms');
+        if (stream.statusCode && stream.headers) {
+            res.writeHead(stream.statusCode, stream.headers)
         }
         
+        stream.pipe(res)
+    };
+    proxyOptions.rewriteRequestHeaders = function(req, headers)
+    {
         // used to auto-assign the client header for /oauth/token requests
         oauth2.autoProxy(req);
+        if (req.headers && req.headers.authorization)
+        {
+            headers["authorization"] = req.headers.authorization;
+        }
     
         // copy domain host into "x-cloudcms-domainhost"
         if (req.domainHost) {
@@ -197,85 +230,21 @@ var createProxyHandler = function(proxyTarget, pathPrefix)
                 headers["authorization"] = "Bearer " + req.gitana_proxy_access_token;
             }
         }
-    };
-    webConfig.onRes = function(req, res, proxyRes) {
-    
-        if (req.gitana_user)
-        {
-            var chunks = [];
-            
-            // triggers on data receive
-            proxyRes.on('data', function(chunk) {
-                // add received chunk to chunks array
-                chunks.push(chunk);
-            });
-
-            proxyRes.on("end", function () {
-
-                if (proxyRes.statusCode === 401)
-                {
-                    var text = "" + Buffer.concat(chunks);
-                    if (text && (text.indexOf("invalid_token") > -1) || (text.indexOf("invalid_grant") > -1))
-                    {
-                        var identifier = req.identity_properties.provider_id + "/" + req.identity_properties.user_identifier;
-
-                        _LOCK([identifier], function(err, releaseLockFn) {
-
-                            if (err)
-                            {
-                                // failed to acquire lock
-                                console.log("FAILED TO ACQUIRE LOCK", err);
-                                req.log("FAILED TO ACQUIRE LOCK", err);
-                                try { releaseLockFn(); } catch (e) { }
-                                return;
-                            }
-
-                            var cleanup = function (full)
-                            {
-                                delete Gitana.APPS[req.identity_properties.token];
-                                delete Gitana.PLATFORM_CACHE[req.identity_properties.token];
-
-                                if (full) {
-                                    auth.removeUserCacheEntry(identifier);
-                                }
-                            };
-
-                            // null out the access token
-                            // this will force the refresh token to be used to get a new one on the next request
-                            req.gitana_user.getDriver().http.refresh(function (err) {
-
-                                if (err) {
-                                    cleanup(true);
-                                    req.log("Invalidated auth state for gitana user: " + req.identity_properties.token);
-                                    return releaseLockFn();
-                                }
-
-                                req.gitana_user.getDriver().reloadAuthInfo(function () {
-                                    cleanup(true);
-                                    req.log("Refreshed token for gitana user: " + req.identity_properties.token);
-                                    releaseLockFn();
-                                });
-                            });
-                        });
-                    }
-
-                }
-            });
-        }
         
-        //res.setHeader('x-powered-by', 'cloudcms');
-        res.writeHead(proxyRes.statusCode, proxyRes.headers)
-        proxyRes.pipe(res)
+        return headers;
+    };
+    // rewrite response headers
+    proxyOptions.rewriteHeaders = function(headers)
+    {
+        return headers;
     };
     
+    //////////////////////////////////////////////////////////////////////////
+    
     var proxyRequestHandler = function(req, res) {
-        proxy.web(req, res, webConfig, function(err, req, res) {
-            defaultWebHandler(err, req, res);
-        });
+        
+        proxy(req, res, pathPrefix, proxyOptions);
     };
     
-    // cookie domain rewrite?
-    // not needed - this is handled intrinsically by http2-proxy
-
     return proxyRequestHandler;
 };