cloudcms-server 3.2.284 → 3.2.285

package/broadcast/broadcast.js

@@ -14,9 +14,9 @@ module.exports = function()
         if (!process.env.CLOUDCMS_BROADCAST_TYPE) {
             process.env.CLOUDCMS_BROADCAST_TYPE = "local";
 
-            if (process.configuration.setup !== "single") {
-                process.env.CLOUDCMS_BROADCAST_TYPE = "redis";
-            }
+            // if (process.configuration.setup !== "single") {
+            //     process.env.CLOUDCMS_BROADCAST_TYPE = "redis";
+            // }
         }
 
         var config = process.configuration;

package/d1/index.js

@@ -0,0 +1,629 @@
+delete process.env.NODE_DEBUG;
+
+var moment = require("moment");
+var cluster = require("cluster");
+var http = require("http");
+var os = require("os");
+var numCPUs = os.cpus().length;
+
+// default agents
+process.defaultHttpTimeoutMs = 60000;
+var HttpKeepAliveAgent = require('agentkeepalive');
+http.globalAgent = new HttpKeepAliveAgent({
+    keepAlive: true,
+    keepAliveMsecs: 5000,
+    maxSockets: 16000,
+    maxFreeSockets: 256,
+    timeout: process.defaultHttpTimeoutMs,
+    freeSocketTimeout: 4000
+});
+
+require("ssl-root-cas").inject();
+
+var REDIS_URL = "redis://redis.default.svc.cluster.local:6379";
+
+// track temporary files
+var temp = require('temp');
+const https = require("https");
+const {setupMaster} = require("@socket.io/sticky");
+temp.track();
+
+var initWorker = function(allDone)
+{
+    var initSession = function (initDone) {
+        var sessionSecret = "secret";
+        var sessionConfig = {
+            secret: sessionSecret,
+            resave: false,
+            saveUninitialized: false
+        };
+        
+        const connectRedis = require('connect-redis');
+        var session = require('express-session');
+        var RedisStore = connectRedis(session);
+        var IORedis = require("ioredis");
+        var redisClient = new IORedis(REDIS_URL);
+        sessionConfig.store = new RedisStore({client: redisClient});
+        initDone(null, session(sessionConfig));
+        //
+        // var options = {};
+        // options.checkPeriod = 86400000; // prune expired entries every 24h
+        //
+        // // session memory store
+        // var MemoryStore = require('memorystore')(session);
+        // sessionConfig.store = new MemoryStore(options);
+        // initDone(null, session(sessionConfig));
+    };
+    
+    var setHeaderOnce = exports.setHeaderOnce = function (response, name, value) {
+        var existing = response.getHeader(name);
+        if (typeof (existing) === "undefined") {
+            setHeader(response, name, value);
+        }
+    };
+    
+    var setHeader = exports.setHeader = function (response, name, value) {
+        try {
+            response.setHeader(name, value);
+        } catch (e) {
+        }
+    };
+    
+    var createProxyHandler = function (protocol, hostname, port, 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);
+        };
+        
+        // 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;
+            
+            console.log("path: " + options.path);
+            
+            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) {
+            
+            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)) {
+                        console.log("ah1");
+                    }
+                }
+            });
+            
+            //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);
+            });
+        };
+        
+        return proxyRequestHandler;
+    };
+    
+    var express = require('express');
+    
+    var app = express();
+    app.disable('x-powered-by');
+    
+    var bodyParser = require("body-parser");
+    var multipart = require("connect-multiparty");
+    var flash = require("connect-flash");
+    
+    var bodyParserFn = function () {
+        return function (req, res, next) {
+            if (req._body) {
+                return next();
+            }
+            
+            var contentType = req.get("Content-Type");
+            //if (contentType == "application/json" && req.method.toLowerCase() == "post") {
+            if (req.method.toLowerCase() == "post") {
+                
+                req._body = true;
+                
+                var responseString = "";
+                
+                req.on('data', function (data) {
+                    responseString += data;
+                });
+                
+                req.on('end', function () {
+                    
+                    if (responseString.length > 0) {
+                        
+                        try {
+                            var b = JSON.parse(responseString);
+                            if (b) {
+                                req.body = b;
+                            }
+                        } catch (e) {
+                        }
+                    }
+                    
+                    next();
+                });
+            } else {
+                next();
+            }
+        };
+    };
+    
+    initSession(function () {
+        
+        // middleware
+        app.enable('strict routing');
+        app.set('port', 3000);
+        // custom morgan logger
+        var morgan = require("morgan");
+        morgan(function (tokens, req, res) {
+            
+            var status = res.statusCode;
+            var len = parseInt(res.getHeader('Content-Length'), 10);
+            var host = req.domainHost;
+            if (req.virtualHost) {
+                host = req.virtualHost;
+            }
+            
+            len = isNaN(len) ? '0b' : len = bytes(len);
+            
+            var d = new Date();
+            var dateString = d.toDateString();
+            var timeString = d.toTimeString();
+            
+            // gray color
+            var grayColor = "\x1b[90m";
+            
+            // status color
+            var color = 32;
+            if (status >= 500) {
+                color = 31;
+            } else if (status >= 400) {
+                color = 33;
+            } else if (status >= 300) {
+                color = 36;
+            }
+            var statusColor = "\x1b[" + color + "m";
+            
+            // final color
+            var finalColor = "\x1b[0m";
+            
+            if (process.env.CLOUDCMS_APPSERVER_MODE === "production") {
+                grayColor = "";
+                statusColor = "";
+                finalColor = "";
+            }
+            
+            var message = '';
+            message += grayColor + '<' + req.id + '> ';
+            message += grayColor + '[' + dateString + ' ' + timeString + '] ';
+            message += grayColor + host + ' ';
+            //message += grayColor + '(' + req.ip + ') ';
+            message += statusColor + res.statusCode + ' ';
+            message += statusColor + (new Date - req._startTime) + ' ms ';
+            message += grayColor + '"' + req.method + ' ';
+            message += grayColor + req.originalUrl + '" ';
+            message += grayColor + len + ' ';
+            message += finalColor;
+            
+            return message;
+        });
+        // add req.id
+        var requestCounter = 0;
+        app.use(function (req, res, next) {
+            requestCounter++;
+            req.id = requestCounter;
+            next();
+        });
+        // retain originalUrl and originalPath since these can get modified along the way
+        app.use(function (req, res, next) {
+            req.originalUrl = req.url;
+            req.originalPath = req.path;
+            next();
+        });
+        // req.param method
+        var requestParam = require("request-param")();
+        app.use(requestParam);
+        // add req.log function
+        app.use(function (req, res, next) {
+            
+            req._log = req.log = function (text/*, warn*/) {
+                
+                var host = req.domainHost;
+                if (req.virtualHost) {
+                    host = req.virtualHost;
+                }
+                
+                var timestamp = moment(new Date()).format("MM/DD/YYYY HH:mm:ss Z");
+                var grayColor = "\x1b[90m";
+                var finalColor = "\x1b[0m";
+                
+                // in production, don't use colors
+                if (process.env.CLOUDCMS_APPSERVER_MODE === "production") {
+                    grayColor = "";
+                    finalColor = "";
+                }
+                
+                var message = '';
+                message += grayColor + '<' + req.id + '> ';
+                if (cluster.worker && cluster.worker.id) {
+                    message += grayColor + '(' + cluster.worker.id + ') ';
+                }
+                message += grayColor + '[' + timestamp + '] ';
+                message += grayColor + host + ' ';
+                message += grayColor + text + '';
+                message += finalColor;
+                
+                /*
+                if (warn)
+                {
+                    message = "\r\n**** SLOW RESPONSE ****\r\n" + message + "\r\n";
+                }
+                */
+                
+                console.log(message);
+            };
+            
+            next();
+        });
+        
+        // TODO: SKIP THIS FOR NOW
+        // common interceptors and config
+        //main.common1(app);
+        
+        // general logging of requests
+        // gather statistics on response time
+        var responseTime = require("response-time");
+        app.use(responseTime(function (req, res, time) {
+            
+            var warn = false;
+            if (time > 1000) {
+                warn = true;
+            }
+            
+            var requestPath = req.originalPath;
+            if (requestPath) {
+                var filter = false;
+                if (requestPath.indexOf("/login") > -1) {
+                    filter = true;
+                }
+                if (requestPath.indexOf("/token") > -1) {
+                    filter = true;
+                }
+                // if (filter)
+                // {
+                //     requestPath = util.stripQueryStringFromUrl(requestPath);
+                // }
+            }
+            
+            req.log(req.method + " " + requestPath + " [" + res.statusCode + "] (" + time.toFixed(2) + " ms)", warn);
+        }));
+        
+        // TODO
+        // // set up CORS allowances
+        // // this lets CORS requests float through the proxy
+        app.use(function (req, res, next) {
+            
+            var origin = null;
+            if (!origin) {
+                origin = req.headers["origin"];
+            }
+            if (!origin) {
+                origin = req.headers["x-cloudcms-origin"];
+            }
+            if (!origin) {
+                origin = "*";
+            }
+            
+            // var methods = null
+            // var headers = null;
+            // var credentials = null;
+            
+            setHeaderOnce(res, "Access-Control-Allow-Origin", origin);
+            
+            // if (methods)
+            // {
+            //     setHeaderOnce(res, "Access-Control-Allow-Methods", methods);
+            // }
+            //
+            // if (headers)
+            // {
+            //     setHeaderOnce(res, "Access-Control-Allow-Headers", headers);
+            // }
+            //
+            // if (credentials)
+            // {
+            //     setHeaderOnce(res, "Access-Control-Allow-Credentials", "" + credentials);
+            // }
+            
+            // res.set('Access-Control-Allow-Max-Age', 3600);
+            
+            if ('OPTIONS' === req.method) {
+                return res.sendStatus(200);
+            }
+            
+            next();
+        });
+        
+        //
+        // set up default security headers
+        app.use(function (req, res, next) {
+            
+            // defaults
+            var xFrameOptions = "SAMEORIGIN";
+            var xXssProtection = "1; mode=block";
+            
+            // TODO: allow overrides here?
+            
+            if (xFrameOptions) {
+                setHeaderOnce(res, "X-Frame-Options", xFrameOptions);
+            }
+            
+            if (xXssProtection) {
+                setHeaderOnce(res, "X-XSS-Protection", xXssProtection)
+            }
+            
+            setHeaderOnce(res, "X-Powered-By", "Cloud CMS");
+            
+            next();
+        });
+        
+        // TODO: SKIP THIS FOR NOW
+        // // common interceptors and config
+        // main.common2(app);
+        
+        // TODO: SKIP THIS FOR NOW
+        // binds gitana driver into place
+        // main.common3(app);
+        
+        // parse cookies
+        var cookieParser = require('cookie-parser');
+        app.use(cookieParser());
+        
+        // TODO: SKIP THIS FOR NOW
+        // // cloudcms things need to run here
+        // main.common4(app, true);
+        
+        // TODO
+        // PATH BASED PERFORMANCE CACHING
+        //main.perf1(app);
+        
+        var proxyRequestHandler = createProxyHandler("http", "api.default.svc.cluster.local", 80);
+        app.use(function (req, res) {
+            req.virtualHost = "mt85.us1.cloudcms.net";
+            proxyRequestHandler(req, res);
+        });
+        
+        // standard body parsing + a special cloud cms body parser that makes a last ditch effort for anything
+        // that might be JSON (regardless of content type)
+        app.use(function (req, res, next) {
+            
+            multipart({})(req, res, function (err) {
+                bodyParser.json({})(req, res, function (err) {
+                    bodyParser.urlencoded({})(req, res, function (err) {
+                        bodyParserFn()(req, res, function (err) {
+                            next(err);
+                        });
+                    });
+                });
+            });
+            
+        });
+        
+        app.use(flash());
+    
+        // var server = app.listen(3000, function() {
+        //     console.log('Process ' + process.pid + ' is listening to all incoming requests');
+        // });
+        //const server = http.createServer()
+        var server = http.Server(app);
+    
+        // request timeout
+        var requestTimeout = 30000; // 30 seconds
+        server.setTimeout(requestTimeout);
+    
+        // socket
+        server.on("connection", function (socket) {
+            console.log("server connection");
+            socket.setNoDelay(true);
+        });
+        
+        // configure socket IO
+        const { setupWorker } = require("@socket.io/sticky");
+        const { Server } = require("socket.io");
+        const { createAdapter } = require("@socket.io/redis-adapter");
+        const IORedis = require("ioredis");
+    
+        var pubClient = new IORedis(REDIS_URL);
+        var subClient = pubClient.duplicate();
+    
+        const io = new Server(server);
+        server.io = io;
+    
+        io.engine.on("connection_error", function(err) {
+            // console.log("CONNECTION ERROR");
+            // console.log("REQUEST: ", err.req);      // the request object
+            // console.log("CODE: " + err.code);     // the error code, for example 1
+            // console.log("MESSAGE: ", err.message);  // the error message, for example "Session ID unknown"
+            // console.log("CONTEXT: ", err.context);  // some additional error context
+        });
+    
+        // use the redis adapter
+        io.adapter(createAdapter(pubClient, subClient, {
+            //publishOnSpecificResponseChannel: true
+        }));
+    
+        // setup connection with the primary process
+        setupWorker(io);
+    
+        // on connect
+        io.on("connection", (socket) => {
+            //console.log("Redis Launcher on('connection') - socket id:" + socket.id);
+            socket.on('message', function(m) {
+                console.log("Socket Connection message: " + m);
+            });
+        
+            // always catch err
+            socket.on("error", function(err) {
+                console.log("Caught socket error");
+                console.log(err.stack);
+            });
+        
+            // TODO
+        });
+
+        allDone(null, server);
+    });
+}
+
+if (cluster.isMaster)
+{
+    console.log(`Primary ${process.pid} is starting`);
+    
+    var server = http.createServer();
+    //server.listen(3000);
+    
+    const { setupMaster } = require("@socket.io/sticky");
+    const { setupPrimary } = require("@socket.io/cluster-adapter");
+    
+    // setup connections between the workers
+    setupPrimary();
+    
+    // needed for packets containing buffers
+    cluster.setupMaster({
+        serialization: "advanced"
+    });
+    
+    // setup sticky sessions
+    setupMaster(server, {
+        //loadBalancingMethod: "least-connection"
+        loadBalancingMethod: "round-robin"
+    });
+    
+    // Fork workers.
+    for (let i = 0; i < numCPUs; i++) {
+        cluster.fork();
+    }
+    
+    cluster.on('exit', (worker, code, signal) => {
+        console.log(`Worker ${worker.process.pid} died`);
+    });
+    
+    console.log(`Primary ${process.pid} is running`);
+}
+else
+{
+    initWorker(function(err, server) {
+        server.listen(3000);
+        console.log(`Worker ${process.pid} started`);
+    });
+}

