cloudcms-server 0.9.255 → 0.9.260

package/server/index.js

@@ -16,22 +16,20 @@ var session = require('express-session');
 var cookieParser = require('cookie-parser');
 var flash = require("connect-flash");
 
-const redis = require('redis');
+//const redis = require('redis');
 const connectRedis = require('connect-redis');
 
 // we don't bind a single passport - instead, we get the constructor here by hand
 var Passport = require("passport").Passport;
 
 var util = require("../util/util");
+var redisHelper = require("../util/redis");
 
 var launchPad = require("../launchpad/index");
 var cluster = require("cluster");
 
 var requestParam = require("request-param")();
 
-var app = express();
-app.disable('x-powered-by');
-
 // cloudcms app server support
 var main = require("../index");
 
@@ -48,11 +46,27 @@ toobusy.interval(250);
 
 var responseTime = require("response-time");
 
+// safely checks for the existence of a path
+var safeExists = function(_path)
+{
+    var exists = false;
+    try
+    {
+        exists = fs.existsSync(_path);
+    }
+    catch (e)
+    {
+        // swallow
+    }
+    
+    return exists;
+}
+
 var requestCounter = 0;
 
 // holds configuration settings
 var SETTINGS = {
-    "setup": "single", // single, cluster, sticky-cluster
+    "setup": "single", // single, cluster, redis
     "name": "Cloud CMS Application Server",
     "socketFunctions": [],
     "routeFunctions": [],
@@ -309,17 +323,67 @@ var SETTINGS = {
     }
 };
 
