cloudcms-server 0.9.260 → 0.9.263

package/framework/controllers.js

@@ -163,10 +163,10 @@ var handleInvalidate = function(req, res)
     // new timestamp
     process.env.CLOUDCMS_APPSERVER_TIMESTAMP = new Date().getTime();
 
-    // update all socket clients
-    process.IO.sockets.emit("timestamp", {
-        "timestamp": process.env.CLOUDCMS_APPSERVER_TIMESTAMP
-    });
+    // // update all socket clients
+    // process.IO.sockets.emit("timestamp", {
+    //     "timestamp": process.env.CLOUDCMS_APPSERVER_TIMESTAMP
+    // });
 
     console.log("Server timestamp regenerated");
 

package/launchpad/index.js

@@ -1,5 +1,18 @@
 const cluster = require("cluster");
 
+// Handle uncaught exceptions...
+process.on('uncaughtException', function(err, source) {
+    // if (err === "read ECONNRESET")
+    // {
+    //     // skip
+    // }
+    // else
+    // {
+        console.log(`Launchpad - process received event 'uncaughtException': ${err}, source: ${source}`);
+        console.log(err.stack);
+    // }
+});
+
 module.exports = function(type, config, options)
 {
     if (!type) {

package/launchpad/launchers/cluster.js

@@ -6,6 +6,9 @@ const numCPUs = require("os").cpus().length;
 const { setupMaster, setupWorker } = require("@socket.io/sticky");
 const { createAdapter, setupPrimary } = require("@socket.io/cluster-adapter");
 
+// numCPUs = 1;
+// console.log("FORCE ONE CPU");
+
 module.exports = function(config) {
     
     var r = {};
@@ -14,7 +17,7 @@ module.exports = function(config) {
     {
         // setup sticky sessions
         setupMaster(httpServer, {
-            loadBalancingMethod: "least-connection",
+            loadBalancingMethod: "least-connection"
         });
 
         // setup connections between the workers
@@ -46,14 +49,23 @@ module.exports = function(config) {
             var worker = cluster.fork(workerEnv);
             
             worker.on('message', function (msg, c) {
+                //console.log("Worker message: " + msg + ", c: " + c);
                 if (msg === "worker-startup") {
                     startupCount++;
                 }
             });
             
+            worker.on('error', function(err) {
+                console.log("Worker.on(error) - " + JSON.stringify(err));
+            });
+            
             workers.push(worker);
         }
         
+        cluster.on("error", function(err) {
+            console.log("Cluster.on(error) - " + JSON.stringify(err));
+        });
+        
         cluster.on("exit", (worker) => {
             console.log(`Worker ${worker.process.pid} died`);
             cluster.fork();
@@ -79,19 +91,25 @@ module.exports = function(config) {
         // worker
     
         const io = new Server(httpServer);
-    
+        httpServer.io = io;
+        
         // use the cluster adapter
         io.adapter(createAdapter());
     
         // setup connection with the primary process
         setupWorker(io);
-    
+        
+        // on connect
         io.on("connection", (socket) => {
             // TODO
+    
+            // always catch err
+            socket.on("error", function(err) {
+                console.log("Caught socket error");
+                console.log(err.stack);
+            });
         });
 
-        httpServer.io = io;
-
         return callback();
     };
     

package/launchpad/launchers/redis.js

@@ -1,6 +1,6 @@
 const { Server } = require("socket.io");
 const { setupWorker } = require("@socket.io/sticky");
-const { createAdapter } = require("@socket.io/cluster-adapter");
+const { createAdapter } = require("@socket.io/redis-adapter");
 const redisHelper = require("../../util/redis");
 
 const clusterLauncherFactory = require("./cluster");
@@ -23,30 +23,61 @@ module.exports = function(config) {
     
     r.afterStartServer = function(app, httpServer, callback)
     {
-        const io = new Server(httpServer);
-    
-        (async function() {
+        (async function(app, httpServer, callback) {
             var redisOptions = redisHelper.redisOptions({}, "CLOUDCMS_CLUSTER");
             await redisHelper.createAndConnect(redisOptions, function(err, _client) {
-            
+    
                 const pubClient = _client;
                 const subClient = pubClient.duplicate();
-            
-                io.adapter(createAdapter(pubClient, subClient));
-                //io.listen(httpServerPort);
-            
-                io.on("connection", (socket) => {
-                    // TODO
+    
+                pubClient.on("error", function(err) {
+                    // something went wrong
+                    console.log("Pub Client caught error: ", err);
                 });
-            
+    
+                subClient.on("error", function(err) {
+                    // something went wrong
+                    console.log("Sub Client caught error: ", err);
+                });
+    
+                const io = new Server(httpServer);
+                httpServer.io = io;
+    
+                io.engine.on("connection_error", function(err) {
+                    // console.log("CONNECTION ERROR");
+                    // console.log("REQUEST: " + err.req);      // the request object
+                    // console.log("CODE: " + err.code);     // the error code, for example 1
+                    // console.log("MESSAGE: " + err.message);  // the error message, for example "Session ID unknown"
+                    // console.log("CONTEXT: " + err.context);  // some additional error context
+                });
+    
+                // use the redis adapter
+                io.adapter(createAdapter(pubClient, subClient, {
+                    //publishOnSpecificResponseChannel: true
+                }));
+    
                 // setup connection with the primary process
                 setupWorker(io);
-            
-                httpServer.io = io;
-            
+                
+                // on connect
+                io.on("connection", (socket) => {
+                    //console.log("Redis Launcher on('connection') - socket id:" + socket.id);
+                    // socket.on('message', function(m) {
+                    //     console.log("Socket Connection message: " + m);
+                    // });
+                    //
+                    // // always catch err
+                    // socket.on("error", function(err) {
+                    //     console.log("Caught socket error");
+                    //     console.log(err.stack);
+                    // });
+                    
+                    // TODO
+                });
+                
                 return callback();
             });
-        })();
+        })(app, httpServer, callback);
     };
     
     return r;

package/launchpad/launchers/single.js

@@ -20,6 +20,12 @@ module.exports = function(config) {
     
         io.on("connection", (socket) => {
             // TODO
+            
+            // always catch err
+            socket.on("error", function(err) {
+                console.log("Caught socket error");
+                console.log(err.stack);
+            });
         });
         
         httpServer.io = io;

package/locks/locks.js

@@ -25,6 +25,8 @@ var async = require("async");
  */
 exports = module.exports = function()
 {
+    var lockTimeoutMs = 120000; // two minutes
+    
     var provider = null;
 
     var r = {};
@@ -72,12 +74,55 @@ exports = module.exports = function()
      */
     var lock = r.lock = function(key, fn)
     {
-        provider.lock(key, function(err, releaseFn) {
+        var __log = function(key, text) {
+            // var skip = false;
+            // if (key === "channels") { skip = true; }
+            // if (!skip) {
+            //     console.log("[LOCK: " + key + "] " + text);
+            // }
+        };
+    
+        __log(key, "request");
+        provider.lock(key, function(err, _releaseFn) {
+            
+            // wrap the releaseFn with a wrapper that can only fire once
+            var releaseFn = function(_releaseFn)
+            {
+                var triggered = false;
+                return function() {
+                    if (!triggered) {
+                        triggered = true;
+                        _releaseFn();
+                        return true;
+                    }
+                    
+                    return false;
+                }
+            }(_releaseFn);
+            
+            // after 120 seconds, we force release lock (if it hasn't already been released)
+            (function(key, releaseFn) {
+                setTimeout(function() {
+                    var released = releaseFn();
+                    if (released) {
+                        __log(key, "timed out, released");
+                    }
+                }, lockTimeoutMs);
+            })(key, releaseFn);
+            
+            __log(key, "taken");
+            
             fn(err, function(afterReleaseCallback) {
+                __log(key, "pre-release");
 
-                releaseFn();
-
-                if (afterReleaseCallback)
+                var released = releaseFn();
+                if (released) {
+                    __log(key, "released");
+                } else {
+                    __log(key, "not released, was previously released on timeout");
+                }
+    
+                if (released && afterReleaseCallback)
                 {
                     afterReleaseCallback();
                 }

package/locks/providers/memory.js

@@ -1,6 +1,4 @@
-var path = require("path");
-
-var ReadWriteLock = require("rwlock");
+var AsyncLock = require('async-lock');
 
 /**
  * Simple in-memory lock service.
@@ -12,8 +10,8 @@ var ReadWriteLock = require("rwlock");
 exports = module.exports = function(lockConfig)
 {
     var r = {};
-
-    var locker = new ReadWriteLock();
+    
+    var lock = new AsyncLock();
 
     r.init = function(callback)
     {
@@ -22,8 +20,13 @@ exports = module.exports = function(lockConfig)
 
     r.lock = function(key, fn)
     {
-        locker.writeLock(key, function(releaseCallbackFn) {
+        lock.acquire(key, function(releaseCallbackFn) {
             fn(null, releaseCallbackFn);
+        }, function(err, ret) {
+            // lock was released
+            if (err) {
+                console.error("Memory Lock heard error: ", err, " return value: ", ret);
+            }
         });
     };
 

package/locks/providers/redis.js

@@ -13,7 +13,7 @@ exports = module.exports = function(locksConfig)
     var redlock = null;
     var client = null;
     
-    var logger = redisHelper.redisLogger("REDIS_LOCKS", "CLOUDCMS_LOCKS_", "error")
+    var logger = redisHelper.redisLogger("REDIS_LOCKS", "CLOUDCMS_LOCKS_", "debug")
     
     var r = {};
 

package/middleware/authentication/providers/saml.js

@@ -1,6 +1,5 @@
 //var auth = require("../../../util/auth");
 
-//var SamlStrategy = require("../../../temp/passport-saml").Strategy;
 var SamlStrategy = require('passport-saml').Strategy;
 var AbstractProvider = require("./abstract");
 

package/middleware/awareness/awareness.js

@@ -60,10 +60,15 @@ exports = module.exports = function()
         if (!process.configuration.awareness.config) {
             process.configuration.awareness.config = {};
         }
-
+    
+        // init any plugins?
+        if (!process.configuration.awareness.plugins) {
+            process.configuration.awareness.plugins = [];
+        }
+    
         var type = process.configuration.awareness.type;
         var config = process.configuration.awareness.config;
-
+        
         var providerFactory = require("./providers/" + type);
         provider = new providerFactory(config);
 
@@ -74,12 +79,6 @@ exports = module.exports = function()
                 return callback(err);
             }
 
-            // init any plugins?
-            if (!process.configuration.awareness.plugins) {
-                process.configuration.awareness.plugins = [];
-            }
-
-
             var fns = [];
             for (var i = 0; i < pluginPaths.length; i++)
             {
@@ -115,15 +114,18 @@ exports = module.exports = function()
     /**
      * This gets called whenever a new socket is connected to the Cloud CMS server.
      *
+     * @param io
+     * @param callback
+     *
      * @type {Function}
      */
-    var initSocketIO = r.initSocketIO = function(callback) {
-
+    var initSocketIO = r.initSocketIO = function(io, callback) {
+    
         // initialize socket IO event handlers so that awareness binds to any new, incoming sockets
-        socketInit(process.IO);
+        socketInit(io);
 
         // ensure the reaper is initialized
-        reaperInit(process.IO, REAP_FREQUENCY_MS, REAP_MAX_AGE_MS, function(err) {
+        reaperInit(io, REAP_FREQUENCY_MS, REAP_MAX_AGE_MS, function(err) {
             callback(err);
         });
     };
@@ -172,7 +174,7 @@ exports = module.exports = function()
         // when a socket.io connection is established, we set up some default listeners for events that the client
         // may emit to us
         io.on("connection", function(socket) {
-
+            
             // "register" -> indicates that a user is in a channel
             socket.on("register", function(channelId, user, dirty, callback) {
 
@@ -193,24 +195,32 @@ exports = module.exports = function()
                             return callback(err);
                         }
 
-                        // if we were already registered, just callback
-                        // however, if "dirty" is set, then we always hand back membership
-                        if (!dirty && alreadyRegistered)
-                        {
-                            return callback();
-                        }
-
-                        if (!alreadyRegistered)
-                        {
-                            // logger.info("New registration - channelId: " + channelId + ",userId=" + user.id + " (" + user.name + ")");
-
+                        // // if we were already registered, just callback
+                        // // however, if "dirty" is set, then we always hand back membership
+                        // if (!dirty && alreadyRegistered)
+                        // {
+                        //     logger.info("Already registered, not dirty - channelId: " + channelId + ",userId=" + user.id + " (" + user.name + ")");
+                        //
+                        //     return callback();
+                        // }
+                        //
+                        // if (!alreadyRegistered)
+                        // {
+                        //     logger.info("New registration - channelId: " + channelId + ",userId=" + user.id + " (" + user.name + ")");
+    
+                            //logger.info("Register - channelId: " + channelId + ", userId=" + user.id + " (" + user.name + ")");
                             socket.join(channelId);
-                        }
+                        //}
 
                         discover(channelId, function(err, userArray) {
 
-                            if (!err) {
-                                logger.info("Discover - channelId: " + channelId + ", userId=" + user.id + " (" + user.name + ") handing back: " + userArray.length);
+                            if (err)
+                            {
+                                logger.info("Discover - channelId: " + channelId + ", err: " + JSON.stringify(err));
+                            }
+                            else
+                            {
+                                //logger.info("Discover - channelId: " + channelId + ", userId=" + user.id + " (" + user.name + ") handing back: " + userArray.length);
                                 io.sockets.in(channelId).emit("membershipChanged", channelId, userArray);
                             }
 
@@ -412,6 +422,8 @@ exports = module.exports = function()
      */
     var register = r.register = function(channelId, user, callback)
     {
+        //console.log("Awareness - heard register, channel: " + channelId + ", user: " + user.id);
+        
         provider.register(channelId, user, callback);
     };