package/d1/index.js.works

@@ -0,0 +1,203 @@
+var createProxyHandler = function(protocol, hostname, port, 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);
+    };
+    
+    // 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);
+        });
+    };
+    
+    return proxyRequestHandler;
+};
+
+const http = require("http");
+const server = http.createServer()
+server.listen(3000);
+
+var proxyRequestHandler = createProxyHandler("http", "api.default.svc.cluster.local", 80);
+server.on('request', (req, res) => {
+    req.virtualHost = "mt85.us1.cloudcms.net";
+    
+    proxyRequestHandler(req, res);
+});

package/d1/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "d1",
+  "description": "D1",
+  "version": "0.0.1",
+  "dependencies": {
+    "@socket.io/cluster-adapter": "^0.2.0",
+    "@socket.io/redis-adapter": "^7.2.0",
+    "@socket.io/sticky": "^1.0.1",
+    "accepts": "^1.3.8",
+    "agentkeepalive": "^4.2.1",
+    "alpaca": "^1.5.27",
+    "archiver": "^1.3.0",
+    "async": "^3.2.3",
+    "async-lock": "^1.3.2",
+    "aws-sdk": "^2.1208.0",
+    "basic-auth": "^2.0.1",
+    "body-parser": "^1.20.0",
+    "bytes": "^2.5.0",
+    "canoe": "^0.3.3",
+    "clone": "^2.1.2",
+    "connect-flash": "^0.1.1",
+    "connect-multiparty": "^2.2.0",
+    "connect-redis": "^6.1.3",
+    "consolidate": "^0.14.5",
+    "cookie-parser": "^1.4.4",
+    "debug": "^2.6.9",
+    "dustjs-helpers": "1.7.4",
+    "dustjs-linkedin": "3.0.1",
+    "errorhandler": "^1.5.1",
+    "express": "^4.18.1",
+    "express-session": "^1.17.3",
+    "express-useragent": "^1.0.15",
+    "extend-with-super": "^2.0.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",
+    "klaw": "^1.3.1",
+    "lru-cache": "^4.1.5",
+    "marked": "^4.0.14",
+    "memorystore": "^1.6.1",
+    "mime": "^1.6.0",
+    "mkdirp": "^0.5.1",
+    "moment": "^2.24.0",
+    "morgan": "^1.9.1",
+    "object-hash": "^1.3.1",
+    "object-merge": "^2.5.1",
+    "on-headers": "^1.0.2",
+    "passport": "^0.4.0",
+    "passport-cas": "^0.0.3",
+    "passport-facebook": "^2.1.1",
+    "passport-github": "^1.1.0",
+    "passport-google-oauth": "^1.0.0",
+    "passport-linkedin": "^1.0.0",
+    "passport-local": "^1.0.0",
+    "passport-oauth": "^1.0.0",
+    "passport-saml": "^2.2.0",
+    "passport-twitter": "^0.1.5",
+    "pkginfo": "^0.4.1",
+    "random-js": "^1.0.8",
+    "recursive-readdir": "^2.2.2",
+    "redis": "^4.2.0",
+    "redlock": "4.2.0",
+    "request": "^2.88.0",
+    "request-param": "^1.0.1",
+    "response-time": "^2.3.2",
+    "semver": "^7.3.7",
+    "serve-favicon": "^2.5.0",
+    "session-file-store": "^0.2.2",
+    "sha1": "^1.1.1",
+    "socket.io": "^4.5.1",
+    "ssl-root-cas": "^1.3.1",
+    "stomp-client": "^0.9.0",
+    "targz": "^1.0.1",
+    "temp": "^0.8.3",
+    "uuid": "^3.3.2",
+    "vm2": "^3.8.4",
+    "watch": "^0.13.0",
+    "winston": "^3.3.3"
+  }
+}

