cloudcms-server 3.2.304 → 3.2.306

package/duster/helpers/core/engine.js

@@ -1231,7 +1231,7 @@ module.exports = function(app, dust)
                             "config": {}
                         };
 
-                        var divId = formId || "form" + new Date().getTime();
+                        var divId = formId || "form" + Date.now();
                         
                         chunk.write("<div id='" + divId + "'></div>");
                         chunk.write("<script src='/_lib/formhelper/formhelper.js'></script>");

package/duster/index.js

@@ -218,9 +218,9 @@ exports.execute = function(req, store, filePath, model, callback)
     var executeTemplate = function(template, templatePath, context, callback)
     {
         // execute template
-        var t1 = new Date().getTime();
+        var t1 = Date.now();
         dust.render(template, context, function(err, out) {
-            var t2 = new Date().getTime();
+            var t2 = Date.now();
 
             if (err)
             {

package/framework/controllers.js

@@ -160,7 +160,7 @@ var handleInvalidate = function(req, res)
     trigger("invalidate");
 
     // new timestamp
-    process.env.CLOUDCMS_APPSERVER_TIMESTAMP = new Date().getTime();
+    process.env.CLOUDCMS_APPSERVER_TIMESTAMP = Date.now();
 
     // // update all socket clients
     // process.IO.sockets.emit("timestamp", {

package/index.js

@@ -39,6 +39,9 @@ process.defaultKeepAliveMs = (3 * 60 * 1000);
 // default http timeout (2 minutes)
 process.defaultHttpTimeoutMs = 2 * 60 * 1000;
 
+// default exclusive lock timeout (2 minutes)
+process.defaultExclusiveLockTimeoutMs = 2 * 60 * 1000;
+
 if (process.env.DEFAULT_HTTP_TIMEOUT_MS)
 {
     try
@@ -63,7 +66,7 @@ var HttpKeepAliveAgent = require('agentkeepalive');
 var HttpsKeepAliveAgent = require('agentkeepalive').HttpsAgent;
 http.globalAgent = new HttpKeepAliveAgent({
     keepAlive: true,
-    keepAliveMsecs: 30000,
+    keepAliveMsecs: process.defaultKeepAliveMs,
     maxSockets: 24000,
     maxFreeSockets: 256,
     timeout: process.defaultHttpTimeoutMs,
@@ -71,7 +74,7 @@ http.globalAgent = new HttpKeepAliveAgent({
 });
 https.globalAgent = new HttpsKeepAliveAgent({
     keepAlive: true,
-    keepAliveMsecs: 30000,
+    keepAliveMsecs: process.defaultKeepAliveMs,
     maxSockets: 24000,
     maxFreeSockets: 256,
     timeout: process.defaultHttpTimeoutMs,

package/middleware/authentication/authentication.js

@@ -695,11 +695,11 @@ exports = module.exports = function()
         return function(req, res, next) {
 
             // record filter start time
-            var _auth_filter_start_ms = new Date().getTime();
+            var _auth_filter_start_ms = Date.now();
 
             fn(req, res, function(result, authenticator) {
 
-                var _auth_filter_end_ms = new Date().getTime() - _auth_filter_start_ms;
+                var _auth_filter_end_ms = Date.now() - _auth_filter_start_ms;
 
                 util.setHeader(res, "x-cloudcms-auth-filter-ms", _auth_filter_end_ms);
 
@@ -736,8 +736,11 @@ exports = module.exports = function()
                         };
                     }
 
-                    if (result.err && result.err.message) {
-                        req.log("Auth strategy: " + strategyId + " - filter error: " + result.err.message);
+                    if (!result.skip)
+                    {
+                        if (result.err && result.err.message) {
+                            req.log("Auth strategy: " + strategyId + " - filter error: " + result.err.message);
+                        }
                     }
 
                     var providerId = null;

package/middleware/awareness/awareness.js

@@ -333,7 +333,7 @@ exports = module.exports = function()
         var reap = function() {
 
             // reap anything before a calculated time in the past
-            var beforeMs = new Date().getTime() - maxAgeMs;
+            var beforeMs = Date.now() - maxAgeMs;
 
             // run expirations
             expire(beforeMs, function(err, updatedMembershipChannelIds, expiredUserIdsByChannelId) {

package/middleware/awareness/providers/abstract-async.js

@@ -81,7 +81,7 @@ class AbstractAsyncProvider extends AbstractProvider
         
             channel.users[user.id] = {
                 "user": user,
-                "time": new Date().getTime()
+                "time": Date.now()
             };
             
             self.writeChannel(channelId, channel, function (err) {

package/middleware/cache/cache.js

@@ -53,11 +53,16 @@ exports = module.exports = function()
         provider.init(function(err) {
 
             // global caches
-            process.deploymentDescriptorCache = createNamespacedCache.call(r, "descriptors");
+            process.deploymentDescriptorCache = createNamespacedCache.call(r, "descriptors", {
+                "seconds": 5 * 60 // 5 minutes (5 minutes * (60 seconds / minute) = 300 seconds)
+            });
             process.driverConfigCache = createNamespacedCache.call(r, "driverconfigs", {
                 "seconds": 5 * 60 // 5 minutes (5 minutes * (60 seconds / minute) = 300 seconds)
             });
             process.subKeyMapCache = createNamespacedCache.call(r, "keyMap");
+            process.runtimeCache = createNamespacedCache.call(r, "runtimes", {
+                "seconds": 5 * 60 // 5 minutes (5 minutes * (60 seconds / minute) = 300 seconds)
+            });
 
             // subscribe to node invalidation broadcast events
             process.broadcast.subscribe("node_invalidation", function (message, channel, invalidationDone) {

package/middleware/cache/providers/memory.js

@@ -26,7 +26,7 @@ exports = module.exports = function(cacheConfig)
 
         if (seconds > -1)
         {
-            expirationTimeMap[key] = new Date().getTime() + (seconds * 1000);
+            expirationTimeMap[key] = Date.now() + (seconds * 1000);
         }
 
         callback();
@@ -39,7 +39,7 @@ exports = module.exports = function(cacheConfig)
         var expirationTime = expirationTimeMap[key];
         if (expirationTime)
         {
-            var now = new Date().getTime();
+            var now = Date.now();
             if (now > expirationTime)
             {
                 delete valueMap[key];

package/middleware/cloudcms/cloudcms.js

@@ -729,7 +729,7 @@ exports = module.exports = function()
 
                             var cacheKey = cacheSettingsKey(application.ref(), "application", "application");
 
-                            var nowMs = new Date().getTime();
+                            var nowMs = Date.now();
 
                             var timestamp = CACHED_APP_SETTINGS_TIMESTAMPS[cacheKey];
                             if (!timestamp || (nowMs - timestamp > CACHED_APP_SETTINGS_TTL))

package/middleware/config/adapter.js

@@ -376,7 +376,7 @@ module.exports = function(configStore)
 
                         _watchLog("Detected changes on disk - reloading...");
 
-                        var t1 = new Date().getTime();
+                        var t1 = Date.now();
 
                         // reload context
                         loadContext(function (err, context) {
@@ -390,7 +390,7 @@ module.exports = function(configStore)
                                 compileContextToRegistry(context);
                                 registry.reloadContext(context);
 
-                                var t2 = new Date().getTime();
+                                var t2 = Date.now();
                                 _watchLog("Reloaded context in: " + (t2 - t1) + " ms");
                             }
                             catch (e)

package/middleware/driver/driver.js

@@ -3,6 +3,8 @@ var http = require('http');
 var util = require("../../util/util");
 var async = require("async");
 
+var Loaders = require("../../util/loaders");
+
 var Gitana = require("gitana");
 
 ////////////////////////////////////////////////////////////////////////////
@@ -38,6 +40,27 @@ exports = module.exports = function()
     var r = {};
 
     var doConnect = r.doConnect = function(req, gitanaConfig, callback)
+    {
+        var key = JSON.stringify(gitanaConfig);
+
+        var loader = function(req, gitanaConfig)
+        {
+            return function(cb)
+            {
+                _doConnect(req, gitanaConfig, function(err) {
+                    cb.call(this, err);
+                });
+            }
+        }(req, gitanaConfig);
+
+        var exclusiveLoader = Loaders.exclusive(loader, key, process.defaultExclusiveLockTimeoutMs);
+
+        exclusiveLoader(function(err) {
+            callback.call(this, err);
+        });
+    };
+
+    var _doConnect = function(req, gitanaConfig, callback)
     {
         // either connect anew or re-use an existing connection to Cloud CMS for this application
         Gitana.connect(gitanaConfig, function(err) {
@@ -45,7 +68,7 @@ exports = module.exports = function()
             if (err)
             {
                 // log as much as we can
-                if(process.env.NODE_ENV === "production")
+                if (process.env.NODE_ENV === "production")
                 {
                     console.warn("Error connecting driver (domainHost=" + req.domainHost + ", virtualHost: " + req.virtualHost + ", err: " + JSON.stringify(err));
                 }
@@ -90,7 +113,7 @@ exports = module.exports = function()
                     var rootStore = req.stores.root;
 
                     var originalFilename = "gitana.json";
-                    var backupFilename = "gitana.json.backup-" + new Date().getTime();
+                    var backupFilename = "gitana.json.backup-" + Date.now();
 
                     console.log("Backing up: gitana.json to: " + backupFilename);
                     rootStore.writeFile(backupFilename, JSON.stringify(gitanaConfig, null, "  "), function(err) {

package/middleware/locale/locale.js

@@ -16,7 +16,7 @@ exports = module.exports = function()
      */
     r.localeInterceptor = function()
     {
-        return function(req, res, next)
+        return function locale(req, res, next)
         {
             var acceptLanguage = "en-us"
 

package/middleware/proxy/proxy.js

@@ -110,7 +110,7 @@ exports = module.exports = function()
 
                     var cacheInfo = JSON.parse(cacheInfoText);
                     var expireTime = cacheInfo.expireTime;
-                    if (new Date().getTime() > expireTime)
+                    if (Date.now() > expireTime)
                     {
                         handleBadStream();
                     }
@@ -196,7 +196,7 @@ exports = module.exports = function()
 
                 // write a cache info file as well
                 var cacheInfo = {
-                    "expireTime": new Date().getTime() + cacheTTL
+                    "expireTime": Date.now() + cacheTTL
                 };
                 contentStore.writeFile(filePath + ".cache", JSON.stringify(cacheInfo), function() {
                     _end.call(res, data, encoding);

package/middleware/runtime/runtime.js

@@ -4,6 +4,8 @@ var http = require('http');
 var util = require("../../util/util");
 var Gitana = require("gitana");
 
+var Loaders = require("../../util/loaders");
+
 /**
  * Runtime middleware.
  *
@@ -56,7 +58,7 @@ exports = module.exports = function()
         var data = {};
 
         // generate a cache buster (in case we're in production mode)
-        data.cb = new Date().getTime();
+        data.cb = Date.now();
         if (json.cb) {
             data.cb = json.cb;
         }
@@ -162,63 +164,87 @@ exports = module.exports = function()
      */
     r.interceptor = function()
     {
-        return util.createInterceptor("runtime", function(req, res, next, stores, cache, configuration) {
-
+        var loadRuntime = function(req, res, callback)
+        {
             var store = req.stores.content;
+            var key = store.id;
 
-            store.existsFile("runtime.json", function(exists) {
-
-                if (exists)
+            // define the loader (loads runtime)
+            var loader = function(store)
+            {
+                return function(cb)
                 {
-                    store.readFile("runtime.json", function(err, data) {
+                    store.existsFile("runtime.json", function(exists) {
 
-                        if (err) {
-                            req.log("Error loading runtime.json");
-                            return next();
-                        }
+                        if (exists)
+                        {
+                            store.readFile("runtime.json", function (err, data) {
+
+                                if (err) {
+                                    return cb(err);
+                                }
 
-                        req.runtime = JSON.parse(data);
-                        next();
+                                return cb(null, JSON.parse(data));
+                            });
+                        }
+                        else
+                        {
+                            // write initial file
+
+                            var runtime = {};
+
+                            // cache buster (cb)
+                            runtime.cb = Date.now();
+                            if (process.env.CLOUDCMS_RUNTIME_CB) {
+                                runtime.cb = process.env.CLOUDCMS_RUNTIME_CB;
+                            }
+
+                            // release id
+                            runtime.releaseId = null;
+                            if (process.env.CLOUDCMS_RUNTIME_RELEASE_ID) {
+                                runtime.releaseId = process.env.CLOUDCMS_RUNTIME_RELEASE_ID;
+                            }
+
+                            // branch id
+                            runtime.branchId = null;
+                            if (process.env.CLOUDCMS_RUNTIME_BRANCH_ID) {
+                                runtime.branchId = process.env.CLOUDCMS_RUNTIME_BRANCH_ID;
+                            }
+
+                            // don't bother writing to disk if we don't have any state to set
+                            if (!runtime.releaseId && !runtime.branchId) {
+                                return cb(null, runtime);
+                            }
+
+                            // create runtime file
+                            store.writeFile("runtime.json", JSON.stringify(runtime, null, 2), function (err) {
+                                return cb(null, runtime);
+                            });
+                        }
                     });
                 }
-                else
-                {
-                    // write initial file
+            }(store);
 
-                    var data = {};
+            // wrap loader with caching + an exclusive lock
+            var cachedLoader = Loaders.cached(loader, process.runtimeCache, key);
+            var exclusiveLoader = Loaders.exclusive(cachedLoader, key, process.defaultExclusiveLockTimeoutMs);
 
-                    // cache buster (cb)
-                    data.cb = new Date().getTime();
-                    if (process.env.CLOUDCMS_RUNTIME_CB) {
-                        data.cb = process.env.CLOUDCMS_RUNTIME_CB;
-                    }
-
-                    // release id
-                    data.releaseId = null;
-                    if (process.env.CLOUDCMS_RUNTIME_RELEASE_ID) {
-                        data.releaseId = process.env.CLOUDCMS_RUNTIME_RELEASE_ID;
-                    }
-
-                    // branch id
-                    data.branchId = null;
-                    if (process.env.CLOUDCMS_RUNTIME_BRANCH_ID) {
-                        data.branchId = process.env.CLOUDCMS_RUNTIME_BRANCH_ID;
-                    }
-
-                    // don't bother writing if we don't have anything to persist
-                    if (!data.releaseId && !data.branchId)
-                    {
-                        req.runtime = data;
-                        next();
-                    }
-
-                    // create runtime file
-                    store.writeFile("runtime.json", JSON.stringify(data, null, "  "), function(err) {
-                        req.runtime = data;
-                        next();
-                    });
+            exclusiveLoader(callback);
+        };
+
+        return util.createInterceptor("runtime", function(req, res, next, stores, cache, configuration) {
+
+            loadRuntime(req, res, function(err, runtime) {
+
+                if (err) {
+                    req.log("Error loading runtime");
+                    req.log(err);
+                    return next();
                 }
-            })
+
+                req.runtime = runtime;
+                next();
+            });
         });
     };
 

package/middleware/stores/store.js

@@ -16,12 +16,12 @@ exports = module.exports = function(engine, engineType, engineId, engineConfigur
     var debugStart = function(text) {
         if (DEBUG_LOG) {
             console.log("[" + engineId + "] " + text);
-            t1 = new Date().getTime();
+            t1 = Date.now();
         }
     };
     var debugFinish = function(text) {
         if (DEBUG_LOG) {
-            t2 = new Date().getTime();
+            t2 = Date.now();
             console.log("[" + engineId + "] " + text + ": " + (t2-t1) + " ms");
         }
     };

package/middleware/stores/stores.js

@@ -144,13 +144,13 @@ exports = module.exports = function()
             else if (stores)
             {
                 CACHED_STORES_BY_HOST[host] = stores;
-                CACHED_STORES_EXPIRATION_MS_BY_HOST[host] = new Date().getTime() + TTL_MS;
+                CACHED_STORES_EXPIRATION_MS_BY_HOST[host] = Date.now() + TTL_MS;
             }
 
             var val = CACHED_STORES_BY_HOST[host];
 
             var expTime = CACHED_STORES_EXPIRATION_MS_BY_HOST[host];
-            if (expTime && new Date().getTime() > expTime)
+            if (expTime && Date.now() > expTime)
             {
                 delete CACHED_STORES_BY_HOST[host];
                 delete CACHED_STORES_EXPIRATION_MS_BY_HOST[host];

package/middleware/virtual-config/virtual-config.js

@@ -399,14 +399,13 @@ exports = module.exports = function()
                             process.driverConfigCache.write(req.virtualHost, {
                                 "config": gitanaConfig
                             }, function (err) {
-                                completionFunction(null, gitanaConfig);
+                                completionFunction(err, gitanaConfig);
                             });
                         }
                         else
                         {
                             // mark with sentinel
-                            process.driverConfigCache.write(req.virtualHost, SENTINEL_NOT_FOUND_VALUE, 5, function (err)
-                            {
+                            process.driverConfigCache.write(req.virtualHost, SENTINEL_NOT_FOUND_VALUE, 5, function (err) {
                                 completionFunction();
                             });
                         }

package/middleware/virtual-files/virtual-files.js

@@ -8,23 +8,26 @@ var util = require("../../util/util");
  */
 exports = module.exports = function()
 {
+    var SENTINEL_NOT_FOUND_VALUE = "null";
+
     var r = {};
 
-    r.interceptor = function() {
-        return util.createInterceptor("virtualHost", function (req, res, next, stores, cache, configuration) {
+    r.interceptor = function()
+    {
+        return util.createInterceptor("virtualFiles", function (req, res, next, stores, cache, configuration) {
 
             var completionFunction = function (err, descriptor) {
 
                 if (err) {
+                    console.log("ERR: ", err);
+
                     // something went wrong
-                    next();
-                    return;
+                    return next();
                 }
 
                 if (!descriptor) {
                     // nothing found
-                    next();
-                    return;
+                    return next();
                 }
 
                 // yes, virtual host deployed, store a few interesting things on the request
@@ -53,48 +56,54 @@ exports = module.exports = function()
             // NOTE: null is a valid sentinel value (meaning none)
             process.deploymentDescriptorCache.read(req.virtualHost, function(err, descriptor) {
 
+                // check for null sentinel
+                if (descriptor === SENTINEL_NOT_FOUND_VALUE) {
+                    return completionFunction();
+                }
+
                 if (typeof(descriptor) !== "undefined" || descriptor === null) {
                     // all done
-                    completionFunction(null, descriptor);
-                    return;
+                    return completionFunction(null, descriptor);
                 }
-                else
-                {
-                    // nothing in cache, load from disk
-                    // check if there is a descriptor on disk
-                    rootStore.existsFile("descriptor.json", function (exists) {
 
-                        if (exists) {
+                // nothing in cache, load from disk
+                // check if there is a descriptor on disk
+                rootStore.existsFile("descriptor.json", function (exists) {
 
-                            // load the descriptor
-                            rootStore.readFile("descriptor.json", function (err, descriptor) {
+                    if (exists) {
 
-                                if (err) {
-                                    // no file descriptor, virtual files not deployed
-                                    next();
-                                    return;
-                                }
+                        // load the descriptor
+                        rootStore.readFile("descriptor.json", function (err, descriptor) {
 
-                                // yes, there is a descriptor, so we have virtual files
+                            if (err) {
+                                // no file descriptor, virtual files not deployed
+                                next();
+                                return;
+                            }
 
-                                // convert descriptor to JSON
-                                descriptor = JSON.parse(descriptor);
+                            // yes, there is a descriptor, so we have virtual files
 
-                                // CACHE: write
-                                process.deploymentDescriptorCache.write(req.virtualHost, descriptor, function() {
+                            // convert descriptor to JSON
+                            descriptor = JSON.parse(descriptor);
 
-                                    // all done
-                                    completionFunction(null, descriptor);
+                            // CACHE: write
+                            process.deploymentDescriptorCache.write(req.virtualHost, descriptor, function() {
 
-                                });
+                                // all done
+                                completionFunction(null, descriptor);
 
                             });
-                        }
-                        else {
+
+                        });
+                    }
+                    else
+                    {
+                        // write null sentinel and return nothing
+                        process.deploymentDescriptorCache.write(req.virtualHost, SENTINEL_NOT_FOUND_VALUE, function() {
                             completionFunction();
-                        }
-                    });
-                }
+                        });
+                    }
+                });
             });
 
         });

package/middleware/wcm/wcm.js

@@ -272,7 +272,7 @@ exports = module.exports = function()
 
         ensureInvalidate(function() {
 
-            var now = new Date().getTime();
+            var now = Date.now();
 
             req.cache.read(WCM_PAGES, function (err, cachedPages) {
                 req.cache.read(WCM_PAGES_CACHE_TIME, function(err, cachedPagesTime) {
@@ -356,7 +356,7 @@ exports = module.exports = function()
                                             {
                                                 req.log("Falling back to using cached pages, will retain for " + WCM_PAGES_CACHE_RETRY_TIME_MS + " ms before trying again");
                                                 req.cache.write(WCM_PAGES_CACHE_TIME, {
-                                                    "ms": (new Date().getTime() + WCM_PAGES_CACHE_RETRY_TIME_MS)
+                                                    "ms": (Date.now() + WCM_PAGES_CACHE_RETRY_TIME_MS)
                                                 });
 
                                                 return finished(null, cachedPages);
@@ -386,7 +386,7 @@ exports = module.exports = function()
                                         // build out pages
                                         var loadedPages = {};
 
-                                        var queryTimeMs = new Date().getTime();
+                                        var queryTimeMs = Date.now();
 
                                         branch.trap(function (err) {
 

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "cloudcms-server",
   "description": "Cloud CMS Application Server Module",
-  "version": "3.2.304",
+  "version": "3.2.306",
   "repository": {
     "type": "git",
     "url": "git://github.com/gitana/cloudcms-server.git"
@@ -20,7 +20,7 @@
     "alpaca": "^1.5.27",
     "archiver": "^1.3.0",
     "async": "^3.2.3",
-    "async-lock": "^1.3.2",
+    "async-lock": "^1.4.1",
     "aws-sdk": "^2.1208.0",
     "axios": "^1.5.0",
     "basic-auth": "^2.0.1",

package/server/index.js

@@ -760,6 +760,47 @@ var startServer = function(config, startServerFinishedFn)
 {
     var app = express();
     app.disable('x-powered-by');
+
+    // customize the app use() method to provide sensible logging
+    app._use = app.use;
+    app.use = function(f)
+    {
+        if (typeof(f) !== "function")
+        {
+            return app._use.apply(app, arguments);
+        }
+
+        return app._use(function(f) {
+            return function(req, res, next)
+            {
+                var functionName = f.name;
+                if (!functionName) {
+                    functionName = "unknown";
+                }
+
+                var id = req.id;
+
+                var startTime = process.hrtime();
+
+                f(req, res, function() {
+                    var totalTime = process.hrtime(startTime);
+                    var totalTimeMs = (totalTime[1] / 1000000).toFixed(2);
+                    if (totalTimeMs > 100)
+                    {
+                        if (id)
+                        {
+                            console.log("[" + id + "](" + functionName + ") time: " + totalTimeMs);
+                        }
+
+                        //console.trace();
+                        //process.exit(-1);
+                    }
+
+                    next();
+                });
+            }
+        }(f));
+    };
     
     initSession(function(err, initializedSession) {
 
@@ -873,7 +914,7 @@ var startServer = function(config, startServerFinishedFn)
     
                     return message;
                 });
-    
+
                 /*
                 // debug headers being set
                 app.use(function(req, res, next) {
@@ -887,7 +928,7 @@ var startServer = function(config, startServerFinishedFn)
                 */
     
                 // increment and assign request id
-                app.use(function (req, res, next) {
+                app.use(function increment_and_assign_id(req, res, next) {
                     requestCounter++;
                     req.id = requestCounter;
                     next();
@@ -897,7 +938,7 @@ var startServer = function(config, startServerFinishedFn)
                 runFunctions(config.initFunctions, [app], function (err) {
     
                     // retain originalUrl and originalPath since these can get modified along the way
-                    app.use(function (req, res, next) {
+                    app.use(function retain_original_url_path(req, res, next) {
                         req.originalUrl = req.url;
                         req.originalPath = req.path;
                         next();
@@ -907,7 +948,7 @@ var startServer = function(config, startServerFinishedFn)
                     app.use(requestParam);
     
                     // add req.log function
-                    app.use(function (req, res, next) {
+                    app.use(function bind_req_log(req, res, next) {
     
                         req._log = req.log = function (text/*, warn*/) {
     
@@ -1171,7 +1212,9 @@ var createHttpServer = function(app, done)
         try { socket.end(); } catch (e) { }
         try { socket.destroy(); } catch (e) { }
     });
-    
+
+    var c = 0;
+
     // socket
     httpServer.on("connection", function (socket) {
         socket.setNoDelay(true);
@@ -1275,7 +1318,7 @@ var configureServer = function(config, app, httpServer, configureServerFinishedF
     }
     
     // SET INITIAL VALUE FOR SERVER TIMESTAMP
-    process.env.CLOUDCMS_APPSERVER_TIMESTAMP = new Date().getTime();
+    process.env.CLOUDCMS_APPSERVER_TIMESTAMP = Date.now();
     
     // DUST
     runFunctions(config.dustFunctions, [app, duster.getDust()], function (err) {

package/util/loaders.js

@@ -0,0 +1,99 @@
+var exports = module.exports;
+
+var AsyncLock = require("async-lock");
+
+var SENTINEL_NOT_FOUND_VALUE = "null";
+
+/**
+ * Applies caching to a loader.
+ *
+ * A loader function is invoked like:
+ *
+ *    loader(function(err, value) {
+ *
+ *    });
+ *
+ * Its job is to load something from a remote place and then fire the callback.
+ *
+ * This method wraps caching around the loader for the given key.  It returns a new loader
+ * that checks a given cache (key) for a value ahead of invoking the actual underlying loader.
+ *
+ * @param loader
+ * @param cache
+ * @param key
+ */
+exports.cached = function(loader, cache, key)
+{
+    return function(callback)
+    {
+        cache.read(key, function(err, value) {
+
+            if (value === SENTINEL_NOT_FOUND_VALUE) {
+                return callback();
+            }
+
+            if (value) {
+                return callback(null, value);
+            }
+
+            loader(function(err, value) {
+
+                if (err) {
+                    return callback(err);
+                }
+
+                if (!value) {
+                    return cache.write(key, SENTINEL_NOT_FOUND_VALUE, function () {
+                        callback();
+                    });
+                }
+
+                // write to cache
+                return cache.write(key, value, function () {
+                    callback.call(this, null, value);
+                });
+            });
+        });
+    };
+};
+
+var lock = new AsyncLock();
+
+/**
+ * Applies caching to a loader.
+ *
+ * A loader function is invoked like:
+ *
+ *    loader(function(err, value) {
+ *
+ *    });
+ *
+ * Its job is to load something from a remote place and then fire the callback.
+ *
+ * This method wraps an exclusive mutex lock around the given loader.  This makes it so that only one
+ * invocation of this loader may run per key within the event loop.
+ *
+ * @param loader
+ * @param key
+ */
+exports.exclusive = function(loader, key, timeout)
+{
+    return function(callback)
+    {
+        var opts = {};
+        // up to 50000 tasks in the queue
+        opts.maxPending = 50000;
+        if (timeout) {
+            opts.timeout = timeout;
+        }
+
+        lock.acquire(key, function(releaseFn) {
+            loader(function(err, value) {
+                setTimeout(function() {
+                    releaseFn();
+                }, 0);
+                callback.call(this, err, value);
+            });
+        }, opts);
+    };
+};

package/util/util.js

@@ -700,11 +700,8 @@ var retryGitanaRequest = exports.retryGitanaRequest = function(logMethod, gitana
         config.headers["Authorization"] = headers2["Authorization"];
 
         // make the request
-        console.log("C: " + JSON.stringify(config, null, 2));
         request(config, function(err, response, body) {
-            console.log("E: " + err);
-            console.log("B: " + body);
-            
+
             if (response)
             {
                 // ok case (just callback)
@@ -850,43 +847,42 @@ var pluck = exports.pluck = function(list, propertyPath)
 //
 /////////////////////////////////////////////////////////////////////////////////////////////
 
-// global pool of interceptor timings
-process.timings = {};
-var incrementTimings = function(req, family, id, time)
-{
-    var increment = function(map, family, id, time)
-    {
-        var key = family + ":" + id;
-
-        // interceptor timings
-        if (!map[key]) {
-            map[key] = {
-                count: 0,
-                total: 0,
-                avg: 0
-            };
-        }
-
-        map[key].count++;
-        map[key].total += time;
-        map[key].avg = map[key].total / map[key].count;
-        map[key].avg = map[key].avg.toFixed(2);
-    };
-
-    // increment global timings
-    increment(process.timings, family, id, time);
-
-    // increment request timings
-    if (!req.timings) {
-        req.timings = {};
-    }
-    increment(req.timings, family, id, time);
-};
-
-var getGlobalTimings = exports.getGlobalTimings = function()
-{
-    return process.timings;
-};
+// // global pool of interceptor timings
+// var incrementTimings = function(req, family, id, time)
+// {
+//     var increment = function(map, family, id, time)
+//     {
+//         var key = family + ":" + id;
+//
+//         // interceptor timings
+//         if (!map[key]) {
+//             map[key] = {
+//                 count: 0,
+//                 total: 0,
+//                 avg: 0
+//             };
+//         }
+//
+//         map[key].count++;
+//         map[key].total += time;
+//         map[key].avg = map[key].total / map[key].count;
+//         map[key].avg = map[key].avg.toFixed(2);
+//     };
+//
+//     // increment global timings
+//     increment(process.timings, family, id, time);
+//
+//     // increment request timings
+//     if (!req.timings) {
+//         req.timings = {};
+//     }
+//     increment(req.timings, family, id, time);
+// };
+//
+// var getGlobalTimings = exports.getGlobalTimings = function()
+// {
+//     return process.timings;
+// };
 
 
 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -895,7 +891,6 @@ var getGlobalTimings = exports.getGlobalTimings = function()
 //
 /////////////////////////////////////////////////////////////////////////////////////////////
 
-
 var createHandler = exports.createHandler = function(id, configName, fn)
 {
     if (typeof(configName) === "function") {
@@ -903,30 +898,30 @@ var createHandler = exports.createHandler = function(id, configName, fn)
         configName = id;
     }
 
-    return function(req, res, next) {
+    var func = function(req, res, next) {
 
-        var startAt = process.hrtime();
+        //var startAt = process.hrtime();
 
         // override next so that we can capture completion of interceptor
         var _next = next;
         next = function(err) {
-            if (startAt)
-            {
-                var diff = process.hrtime(startAt);
-                var time = diff[0] * 1e3 + diff[1] * 1e-6;
-                incrementTimings(req, "handler", id, time);
-                startAt = null;
-            }
+            // if (startAt)
+            // {
+            //     var diff = process.hrtime(startAt);
+            //     var time = diff[0] * 1e3 + diff[1] * 1e-6;
+            //     incrementTimings(req, "handler", id, time);
+            //     startAt = null;
+            // }
             return _next.call(_next, err);
         };
         onHeaders(res, function() {
-            if (startAt)
-            {
-                var diff = process.hrtime(startAt);
-                var time = diff[0] * 1e3 + diff[1] * 1e-6;
-                incrementTimings(req, "handler", id, time);
-                startAt = null;
-            }
+            // if (startAt)
+            // {
+            //     var diff = process.hrtime(startAt);
+            //     var time = diff[0] * 1e3 + diff[1] * 1e-6;
+            //     incrementTimings(req, "handler", id, time);
+            //     startAt = null;
+            // }
         });
 
         req.configuration(configName, function(err, handlerConfiguration) {
@@ -943,6 +938,10 @@ var createHandler = exports.createHandler = function(id, configName, fn)
             fn(req, res, next, req.stores, req.cache, handlerConfiguration);
         });
     };
+
+    Object.defineProperty(func, "name", { value: id });
+
+    return func;
 };
 
 var createInterceptor = exports.createInterceptor = function(id, configName, fn)
@@ -952,30 +951,30 @@ var createInterceptor = exports.createInterceptor = function(id, configName, fn)
         configName = id;
     }
 
-    return function(req, res, next) {
+    var func = function(req, res, next) {
 
-        var startAt = process.hrtime();
+        //var startAt = process.hrtime();
 
         // override next so that we can capture completion of interceptor
         var _next = next;
         next = function(err) {
-            if (startAt > -1)
-            {
-                var diff = process.hrtime(startAt);
-                var time = diff[0] * 1e3 + diff[1] * 1e-6;
-                incrementTimings(req, "interceptor", id, time);
-                startAt = -1;
-            }
+            // if (startAt > -1)
+            // {
+            //     var diff = process.hrtime(startAt);
+            //     var time = diff[0] * 1e3 + diff[1] * 1e-6;
+            //     incrementTimings(req, "interceptor", id, time);
+            //     startAt = -1;
+            // }
             return _next.call(_next, err);
         };
         onHeaders(res, function() {
-            if (startAt > -1)
-            {
-                var diff = process.hrtime(startAt);
-                var time = diff[0] * 1e3 + diff[1] * 1e-6;
-                incrementTimings(req, "interceptor", id, time);
-                startAt = -1;
-            }
+            // if (startAt > -1)
+            // {
+            //     var diff = process.hrtime(startAt);
+            //     var time = diff[0] * 1e3 + diff[1] * 1e-6;
+            //     incrementTimings(req, "interceptor", id, time);
+            //     startAt = -1;
+            // }
         });
 
         req.configuration(configName, function(err, interceptorConfiguration) {
@@ -992,6 +991,10 @@ var createInterceptor = exports.createInterceptor = function(id, configName, fn)
             fn(req, res, next, req.stores, req.cache, interceptorConfiguration);
         });
     };
+
+    Object.defineProperty(func, "name", { value: id });
+
+    return func;
 };
 
 var replaceAll = exports.replaceAll = function(text, find, replace)