cloudcms-server 4.0.0-beta.2 → 4.0.0-beta.21

package/util/proxy-factory.js

@@ -1,15 +1,13 @@
-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");
-
-var LRUCache = require("lru-cache");
+var LRU = require("lru-cache");
 
 var exports = module.exports;
 
@@ -19,9 +17,9 @@ var _LOCK = function(lockIdentifiers, workFunction)
     process.locks.lock(name, workFunction);
 };
 
-var NAMED_PROXY_HANDLERS_CACHE = new LRUCache({
+var NAMED_PROXY_HANDLERS_CACHE = new LRU({
     max: 200,
-    maxAge: 1000 * 60 * 60 // 60 minutes
+    ttl: 1000 * 60 * 60 // 60 minutes
 });
 
 var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pathPrefix, callback)
@@ -35,36 +33,40 @@ var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pa
     {
         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);
-    });
+    // // 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);
+    // });
+
+    _cachedHandler = NAMED_PROXY_HANDLERS_CACHE[name] = createProxyHandler(proxyTarget, pathPrefix);
+
+    callback(null, _cachedHandler);
 };
 
 
@@ -72,70 +74,106 @@ var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pa
 
 var createProxyHandler = function(proxyTarget, pathPrefix)
 {
-    const proxy = require("http2-proxy");
-    const finalhandler = require('finalhandler')
-    
-    const defaultWebHandler = function(err, req, res) {
-        if (err)
+    const { proxy, close } = require('fast-proxy')({
+        base: proxyTarget,
+        cacheURLs: 0,
+        //http2: true,
+        //undici: true
+    });
+
+    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;
-    
-    // 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;
+            var chunks = [];
+
+            // triggers on data receive
+            stream.on('data', function(chunk) {
+                console.log("DATA!");
+                // add received chunk to chunks array
+                chunks.push(chunk);
+            });
+
+            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();
+                                }
 
-        if (options.path && options.path.startsWith("/proxy")) {
-            options.path = options.path.substring(6);
+                                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) {
             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)
         {
@@ -145,27 +183,27 @@ var createProxyHandler = function(proxyTarget, pathPrefix)
                 {
                     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)
@@ -176,13 +214,13 @@ var createProxyHandler = function(proxyTarget, pathPrefix)
         {
             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"])
@@ -196,85 +234,22 @@ 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();
-                                }
+        return headers;
+    };
+    // rewrite response headers
+    proxyOptions.rewriteHeaders = function(headers)
+    {
+        return headers;
+    };
+    // request invoke settings
+    //proxyOptions.request = {};
 
-                                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);
-        });
+        proxy(req, res, pathPrefix, proxyOptions);
     };
-    
-    // cookie domain rewrite?
-    // not needed - this is handled intrinsically by http2-proxy
 
     return proxyRequestHandler;
 };

package/util/request.js

@@ -103,7 +103,6 @@ module.exports = function(config, callback)
         requestConfig.responseType = config.responseType;
     }
 
-
     /*
     if (requestConfig.url.toLowerCase().indexOf("https:") > -1)
     {
@@ -114,10 +113,15 @@ module.exports = function(config, callback)
         requestConfig.httpAgent = http.globalAgent;
     }
     */
+
+    if (config.timeout) {
+        requestConfig.timeout = config.timeout;
+    }
     
     return axios.request(requestConfig).then(function(response) {
         callback(null, response, response.data);
-    }, function(error) {
+    }).catch(function(error) {
         callback(error);
     });
+
 };

package/util/workqueue.js