package/d1/package.json.works

@@ -0,0 +1,14 @@
+{
+  "author": {
+    "name": "Gitana Software, Inc.",
+    "email": "info@cloudcms.com",
+    "url": "https://www.cloudcms.com"
+  },
+  "name": "d1",
+  "description": "D1",
+  "version": "0.0.1",
+  "dependencies": {
+    "http2-proxy": "^5.0.53",
+    "finalhandler": "^1.2.0"
+  }
+}

package/launchpad/index.js

@@ -49,26 +49,57 @@ module.exports = function(type, config, options)
         fork = false;
     }
     
+    var bindToListeningPort = function(app, httpServer)
+    {
+        var httpServerPort = -1;
+        if (app) {
+            httpServerPort = app.get("port");
+        }
+        if (httpServerPort === -1) {
+            httpServerPort = process.env.PORT;
+        }
+        if (httpServerPort === -1) {
+            httpServerPort = 3000;
+        }
+    
+        httpServer.listen(httpServerPort);
+    }
+    
+    var bindSignalHandler = function()
+    {
+        var signal = false;
+        process.on('SIGINT', function() {
+            if (!signal) {
+                signal = true;
+                console.log("-------");
+                console.log("Heard SIGINT - shutting down in 10 seconds...");
+                console.log("-------");
+                setTimeout(function() { process.exit(0); }, 10000);
+            }
+        });
+        process.on('SIGTERM', function() {
+            if (!signal) {
+                signal = true;
+                console.log("-------");
+                console.log("Heard SIGTERM - shutting down in 10 seconds...");
+                console.log("-------");
+                setTimeout(function() { process.exit(0); }, 10000);
+            }
+        });
+    };
+    
     if (!fork)
     {
+        bindSignalHandler();
+        
         return launchWorker(launcher, config, options, function(err, app, httpServer) {
             
             if (err) {
                 return completionFn(config, err);
             }
     
-            var httpServerPort = -1;
-            // if (app) {
-            //     httpServerPort = app.get("port");
-            // }
-            if (httpServerPort === -1) {
-                httpServerPort = process.env.PORT;
-            }
-            if (httpServerPort === -1) {
-                httpServerPort = 3000;
-            }
-    
-            httpServer.listen(httpServerPort);
+            // bind to listening port
+            bindToListeningPort(app, httpServer);
     
             reportFn(config);
             completionFn(config);
@@ -76,21 +107,29 @@ module.exports = function(type, config, options)
     }
     else
     {
+        // in cluster mode, we have a single master listening to the port which distributes work to the workers
+        
         if (cluster.isMaster)
         {
-            return launchMaster(launcher, config, options, function(err, workers) {
+            bindSignalHandler();
+            
+            return launchMaster(launcher, config, options, function(err, workers, httpServer) {
     
                 if (err) {
                     return completionFn(config, err);
                 }
-    
+                
                 //reportFn(config);
                 completionFn(config);
             });
         }
         else
         {
-            return launchWorker(launcher, config, options, function(err) {
+            return launchWorker(launcher, config, options, function(err, app, httpServer) {
+    
+                // bind to listening port
+                bindToListeningPort(app, httpServer);
+    
                 completionFn(config, err);
             });
         }
@@ -112,22 +151,10 @@ var launchMaster = function(launcher, config, options, done)
             if (err) {
                 return done(err);
             }
-    
-            var httpServerPort = -1;
-            // if (app) {
-            //     httpServerPort = app.get("port");
-            // }
-            if (httpServerPort === -1) {
-                httpServerPort = process.env.PORT;
-            }
-            if (httpServerPort === -1) {
-                httpServerPort = 3000;
-            }
-    
-            httpServer.listen(httpServerPort);
-    
+            
             launcher.afterStartCluster(httpServer, function(err, workers) {
-                done(err, workers);
+                console.log("LaunchPad started Master: " + process.pid);
+                done(err, workers, httpServer);
             });
         });
     });
@@ -161,7 +188,7 @@ var launchWorker = function(launcher, config, options, done)
                 if (err) {
                     return done(err);
                 }
-                
+    
                 // if we are on a worker process, then inform the master that we completed
                 if (process.send) {
                     process.send("worker-startup");
@@ -173,6 +200,8 @@ var launchWorker = function(launcher, config, options, done)
                     reportFn(config);
                 }
 
+                console.log("LaunchPad started Worker: " + process.pid);
+                
                 done(null, app, httpServer);
             });
         });