+// always push core tag helpers to the front
+SETTINGS.dustFunctions.unshift(coreHelpers);
+
+// if SETTINGS.errorFunctions is empty, plug in a default error handler
+if (SETTINGS.errorFunctions.length === 0)
+{
+    SETTINGS.errorFunctions.push(main.defaultErrorHandler);
+}
+else
+{
+    // otherwise, if they plugged in a custom error handler, make sure we at least have a console logger ahead of it
+    // so that things are sure to get logged out to console
+    SETTINGS.errorFunctions.unshift(main.consoleErrorLogger);
+}
+
+// insert an error handler to handle refresh token failures
+SETTINGS.errorFunctions.unshift(main.refreshTokenErrorHandler);
+
+// CLOUDCMS_HOSTS_PATH environment variable
+// assume /hosts with optional fallback to /System/Volumes/Data/hosts for MacOS support
+if (!process.env.CLOUDCMS_HOSTS_PATH)
+{
+    process.env.CLOUDCMS_HOSTS_PATH = "/hosts";
+    
+    if (!safeExists(process.env.CLOUDCMS_HOSTS_PATH))
+    {
+        if (safeExists("/System/Volumes/Data/hosts"))
+        {
+            process.env.CLOUDCMS_HOSTS_PATH = "/System/Volumes/Data/hosts";
+        }
+        else
+        {
+            const homedir = require('os').homedir();
+            
+            if (safeExists(homedir + "/hosts"))
+            {
+                process.env.CLOUDCMS_HOSTS_PATH = homedir + "/hosts";
+            }
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // runs on 2999 by default
 process.env.PORT = process.env.PORT || 2999;
 
-// allows for specification of alternative transports
-// SETTINGS.socketTransports = [
-//     'websocket',
-//     'xhr-polling',
-//     'jsonp-polling',
-//     'polling'
-// ];
-
 var exports = module.exports;
 
 /**
@@ -503,62 +567,19 @@ var _start = function(overrides, callback) {
         callback = function() {};
     }
 
-    // always push core tag helpers to the front
-    SETTINGS.dustFunctions.unshift(coreHelpers);
-
-    // if SETTINGS.errorFunctions is empty, plug in a default error handler
-    if (SETTINGS.errorFunctions.length === 0)
-    {
-        SETTINGS.errorFunctions.push(main.defaultErrorHandler);
-    }
-    else
-    {
-        // otherwise, if they plugged in a custom error handler, make sure we at least have a console logger ahead of it
-        // so that things are sure to get logged out to console
-        SETTINGS.errorFunctions.unshift(main.consoleErrorLogger);
-    }
-
-    // insert an error handler to handle refresh token failures
-    SETTINGS.errorFunctions.unshift(main.refreshTokenErrorHandler);
-
     // create our master config
     var config = clone(SETTINGS);
     if (overrides) {
         util.merge(overrides, config);
     }
-
-    // assume for launchpad
-    if (!config.setup) {
-        config.setup = "single";
-    }
-
-    launchPad({
-        "setup": config.setup,
-        "factory": function(done) {
-            startSlave(config, function(app, server) {
-                done(server);
-            });
-        },
-        "report": function() {
-            runFunctions(config.reportFunctions, [], function(err) {
-                // todo
-            });
-        },
-        "complete": function() {
-            callback();
-        }
-    });
-};
-
-var startSlave = function(config, afterStartFn)
-{
+    
     // set up modes
     process.env.CLOUDCMS_APPSERVER_MODE = "development";
-
-    if (process.env.NODE_ENV == "production") {
+    
+    if (process.env.NODE_ENV === "production") {
         process.env.CLOUDCMS_APPSERVER_MODE = "production";
     }
-
+    
     /*
     // set up domain hosting
     // if not otherwise specified, we assume hosting at *.cloudcms.net
@@ -569,10 +590,10 @@ var startSlave = function(config, afterStartFn)
         }
     }
     */
-
+    
     // store config on process instance
     process.configuration = config;
-
+    
     // some config overrides can come in through process.configuration
     if (process.configuration) {
         if (process.configuration.virtualHost && process.configuration.virtualHost.domain) {
@@ -586,7 +607,7 @@ var startSlave = function(config, afterStartFn)
     if (process.env.CLOUDCMS_VIRTUAL_HOST_DOMAIN) {
         process.env.CLOUDCMS_VIRTUAL_HOST_DOMAIN = process.env.CLOUDCMS_VIRTUAL_HOST_DOMAIN.toLowerCase();
     }
-
+    
     if (!process.env.CLOUDCMS_STANDALONE_HOST) {
         process.env.CLOUDCMS_STANDALONE_HOST = "local";
     }
@@ -628,6 +649,11 @@ var startSlave = function(config, afterStartFn)
     if (!process.configuration.session) {
         process.configuration.session = {};
     }
+    // auto-configuration for redis?
+    if (process.env.CLOUDCMS_REDIS_URL || (process.env.CLOUDCMS_REDIS_ENDPOINT && process.env.CLOUDCMS_REDIS_PORT)) {
+        process.env.CLOUDCMS_SESSION_TYPE = "redis";
+    }
+    
     if (process.env.CLOUDCMS_SESSION_TYPE) {
         process.configuration.session.enabled = true;
         process.configuration.session.type = process.env.CLOUDCMS_SESSION_TYPE;
@@ -635,7 +661,50 @@ var startSlave = function(config, afterStartFn)
     if (process.env.CLOUDCMS_SESSION_SECRET) {
         process.configuration.session.secret = process.env.CLOUDCMS_SESSION_SECRET;
     }
+    
+    
+    // determine the max files
+    util.maxFiles(function(err, maxFiles) {
+        process.env.CLOUDCMS_MAX_FILES = maxFiles;
+        
+        // assume for launchpad
+        if (!config.setup) {
+            config.setup = "single";
+        }
+        
+        launchPad(config.setup, config, {
+            "createHttpServer": function(app, done) {
+                createHttpServer(app, function(err, httpServer) {
+                    done(err, httpServer);
+                });
+            },
+            "startServer": function(config, done) {
+                startServer(config, function(err, app, httpServer, httpServerPort) {
+                    done(err, app, httpServer, httpServerPort);
+                });
+            },
+            "configureServer": function(config, app, httpServer, done) {
+                configureServer(config, app, httpServer, function(err) {
+                    done(err);
+                });
+            },
+            "report": function(config) {
+                runFunctions(config.reportFunctions, [], function(err) {
+                    // todo
+                });
+            },
+            "complete": function(config, err) {
+                callback(err);
+            }
+        });
+    });
+};
 
+var startServer = function(config, startServerFinishedFn)
+{
+    var app = express();
+    app.disable('x-powered-by');
+    
     // session store
     var initializedSession = null;
     if (process.configuration.session)
@@ -670,25 +739,20 @@ var startSlave = function(config, afterStartFn)
             }
             else if (process.configuration.session.type === "redis")
             {
-                var redisPort = process.env.CLOUDCMS_REDIS_PORT;
-                var redisHost = process.env.CLOUDCMS_REDIS_ENDPOINT;
-                
-                if (!redisPort)
-                {
-                    console.error("Cannot configure session for Redis storage because CLOUDCMS_REDIS_PORT is not defined");
-                }
-                else if (!redisHost)
-                {
-                    console.error("Cannot configure session for Redis storage because CLOUDCMS_REDIS_ENDPOINT is not defined");
-                }
-                else
-                {
-                    var redisOptions = {};
-                    var redisClient = redis.createClient(redisPort, redisHost, redisOptions);
-                    
-                    var RedisStore = connectRedis(session);
-                    sessionConfig.store = new RedisStore({ client: redisClient });
-                }
+                (async function() {
+                    var redisOptions = redisHelper.redisOptions();
+                    redisHelper.createAndConnect(redisOptions, function(err, redisClient) {
+    
+                        if (err) {
+                            console.error(err);
+                        }
+                        else
+                        {
+                            var RedisStore = connectRedis(session);
+                            sessionConfig.store = new RedisStore({ client: redisClient });
+                        }
+                    });
+                })();
             }
             else if (process.configuration.session.type === "memory" || !process.configuration.session.type)
             {
@@ -703,604 +767,376 @@ var startSlave = function(config, afterStartFn)
             initializedSession = session(sessionConfig);
         }
     }
+    
+    // global temp directory
+    util.createTempDirectory(function(err, tempDirectory) {
+        process.env.CLOUDCMS_TEMPDIR_PATH = tempDirectory;
 
-    // safely checks for the existence of a path
-    var safeExists = function(_path)
-    {
-        var exists = false;
-        try
-        {
-            exists = fs.existsSync(_path);
-        }
-        catch (e)
-        {
-            // swallow
-        }
+        // global service starts
+        main.init(app, function (err) {
 
-        return exists;
-    }
+            app.enable('strict routing');
 
-    // CLOUDCMS_HOSTS_PATH environment variable
-    // assume /hosts with optional fallback to /System/Volumes/Data/hosts for MacOS support
-    if (!process.env.CLOUDCMS_HOSTS_PATH)
-    {
-        process.env.CLOUDCMS_HOSTS_PATH = "/hosts";
+            ////////////////////////////////////////////////////////////////////////////
+            //
+            // BASE CONFIGURATION
+            //
+            // Configures NodeJS app server using dustjs templating engine
+            // Runs on port 3000 by default
+            //
+            ////////////////////////////////////////////////////////////////////////////
 
-        if (!safeExists(process.env.CLOUDCMS_HOSTS_PATH))
-        {
-            if (safeExists("/System/Volumes/Data/hosts"))
+            // all environments
+            app.set('port', process.env.PORT);
+            app.set('views', process.env.CLOUDCMS_APPSERVER_BASE_PATH + "/views");
+
+            if (config.viewEngine === "dust")
             {
-                process.env.CLOUDCMS_HOSTS_PATH = "/System/Volumes/Data/hosts";
+                var cons = require('consolidate');
+
+                app.set('view engine', 'html');
+                app.set('view engine', 'dust');
+                app.engine('html', cons.dust);
+                app.engine('dust', cons.dust);
             }
-            else
+            else if (config.viewEngine === "handlebars" || config.viewEngine === "hbs")
             {
-                const homedir = require('os').homedir();
+                var hbs = require('hbs');
 
-                if (safeExists(homedir + "/hosts"))
-                {
-                    process.env.CLOUDCMS_HOSTS_PATH = homedir + "/hosts";
-                }
+                app.set('view engine', 'html');
+                app.set('view engine', 'hbs');
+                app.engine('html', hbs.__express);
+                app.engine('hbs', hbs.__express);
             }
-        }
-    }
-
-    // global temp directory
-    util.createTempDirectory(function(err, tempDirectory) {
-        process.env.CLOUDCMS_TEMPDIR_PATH = tempDirectory;
-
-        // determine the max files
-        util.maxFiles(function(err, maxFiles) {
-
-            process.env.CLOUDCMS_MAX_FILES = maxFiles;
-
-            // global service starts
-            main.init(app, function (err) {
 
-                app.enable('strict routing');
+            ////////////////////////////////////////////////////////////////////////////
+            //
+            // VIRTUAL SUPPORT
+            //
+            // Configure NodeJS to load virtual driver and configure for virtual descriptors
+            // ahead of anything else running.
+            //
+            ////////////////////////////////////////////////////////////////////////////
+
+            // custom morgan logger
+            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;
+                }
 
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                // BASE CONFIGURATION
-                //
-                // Configures NodeJS app server using dustjs templating engine
-                // Runs on port 3000 by default
-                //
-                ////////////////////////////////////////////////////////////////////////////
+                len = isNaN(len) ? '0b' : len = bytes(len);
 
-                // all environments
-                app.set('port', process.env.PORT);
-                app.set('views', process.env.CLOUDCMS_APPSERVER_BASE_PATH + "/views");
+                var d = new Date();
+                var dateString = d.toDateString();
+                var timeString = d.toTimeString();
 
-                if (config.viewEngine === "dust")
-                {
-                    var cons = require('consolidate');
+                // gray color
+                var grayColor = "\x1b[90m";
 
-                    app.set('view engine', 'html');
-                    app.set('view engine', 'dust');
-                    app.engine('html', cons.dust);
-                    app.engine('dust', cons.dust);
+                // status color
+                var color = 32;
+                if (status >= 500) {
+                    color = 31;
                 }
-                else if (config.viewEngine === "handlebars" || config.viewEngine === "hbs")
-                {
-                    var hbs = require('hbs');
-
-                    app.set('view engine', 'html');
-                    app.set('view engine', 'hbs');
-                    app.engine('html', hbs.__express);
-                    app.engine('hbs', hbs.__express);
+                else if (status >= 400) {
+                    color = 33;
                 }
+                else if (status >= 300) {
+                    color = 36;
+                }
+                var statusColor = "\x1b[" + color + "m";
 
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                // VIRTUAL SUPPORT
-                //
-                // Configure NodeJS to load virtual driver and configure for virtual descriptors
-                // ahead of anything else running.
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // custom morgan logger
-                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();
+                // final color
+                var finalColor = "\x1b[0m";
 
-                    // gray color
-                    var grayColor = "\x1b[90m";
+                if (process.env.CLOUDCMS_APPSERVER_MODE === "production")
+                {
+                    grayColor = "";
+                    statusColor = "";
+                    finalColor = "";
+                }
 
-                    // 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";
+                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;
+            });
 
-                    // final color
-                    var finalColor = "\x1b[0m";
+            /*
+            // debug headers being set
+            app.use(function(req, res, next) {
+                var setHeader = res.setHeader;
+                res.setHeader = function(a,b) {
+                    console.trace("Writing header: " + a + " = " + b);
+                    setHeader.call(this, a,b);
+                };
+                next();
+            });
+            */
 
-                    if (process.env.CLOUDCMS_APPSERVER_MODE == "production")
-                    {
-                        grayColor = "";
-                        statusColor = "";
-                        finalColor = "";
-                    }
+            // middleware which blocks requests when we're too busy
+            app.use(function(req, res, next) {
+                if (toobusy()) {
+                    res.status(503).send("The web application is too busy to serve this request.  Please try again.");
+                } else {
+                    next();
+                }
+            });
 
-                    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  re
+            app.use(function (req, res, next) {
+                requestCounter++;
+                req.id = requestCounter;
+                next();
+            });
 
-                /*
-                // debug headers being set
-                app.use(function(req, res, next) {
-                    var setHeader = res.setHeader;
-                    res.setHeader = function(a,b) {
-                        console.trace("Writing header: " + a + " = " + b);
-                        setHeader.call(this, a,b);
-                    };
-                    next();
-                });
-                */
-
-                // middleware which blocks requests when we're too busy
-                app.use(function(req, res, next) {
-                    if (toobusy()) {
-                        res.status(503).send("The web application is too busy to serve this request.  Please try again.");
-                    } else {
-                        next();
-                    }
-                });
+            // APPLY CUSTOM INIT FUNCTIONS
+            runFunctions(config.initFunctions, [app], function (err) {
 
-                // add req.id  re
+                // retain originalUrl and originalPath since these can get modified along the way
                 app.use(function (req, res, next) {
-                    requestCounter++;
-                    req.id = requestCounter;
+                    req.originalUrl = req.url;
+                    req.originalPath = req.path;
                     next();
                 });
 
-                // APPLY CUSTOM INIT FUNCTIONS
-                runFunctions(config.initFunctions, [app], function (err) {
+                // req.param method
+                app.use(requestParam);
 
-                    // 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
-                    app.use(requestParam);
+                // add req.log function
+                app.use(function (req, res, next) {
 
-                    // add req.log function
-                    app.use(function (req, res, next) {
+                    req._log = req.log = function (text/*, warn*/) {
 
-                        req._log = req.log = function (text/*, warn*/) {
+                        var host = req.domainHost;
+                        if (req.virtualHost)
+                        {
+                            host = req.virtualHost;
+                        }
 
-                            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";
 
-                            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 = "";
+                        }
 
-                            // 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;
 
-                            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";
+                        }
+                        */
 
-                            /*
-                            if (warn)
-                            {
-                                message = "\r\n**** SLOW RESPONSE ****\r\n" + message + "\r\n";
-                            }
-                            */
+                        console.log(message);
+                    };
 
-                            console.log(message);
-                        };
+                    next();
+                });
 
-                        next();
-                    });
+                // common interceptors and config
+                main.common1(app);
 
-                    // common interceptors and config
-                    main.common1(app);
+                // general logging of requests
+                // gather statistics on response time
+                app.use(responseTime(function (req, res, time) {
 
-                    // general logging of requests
-                    // gather statistics on response time
-                    app.use(responseTime(function (req, res, time) {
+                    var warn = false;
+                    if (time > 1000)
+                    {
+                        warn = true;
+                    }
 
-                        var warn = false;
-                        if (time > 1000)
+                    var requestPath = req.originalPath;
+                    if (requestPath)
+                    {
+                        var filter = false;
+                        if (requestPath.indexOf("/login") > -1)
                         {
-                            warn = true;
+                            filter = true;
                         }
-
-                        var requestPath = req.originalPath;
-                        if (requestPath)
+                        if (requestPath.indexOf("/token") > -1)
                         {
-                            var filter = false;
-                            if (requestPath.indexOf("/login") > -1)
-                            {
-                                filter = true;
-                            }
-                            if (requestPath.indexOf("/token") > -1)
-                            {
-                                filter = true;
-                            }
-                            if (filter)
-                            {
-                                requestPath = util.stripQueryStringFromUrl(requestPath);
-                            }
+                            filter = true;
                         }
+                        if (filter)
+                        {
+                            requestPath = util.stripQueryStringFromUrl(requestPath);
+                        }
+                    }
 
-                        req.log(req.method + " " + requestPath + " [" + res.statusCode + "] (" + time.toFixed(2) + " ms)", warn);
-                    }));
+                    req.log(req.method + " " + requestPath + " [" + res.statusCode + "] (" + time.toFixed(2) + " ms)", warn);
+                }));
 
-                    // set up CORS allowances
-                    // this lets CORS requests float through the proxy
-                    app.use(main.ensureCORS());
+                // set up CORS allowances
+                // this lets CORS requests float through the proxy
+                app.use(main.ensureCORS());
 
-                    // set up default security headers
-                    app.use(main.ensureHeaders());
+                // set up default security headers
+                app.use(main.ensureHeaders());
 
-                    // common interceptors and config
-                    main.common2(app);
+                // common interceptors and config
+                main.common2(app);
 
-                    // APPLY CUSTOM DRIVER FUNCTIONS
-                    runFunctions(config.driverFunctions, [app], function(err) {
+                // APPLY CUSTOM DRIVER FUNCTIONS
+                runFunctions(config.driverFunctions, [app], function(err) {
 
-                        // binds gitana driver into place
-                        main.common3(app);
+                    // binds gitana driver into place
+                    main.common3(app);
 
-                        // parse cookies
-                        app.use(cookieParser());
+                    // parse cookies
+                    app.use(cookieParser());
 
-                        // cloudcms things need to run here
-                        main.common4(app, true);
+                    // cloudcms things need to run here
+                    main.common4(app, true);
 
-                        // APPLY CUSTOM FILTER FUNCTIONS
-                        runFunctions(config.filterFunctions, [app], function (err) {
+                    // APPLY CUSTOM FILTER FUNCTIONS
+                    runFunctions(config.filterFunctions, [app], function (err) {
 
-                            // PATH BASED PERFORMANCE CACHING
-                            main.perf1(app);
+                        // PATH BASED PERFORMANCE CACHING
+                        main.perf1(app);
 
-                            // proxy - anything that goes to /proxy is handled here early and nothing processes afterwards
-                            main.proxy(app);
+                        // proxy - anything that goes to /proxy is handled here early and nothing processes afterwards
+                        main.proxy(app);
 
-                            // MIMETYPE BASED PERFORMANCE CACHING
-                            main.perf2(app);
+                        // MIMETYPE BASED PERFORMANCE CACHING
+                        main.perf2(app);
 
-                            // DEVELOPMENT BASED PERFORMANCE CACHING
-                            main.perf3(app);
+                        // DEVELOPMENT BASED PERFORMANCE CACHING
+                        main.perf3(app);
 
-                            // 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) {
+                        // 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(process.configuration.bodyParsers.multipart || {})(req, res, function (err) {
-                                    bodyParser.json(process.configuration.bodyParsers.json || {})(req, res, function (err) {
-                                        bodyParser.urlencoded(process.configuration.bodyParsers.urlencoded || {})(req, res, function (err) {
-                                            main.bodyParser()(req, res, function (err) {
-                                                next(err);
-                                            });
+                            multipart(process.configuration.bodyParsers.multipart || {})(req, res, function (err) {
+                                bodyParser.json(process.configuration.bodyParsers.json || {})(req, res, function (err) {
+                                    bodyParser.urlencoded(process.configuration.bodyParsers.urlencoded || {})(req, res, function (err) {
+                                        main.bodyParser()(req, res, function (err) {
+                                            next(err);
                                         });
                                     });
                                 });
-
                             });
 
-                            if (initializedSession)
-                            {
-                                app.use(initializedSession);
-                                app.use(flash());
-                            }
+                        });
 
-                            // this is the same as calling
-                            // app.use(passport.initialize());
-                            // except we create a new passport each time and store on request to support multitenancy
-                            app.use(function(req, res, next) {
+                        if (initializedSession)
+                        {
+                            app.use(initializedSession);
+                            app.use(flash());
+                        }
 
-                                var passport = new Passport();
-                                passport._key = "passport-" + req.virtualHost;
+                        // this is the same as calling
+                        // app.use(passport.initialize());
+                        // except we create a new passport each time and store on request to support multitenancy
+                        app.use(function(req, res, next) {
 
-                                req._passport = {};
-                                req._passport.instance = passport;
+                            var passport = new Passport();
+                            passport._key = "passport-" + req.virtualHost;
 
-                                if (req.session && req.session[passport._key])
-                                {
-                                    // load data from existing session
-                                    req._passport.session = req.session[passport._key];
-                                }
+                            req._passport = {};
+                            req._passport.instance = passport;
 
-                                // add this in
-                                req.passport = req._passport.instance;
+                            if (req.session && req.session[passport._key])
+                            {
+                                // load data from existing session
+                                req._passport.session = req.session[passport._key];
+                            }
 
-                                // passport - serialize and deserialize
-                                req.passport.serializeUser(function(user, done) {
-                                    done(null, user);
-                                });
-                                req.passport.deserializeUser(function(user, done) {
-                                    done(null, user);
-                                });
+                            // add this in
+                            req.passport = req._passport.instance;
 
-                                next();
+                            // passport - serialize and deserialize
+                            req.passport.serializeUser(function(user, done) {
+                                done(null, user);
+                            });
+                            req.passport.deserializeUser(function(user, done) {
+                                done(null, user);
                             });
 
-                            // passport session
-                            if (initializedSession)
-                            {
-                                app.use(function(req, res, next) {
-                                    req.passport.session()(req, res, next);
-                                });
-                            }
+                            next();
+                        });
+
+                        // passport session
+                        if (initializedSession)
+                        {
+                            app.use(function(req, res, next) {
+                                req.passport.session()(req, res, next);
+                            });
+                        }
 
-                            // welcome files
-                            main.welcome(app);
+                        // welcome files
+                        main.welcome(app);
 
-                            // configure cloudcms app server command handing
-                            main.interceptors(app, true);
+                        // configure cloudcms app server command handing
+                        main.interceptors(app, true);
 
-                            //app.use(app.router);
+                        //app.use(app.router);
 
-                            // healthcheck middleware
-                            main.healthcheck(app);
+                        // healthcheck middleware
+                        main.healthcheck(app);
 
-                            // APPLY CUSTOM ROUTES
-                            runFunctions(config.routeFunctions, [app], function (err) {
+                        // APPLY CUSTOM ROUTES
+                        runFunctions(config.routeFunctions, [app], function (err) {
 
-                                // configure cloudcms app server handlers
-                                main.handlers(app, true);
+                            // configure cloudcms app server handlers
+                            main.handlers(app, true);
 
-                                // register error functions
-                                runFunctions(config.errorFunctions, [app], function (err) {
+                            // register error functions
+                            runFunctions(config.errorFunctions, [app], function (err) {
 
-                                    // APPLY CUSTOM CONFIGURE FUNCTIONS
-                                    var allConfigureFunctions = [];
-                                    for (var env in config.configureFunctions)
+                                // APPLY CUSTOM CONFIGURE FUNCTIONS
+                                var allConfigureFunctions = [];
+                                for (var env in config.configureFunctions)
+                                {
+                                    var functions = config.configureFunctions[env];
+                                    if (functions)
                                     {
-                                        var functions = config.configureFunctions[env];
-                                        if (functions)
+                                        for (var i = 0; i < functions.length; i++)
                                         {
-                                            for (var i = 0; i < functions.length; i++)
-                                            {
-                                                allConfigureFunctions.push(functions[i]);
-                                            }
+                                            allConfigureFunctions.push(functions[i]);
                                         }
                                     }
-                                    runFunctions(allConfigureFunctions, [app], function (err) {
-
-                                        ////////////////////////////////////////////////////////////////////////////
-                                        //
-                                        // INITIALIZE THE SERVER
-                                        //
-                                        ////////////////////////////////////////////////////////////////////////////
-
-
-                                        // create the server (either HTTP or HTTPS)
-                                        var httpServer = null;
-                                        if (process.configuration.https) {
-                                            // configure helmet to support auto-upgrade of http->https
-                                            app.use(helmet());
-                                            // create https server
-                                            httpServer = https.createServer(process.configuration.https, app);
-                                        } else {
-                                            // legacy
-                                            httpServer = http.Server(app);
-                                        }
+                                }
+                                runFunctions(allConfigureFunctions, [app], function (err) {
 
-                                        // request timeout
-                                        var requestTimeout = 30000; // 30 seconds
-                                        if (process.configuration && process.configuration.timeout)
-                                        {
-                                            requestTimeout = process.configuration.timeout;
+                                    // create the server (either HTTP or HTTPS)
+                                    createHttpServer(app, function(err, httpServer) {
+                                        
+                                        if (err) {
+                                            return startServerFinishedFn(err);
                                         }
-                                        httpServer.setTimeout(requestTimeout);
-
-                                        // socket
-                                        httpServer.on("connection", function (socket) {
-                                            socket.setNoDelay(true);
-                                        });
-                                        const { Server } = require("socket.io");
-                                        var io = process.IO = new Server(httpServer);
-                                        //io.set('transports', config.socketTransports);
-                                        io.use(function (socket, next) {
-
-                                            // console.log("New socket being initialized");
-
-                                            // attach _log function
-                                            socket._log = function (text) {
-
-                                                var host = socket.handshake.headers.host;
-                                                if (socket.handshake.headers["x-forwarded-host"])
-                                                {
-                                                    host = socket.handshake.headers["x-forwarded-host"];
-                                                }
-
-                                                var d = new Date();
-                                                var dateString = d.toDateString();
-                                                var timeString = d.toTimeString();
-
-                                                // gray color
-                                                var grayColor = "\x1b[90m";
-
-                                                // final color
-                                                var finalColor = "\x1b[0m";
-
-                                                if (process.env.CLOUDCMS_APPSERVER_MODE === "production")
-                                                {
-                                                    grayColor = "";
-                                                    finalColor = "";
-                                                }
-
-                                                var message = '';
-                                                message += grayColor + '<socket> ';
-                                                message += grayColor + '[' + dateString + ' ' + timeString + '] ';
-                                                message += grayColor + host + ' ';
-                                                message += grayColor + text + '';
-                                                message += finalColor;
-
-                                                console.log(message);
-                                            };
-                                            /*
-                                            socket.on("connect", function () {
-                                                console.log("Socket connect()");
-                                            });
-                                            */
-                                            /*
-                                            socket.on("disconnect", function () {
-                                                var message = "Socket disconnected";
-                                                if (socket && socket.host)
-                                                {
-                                                    message += ", host=" + socket.host;
-                                                }
-                                                if (socket && socket.gitana && socket.gitana.application && socket.gitana.application())
-                                                {
-                                                    message += ", application=" + socket.gitana.application().title;
-                                                }
-                                                console.log(message);
-                                            });
-                                            */
-
-                                            // APPLY CUSTOM SOCKET.IO CONFIG
-                                            runFunctions(config.socketFunctions, [socket], function (err) {
-
-                                                require("../middleware/awareness/awareness").initSocketIO(function() {
-                                                    next();
-                                                });
-
-                                                // INSIGHT SERVER
-                                                // if (config.insight && config.insight.enabled)
-                                                // {
-                                                //     console.log("Init Insight to Socket");
-
-                                                //     require("../insight/insight").init(socket, function () {
-                                                //         next();
-                                                //     });
-                                                // }
-                                                // else
-                                                // {
-                                                //     next();
-                                                // }
-                                            });
-
-                                        });
-
-                                        // SET INITIAL VALUE FOR SERVER TIMESTAMP
-                                        process.env.CLOUDCMS_APPSERVER_TIMESTAMP = new Date().getTime();
-
-                                        // DUST
-                                        runFunctions(config.dustFunctions, [app, duster.getDust()], function (err) {
-
-                                            // APPLY SERVER BEFORE START FUNCTIONS
-                                            runFunctions(config.beforeFunctions, [app], function (err) {
-
-                                                httpServer._listenPort = app.get("port");
-
-                                                // AFTER SERVER START
-                                                runFunctions(config.afterFunctions, [app], function (err) {
-
-                                                    function cleanup() {
-
-                                                        if (cluster.isMaster)
-                                                        {
-                                                            console.log("");
-                                                            console.log("");
-
-                                                            console.log("Cloud CMS Module shutting down");
-
-                                                            // close server connections as cleanly as we can
-                                                            console.log(" -> Closing server connections");
-                                                        }
-
-                                                        try
-                                                        {
-                                                            httpServer.close();
-                                                        }
-                                                        catch (e)
-                                                        {
-                                                            console.log("Server.close produced error: " + JSON.stringify(e));
-                                                        }
-
-                                                        // ask toobusy to shut down as cleanly as we can
-                                                        if (cluster.isMaster)
-                                                        {
-                                                            console.log(" -> Closing toobusy monitor");
-                                                        }
-
-                                                        try
-                                                        {
-                                                            toobusy.shutdown();
-                                                        }
-                                                        catch (e)
-                                                        {
-                                                            console.log("toobusy.shutdown produced error: " + JSON.stringify(e));
-                                                        }
-
-                                                        if (cluster.isMaster)
-                                                        {
-                                                            console.log("");
-                                                        }
-
-                                                        // tell the process to exit
-                                                        process.exit();
-                                                    }
-
-                                                    // listen for kill or interrupt so that we can shut down cleanly
-                                                    process.on('SIGINT', cleanup);
-                                                    process.on('SIGTERM', cleanup);
-
-                                                    // if we are on a worker process, then inform the master that we completed
-                                                    if (process.send)
-                                                    {
-                                                        process.send("server-startup");
-                                                    }
-
-                                                    afterStartFn(app, httpServer);
-
-                                                });
-                                            });
-                                        });
+                                        
+                                        startServerFinishedFn(null, app, httpServer);
                                     });
                                 });
                             });
@@ -1312,6 +1148,202 @@ var startSlave = function(config, afterStartFn)
     });
 };
 
+var createHttpServer = function(app, done)
+{
+    // create the server (either HTTP or HTTPS)
+    var httpServer = null;
+    
+    if (process.configuration.https)
+    {
+        if (app)
+        {
+            // configure helmet to support auto-upgrade of http->https
+            app.use(helmet());
+        }
+            
+        // create https server
+        httpServer = https.createServer(process.configuration.https, app);
+    }
+    else
+    {
+        // legacy
+        httpServer = http.Server(app);
+    }
+    
+    // request timeout
+    var requestTimeout = 30000; // 30 seconds
+    if (process.configuration && process.configuration.timeout)
+    {
+        requestTimeout = process.configuration.timeout;
+    }
+    httpServer.setTimeout(requestTimeout);
+    
+    // socket
+    httpServer.on("connection", function (socket) {
+        socket.setNoDelay(true);
+    });
+    
+    done(null, httpServer);
+}
+
+var configureServer = function(config, app, httpServer, configureServerFinishedFn)
+{
+    var io = httpServer.io;
+    if (io)
+    {
+        //io.set('transports', config.socketTransports);
+        io.use(function (socket, next) {
+            
+            // console.log("New socket being initialized");
+            
+            // attach _log function
+            socket._log = function (text) {
+                
+                var host = socket.handshake.headers.host;
+                if (socket.handshake.headers["x-forwarded-host"])
+                {
+                    host = socket.handshake.headers["x-forwarded-host"];
+                }
+                
+                var d = new Date();
+                var dateString = d.toDateString();
+                var timeString = d.toTimeString();
+                
+                // gray color
+                var grayColor = "\x1b[90m";
+                
+                // final color
+                var finalColor = "\x1b[0m";
+                
+                if (process.env.CLOUDCMS_APPSERVER_MODE === "production")
+                {
+                    grayColor = "";
+                    finalColor = "";
+                }
+                
+                var message = '';
+                message += grayColor + '<socket> ';
+                message += grayColor + '[' + dateString + ' ' + timeString + '] ';
+                message += grayColor + host + ' ';
+                message += grayColor + text + '';
+                message += finalColor;
+                
+                console.log(message);
+            };
+            /*
+            socket.on("connect", function () {
+                console.log("Socket connect()");
+            });
+            */
+            /*
+            socket.on("disconnect", function () {
+                var message = "Socket disconnected";
+                if (socket && socket.host)
+                {
+                    message += ", host=" + socket.host;
+                }
+                if (socket && socket.gitana && socket.gitana.application && socket.gitana.application())
+                {
+                    message += ", application=" + socket.gitana.application().title;
+                }
+                console.log(message);
+            });
+            */
+            
+            // APPLY CUSTOM SOCKET.IO CONFIG
+            runFunctions(config.socketFunctions, [socket], function (err) {
+                
+                require("../middleware/awareness/awareness").initSocketIO(function() {
+                    next();
+                });
+                
+                // INSIGHT SERVER
+                // if (config.insight && config.insight.enabled)
+                // {
+                //     console.log("Init Insight to Socket");
+                
+                //     require("../insight/insight").init(socket, function () {
+                //         next();
+                //     });
+                // }
+                // else
+                // {
+                //     next();
+                // }
+            });
+            
+        });
+    }
+    
+    // SET INITIAL VALUE FOR SERVER TIMESTAMP
+    process.env.CLOUDCMS_APPSERVER_TIMESTAMP = new Date().getTime();
+    
+    // DUST
+    runFunctions(config.dustFunctions, [app, duster.getDust()], function (err) {
+        
+        // APPLY SERVER BEFORE START FUNCTIONS
+        runFunctions(config.beforeFunctions, [app], function (err) {
+            
+            // AFTER SERVER START
+            runFunctions(config.afterFunctions, [app], function (err) {
+                
+                function cleanup() {
+                    
+                    if (cluster.isMaster)
+                    {
+                        console.log("");
+                        console.log("");
+                        
+                        console.log("Cloud CMS Module shutting down");
+                        
+                        // close server connections as cleanly as we can
+                        console.log(" -> Closing server connections");
+                    }
+                    
+                    try
+                    {
+                        httpServer.close();
+                    }
+                    catch (e)
+                    {
+                        console.log("Server.close produced error: " + JSON.stringify(e));
+                    }
+                    
+                    // ask toobusy to shut down as cleanly as we can
+                    if (cluster.isMaster)
+                    {
+                        console.log(" -> Closing toobusy monitor");
+                    }
+                    
+                    try
+                    {
+                        toobusy.shutdown();
+                    }
+                    catch (e)
+                    {
+                        console.log("toobusy.shutdown produced error: " + JSON.stringify(e));
+                    }
+                    
+                    if (cluster.isMaster)
+                    {
+                        console.log("");
+                    }
+                    
+                    // tell the process to exit
+                    process.exit();
+                }
+                
+                // listen for kill or interrupt so that we can shut down cleanly
+                process.on('SIGINT', cleanup);
+                process.on('SIGTERM', cleanup);
+                
+                configureServerFinishedFn();
+            });
+        });
+    });
+};
+
+
 
 ////////////////////////////////////////////////////////////////////////////
 //