@@ -0,0 +1,111 @@
+var util = require("./util");
+
+module.exports = function(name, maxSize, debug)
+{
+    if (!maxSize) {
+        maxSize = 3;
+    }
+
+    var pendingWorkQueue = [];
+    var activeCount = 0;
+
+    var debugLog = function(text)
+    {
+        if (debug)
+        {
+            console.log("[WORKQUEUE: " + name + "] " + text);
+        }
+    }
+
+    var dispatcherFn = function () {
+
+        // add as many pending work items as we can, loop until full or no more pending
+        var process = true;
+        do
+        {
+            // if nothing to work on, bail
+            if (pendingWorkQueue.length === 0)
+            {
+                process = false;
+            }
+            else
+            {
+                // var ids = [];
+                // for (var z = 0; z < pendingWorkQueue.length; z++)
+                // {
+                //     ids.push(pendingWorkQueue[z].id);
+                // }
+                //
+                // debugLog("Dispatcher top, queue: " + ids.join(","));
+
+                //debugLog("dispatcher, pending: " + pendingWorkQueue.length + ", actives: " + activeCount + "]");
+
+                // if we're full, bail
+                if (activeCount >= maxSize)
+                {
+                    process = false;
+                }
+
+                if (process)
+                {
+                    // increment active count
+                    activeCount++;
+
+                    // define execution function and splice/bind to 0th element from pending list
+                    var executionFn = function(work) {
+                        return function() {
+                            var workFn = work.workFn;
+                            var callbackFn = work.callbackFn;
+
+                            debugLog("Start: " + work.id + ", queue: " + pendingWorkQueue.length + ", actives: " + activeCount);
+
+                            workFn(function(err, obj1, obj2) {
+
+                                // fire optional callback
+                                if (callbackFn) {
+                                    window.setTimeout(function() {
+                                        callbackFn(err, obj1, obj2);
+                                    });
+                                }
+
+                                // decrement active count
+                                activeCount--;
+
+                                debugLog("Complete: " + work.id + ", queue: " + pendingWorkQueue.length + ", actives: " + activeCount);
+                            });
+
+                        };
+                    }(pendingWorkQueue.splice(0, 1)[0]);
+
+                    // execute on timeout
+                    window.setTimeout(executionFn);
+                }
+            }
+
+        } while (process);
+
+        // run again on a brief timeout
+        window.setTimeout(dispatcherFn, 50);
+    };
+
+    // launch dispatcher
+    window.setTimeout(dispatcherFn);
+
+    // hand back a function to register work onto the queue
+    return function(workFn, callbackFn) {
+
+        var work = {
+            "id": util.guid(),
+            "workFn": workFn
+        };
+
+        if (callbackFn) {
+            work.callbackFn = callbackFn;
+        }
+
+        pendingWorkQueue.push(work);
+
+        //debugLog("Added to pending queue, id: " + work.id + ", pending: " + pendingWorkQueue.length);
+    };
+
+};

package/.last_command

@@ -1,7 +0,0 @@
-{
-  "command": {
-    "group": "server",
-    "name": "start"
-  },
-  "arguments": {}
-}

package/duster/helpers/core/cloudcms/associations.js

@@ -1,34 +0,0 @@
-/**
- * @associations
- *
- * @param app
- * @param dust
- * @param callback
- */
-module.exports = function(app, dust, callback)
-{
-    var engine = require("../engine")(app, dust);
-
-    /**
-     * ASSOCIATIONS
-     *
-     * Finds associations around a node.
-     *
-     * Syntax:
-     *
-     *    {@associations node="<nodeId>" type="<association_type>" limit="" skip="" as=""}
-     *       {+templateIdentifier/}
-     *    {/associations}
-     *
-     * @param chunk
-     * @param context
-     * @param bodies
-     * @param params
-     */
-    dust.helpers.associations = function(chunk, context, bodies, params)
-    {
-        return engine.handleAssociations(chunk, context, bodies, params);
-    };
-
-    callback();
-};

package/duster/helpers/core/cloudcms/beta/markdown.js

@@ -1,46 +0,0 @@
-var marked = require("marked");
-marked.setOptions({
-    renderer: new marked.Renderer(),
-    gfm: true,
-    tables: true,
-    breaks: false,
-    pedantic: false,
-    sanitize: true,
-    smartLists: true,
-    smartypants: false
-});
-
-/**
- * @markdown
- *
- * @param app
- * @param dust
- * @param callback
- */
-module.exports = function(app, dust, callback)
-{
-    /**
-     * Renders markdown into the Dust template.
-     *
-     * @param chunk
-     * @param context
-     * @param bodies
-     * @param params
-     * @returns {*}
-     */
-    dust.helpers.markdown = function(chunk, context, bodies, params) {
-
-        params = params || {};
-
-        var text = context.resolve(params.text);
-        if (!text) {
-            return chunk;
-        }
-
-        text = marked(text);
-
-        return chunk.write(text);
-    };
-
-    callback();
-};

package/duster/helpers/core/cloudcms/beta/nodeAttachmentText.js

@@ -1,46 +0,0 @@
-/**
- * @nodeAttachmentText
- *
- * @param app
- * @param dust
- * @param callback
- */
-module.exports = function(app, dust, callback)
-{
-    var engine = require("../../engine")(app, dust);
-
-    var map = engine.map;
-    var end = engine.end;
-
-    dust.helpers.nodeAttachmentText = dust.helpers.nodeAttachmentValue = function(chunk, context, bodies, params)
-    {
-        params = params || {};
-
-        var nodeId = context.resolve(params.node);
-        var attachmentId = context.resolve(params.attachment);
-        if (!attachmentId)
-        {
-            attachmentId = "default";
-        }
-
-        return map(chunk, function(chunk) {
-
-            var req = context.get("req");
-            req.branch(function(err, branch) {
-
-                if (err) {
-                    return end(chunk, context);
-                }
-
-                branch.readNode(nodeId).attachment(attachmentId).download(function(text) {
-
-                    chunk.write(text);
-
-                    end(chunk, context);
-                });
-            });
-        });
-    };
-
-    callback();
-};