package/launchpad/launchers/cluster.js

@@ -65,7 +65,7 @@ module.exports = function(config) {
         
         cluster.on("exit", (worker) => {
             console.log(`Worker ${worker.process.pid} died`);
-            cluster.fork();
+            //cluster.fork();
         });
         
         // wait for workers to start

package/locks/locks.js

@@ -40,9 +40,9 @@ exports = module.exports = function()
         {
             process.env.CLOUDCMS_LOCKS_TYPE = "memory";
 
-            if (process.configuration.setup !== "single") {
-                process.env.CLOUDCMS_LOCKS_TYPE = "redis";
-            }
+            // if (process.configuration.setup !== "single") {
+            //     process.env.CLOUDCMS_LOCKS_TYPE = "redis";
+            // }
         }
 
         if (!process.configuration.locks) {

package/middleware/awareness/awareness.js

@@ -44,9 +44,9 @@ exports = module.exports = function()
         {
             process.env.CLOUDCMS_AWARENESS_TYPE = "memory";
 
-            if (process.configuration.setup !== "single") {
-                process.env.CLOUDCMS_AWARENESS_TYPE = "redis";
-            }
+            // if (process.configuration.setup !== "single") {
+            //     process.env.CLOUDCMS_AWARENESS_TYPE = "redis";
+            // }
         }
 
         if (!process.configuration.awareness) {

package/middleware/cache/cache.js

@@ -28,9 +28,9 @@ exports = module.exports = function()
 
             process.env.CLOUDCMS_CACHE_TYPE = "memory";
 
-            if (process.configuration.setup !== "single") {
-                process.env.CLOUDCMS_CACHE_TYPE = "redis";
-            }
+            // if (process.configuration.setup !== "single") {
+            //     process.env.CLOUDCMS_CACHE_TYPE = "redis";
+            // }
         }
 
         if (!process.configuration.cache.type)

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "cloudcms-server",
   "description": "Cloud CMS Application Server Module",
-  "version": "3.2.284",
+  "version": "3.2.285",
   "repository": {
     "type": "git",
     "url": "git://github.com/gitana/cloudcms-server.git"

package/server/index.js

@@ -886,7 +886,7 @@ var startServer = function(config, startServerFinishedFn)
                 });
                 */
     
-                // add req.id  re
+                // increment and assign request id
                 app.use(function (req, res, next) {
                     requestCounter++;
                     req.id = requestCounter;