cloudcms-server 0.9.261 → 0.9.262

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/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);
     };
 

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

@@ -14,28 +14,33 @@ class AbstractAsyncProvider extends AbstractProvider
     {
         super(config);
     }
-
+    
+    _lock(lockKey, workFunction)
+    {
+        process.locks.lock(lockKey, workFunction);
+    }
+    
     readOrCreateChannel(channelId, callback) {
 
         var self = this;
 
         self.readChannel(channelId, function(err, channel) {
-
+    
             if (err) {
                 return callback(err);
             }
-
+    
             if (channel) {
                 return callback(null, channel);
             }
 
             var channel = {};
             self.writeChannel(channelId, channel, function(err) {
-
+    
                 if (err) {
                     return callback(err);
                 }
-
+    
                 callback(null, channel);
             });
         });
@@ -46,26 +51,47 @@ class AbstractAsyncProvider extends AbstractProvider
     register(channelId, user, callback)
     {
         var self = this;
-
+        
+        self._lock("channels", function(err, releaseLockFn) {
+            self.doRegister(channelId, user, function(err) {
+                callback(err);
+                return releaseLockFn();
+            });
+        });
+    }
+    
+    /**
+     * Workhorse method.  The "channels" lock is taken out ahead of this being called.
+     *
+     * @param channelId
+     * @param user
+     * @param callback
+     * @private
+     */
+    doRegister(channelId, user, callback)
+    {
+        var self = this;
+        
         self.readOrCreateChannel(channelId, function (err, channel) {
-
+    
             if (err) {
                 return callback(err);
             }
-
+        
             if (!channel.users) {
                 channel.users = {};
             }
-
+        
             channel.users[user.id] = {
                 "user": user,
                 "time": new Date().getTime()
             };
-
+            
             self.writeChannel(channelId, channel, function (err) {
                 callback(err);
             });
         });
+        
     }
 
     discover(channelId, callback)
@@ -101,46 +127,86 @@ class AbstractAsyncProvider extends AbstractProvider
         });
     }
 
-    expire(beforeMs, callback)
+    checkRegistered(channelId, userId, callback)
     {
         var self = this;
 
-        self.listChannelIds(function(err, channelIds) {
+        self.readChannel(channelId, function(err, channel) {
 
             if (err) {
                 return callback(err);
             }
 
+            if (!channel) {
+                return callback(null, false);
+            }
+
+            if (!channel.users) {
+                return callback(null, false);
+            }
+
+            if (channel.users[userId]) {
+                return callback(null, true);
+            }
+
+            callback(null, false);
+
+        });
+    }
+    
+    expire(beforeMs, callback)
+    {
+        var self = this;
+        
+        self._lock("channels", function(err, releaseLockFn) {
+            self._expire(beforeMs, function(err) {
+                callback(err);
+                return releaseLockFn();
+            });
+        });
+    }
+    
+    /**
+     * @override
+     */
+    _expire(beforeMs, callback)
+    {
+        var self = this;
+        
+        self.listChannelIds(function(err, channelIds) {
+            
+            if (err) {
+                return callback(err);
+            }
+            
             if (!channelIds || channelIds.length === 0) {
                 return callback(null, [], {});
             }
-
+            
             // a list of channel IDs whose memberships were updated
             var updatedMembershipChannelIds = [];
             var expiredUserIdsByChannelId = {};
-
+            
             var fns = [];
-
+            
             for (var i = 0; i < channelIds.length; i++)
             {
                 var channelId = channelIds[i];
-
+                
                 var fn = function (channelId, updatedMembershipChannelIds, expiredUserIdsByChannelId, beforeMs) {
                     return function (done) {
-
+                        
                         self.readChannel(channelId, function(err, channel) {
-
+                            
                             if (err) {
                                 return done(err);
                             }
-
+                            
                             if (!channel) {
                                 return done();
                             }
-
-                            var updatedMembership = false;
-
-                            if (channel.users)
+                            
+                            if (channel.users && Object.keys(channel.users).length > 0)
                             {
                                 // populate all of the user IDs that need to be removed
                                 var userIdsToRemove = [];
@@ -149,75 +215,46 @@ class AbstractAsyncProvider extends AbstractProvider
                                     var entry = channel.users[userId];
                                     if (entry.time < beforeMs)
                                     {
-                                        updatedMembership = true;
+                                        updatedMembershipChannelIds.push(channelId);
                                         userIdsToRemove.push(userId);
-
+                                        
                                         var expiredUserIds = expiredUserIdsByChannelId[channelId]
                                         if (!expiredUserIds) {
                                             expiredUserIds = expiredUserIdsByChannelId[channelId] = [];
                                         }
-
+                                        
                                         expiredUserIds.push(userId);
                                     }
                                 }
-
+                                
                                 // remove the user IDs
                                 for (var i = 0; i < userIdsToRemove.length; i++)
                                 {
                                     delete channel.users[userIdsToRemove[i]];
                                 }
+                                
+                                self.writeChannel(channelId, channel, function() {
+                                    done();
+                                });
                             }
-
-                            if (updatedMembership)
-                            {
-                                updatedMembershipChannelIds.push(channelId);
-                            }
-
-                            done();
+                            
                         });
                     };
                 }(channelId, updatedMembershipChannelIds, expiredUserIdsByChannelId, beforeMs);
                 fns.push(fn);
             }
-
+            
             async.parallel(fns, function(err) {
-
+                
                 if (err) {
                     return callback(err);
                 }
-
+                
                 callback(null, updatedMembershipChannelIds, expiredUserIdsByChannelId);
             });
         });
-    }
-
-    checkRegistered(channelId, userId, callback)
-    {
-        var self = this;
-
-        self.readChannel(channelId, function(err, channel) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            if (!channel) {
-                return callback(null, false);
-            }
-
-            if (!channel.users) {
-                return callback(null, false);
-            }
-
-            if (channel.users[userId]) {
-                return callback(null, true);
-            }
-
-            callback(null, false);
-
-        });
-    }
-
+    };
+    
     acquireLock(channelId, user, callback)
     {
         var self = this;
@@ -303,14 +340,16 @@ class AbstractAsyncProvider extends AbstractProvider
             callback(null, lock);
         });
     }
-
-
+    
+    
+    
+    
     //////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // ABSTRACT METHODS
     //
     //////////////////////////////////////////////////////////////////////////////////////////////////////////
-
+    
     // ABSTRACT
     readChannel(channelId, callback)
     {
@@ -328,7 +367,7 @@ class AbstractAsyncProvider extends AbstractProvider
     {
         throw new Error("listChannelIds() method is not implemented");
     }
-
+    
     // ABSTRACT
     readLock(lockId, callback)
     {

package/middleware/awareness/providers/abstract.js

@@ -2,7 +2,7 @@
  * Abstract class for an Awareness Provider.
  *
  * This class provides an interface or base functions that any implementation class must implement in order to
- * work with the Awareness Service.  Any methods that
+ * work with the Awareness Service.
  *
  */
 class AbstractProvider

package/middleware/awareness/providers/memory.js

@@ -24,20 +24,6 @@ class MemoryProvider extends AbstractAsyncProvider
         callback();
     }
 
-    readOrCreateChannel(channelId, callback)
-    {
-        var self = this;
-
-        var channel = self.channelMap[channelId];
-        if (channel) {
-            return callback(null, channel);
-        }
-
-        channel = self.channelMap[channelId] = {};
-
-        callback(null, channel);
-    }
-
     readChannel(channelId, callback)
     {
         var self = this;