cloudcms-server 0.9.255 → 0.9.260

package/launchpad/launchers/redis.js

@@ -0,0 +1,53 @@
+const { Server } = require("socket.io");
+const { setupWorker } = require("@socket.io/sticky");
+const { createAdapter } = require("@socket.io/cluster-adapter");
+const redisHelper = require("../../util/redis");
+
+const clusterLauncherFactory = require("./cluster");
+
+module.exports = function(config) {
+    
+    var clusterLauncher = clusterLauncherFactory(config);
+    
+    var r = {};
+    
+    r.startCluster = function(httpServer, callback)
+    {
+        clusterLauncher.startCluster(httpServer, callback);
+    };
+    
+    r.afterStartCluster = function(httpServer, callback)
+    {
+        clusterLauncher.afterStartCluster(httpServer, callback);
+    };
+    
+    r.afterStartServer = function(app, httpServer, callback)
+    {
+        const io = new Server(httpServer);
+    
+        (async function() {
+            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
+                });
+            
+                // setup connection with the primary process
+                setupWorker(io);
+            
+                httpServer.io = io;
+            
+                return callback();
+            });
+        })();
+    };
+    
+    return r;
+}

package/launchpad/launchers/single.js

@@ -1,23 +1,31 @@
-module.exports = function(options) {
+const { Server } = require("socket.io");
 
-    var factoryCallback = options.factory;
-    var reportCallback = options.report;
-    if (!reportCallback) {
-        reportCallback = function () {
-        };
-    }
-    var completionCallback = options.complete;
-    if (!completionCallback) {
-        completionCallback = function () {
-        };
-    }
-
-    factoryCallback(function (server) {
-
-        reportCallback();
-
-        server.listen(server._listenPort);
-
-        completionCallback();
-    });
-};
+module.exports = function(config) {
+    
+    var r = {};
+    
+    r.startCluster = function(httpServer, callback)
+    {
+        callback();
+    };
+    
+    r.afterStartCluster = function(httpServer, callback)
+    {
+        callback();
+    };
+    
+    r.afterStartServer = function(app, httpServer, callback)
+    {
+        var io = new Server(httpServer);
+    
+        io.on("connection", (socket) => {
+            // TODO
+        });
+        
+        httpServer.io = io;
+        
+        callback();
+    };
+    
+    return r;
+}

package/locks/locks.js

@@ -34,7 +34,8 @@ exports = module.exports = function()
         var self = this;
 
         // set up defaults
-        if (!process.env.CLOUDCMS_LOCKS_TYPE) {
+        if (!process.env.CLOUDCMS_LOCKS_TYPE)
+        {
             process.env.CLOUDCMS_LOCKS_TYPE = "memory";
 
             if (process.configuration.setup !== "single") {
@@ -71,8 +72,8 @@ exports = module.exports = function()
      */
     var lock = r.lock = function(key, fn)
     {
-        provider.lock(key, function(releaseFn) {
-            fn(function(afterReleaseCallback) {
+        provider.lock(key, function(err, releaseFn) {
+            fn(err, function(afterReleaseCallback) {
 
                 releaseFn();
 

package/locks/providers/cluster.js

@@ -19,7 +19,7 @@ exports = module.exports = function(lockConfig)
     r.lock = function(key, fn)
     {
         ClusterLock.lock(key, function(releaseCallbackFn) {
-            fn(releaseCallbackFn);
+            fn(null, releaseCallbackFn);
         });
     };
 

package/locks/providers/memory.js

@@ -23,7 +23,7 @@ exports = module.exports = function(lockConfig)
     r.lock = function(key, fn)
     {
         locker.writeLock(key, function(releaseCallbackFn) {
-            fn(releaseCallbackFn);
+            fn(null, releaseCallbackFn);
         });
     };
 

package/locks/providers/redis.js

@@ -1,6 +1,7 @@
-var path = require("path");
-var redis = require("redis");
-var logFactory = require("../../util/logger");
+const redisHelper = require("../../util/redis");
+
+const IORedis = require("ioredis");
+var Redlock = require("redlock");
 
 /**
  * Redis lock service.
@@ -9,98 +10,77 @@ var logFactory = require("../../util/logger");
  */
 exports = module.exports = function(locksConfig)
 {
-    var redisLock = require("redislock");
-    redisLock.setDefaults({
-        timeout: 200000,
-        retries: 2000,
-        delay: 50
-    });
-
-    var nrp = null;
+    var redlock = null;
     var client = null;
-
-    var logger = logFactory("REDIS LOCK");
-
-    // allow for global redis default
-    // allow for redis broadcast specific
-    // otherwise default to error
-    if (typeof(process.env.CLOUDCMS_REDIS_DEBUG_LEVEL) !== "undefined") {
-        logger.setLevel(("" + process.env.CLOUDCMS_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-    }
-    else if (typeof(process.env.CLOUDCMS_LOCKS_REDIS_DEBUG_LEVEL) !== "undefined") {
-        logger.setLevel(("" + process.env.CLOUDCMS_LOCKS_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-    }
-    else {
-        logger.setLevel("error");
-    }
-
+    
+    var logger = redisHelper.redisLogger("REDIS_LOCKS", "CLOUDCMS_LOCKS_", "error")
+    
     var r = {};
 
     r.init = function(callback)
     {
-        var redisPort = locksConfig.port;
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_LOCKS_REDIS_PORT;
-        }
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_REDIS_PORT;
-        }
-
-        var redisEndpoint = locksConfig.endpoint;
-        if (typeof(redisEndpoint) === "undefined" || !redisEndpoint)
-        {
-            redisEndpoint = process.env.CLOUDCMS_LOCKS_REDIS_ENDPOINT;
-        }
-        if (typeof(redisEndpoint) === "undefined" || !redisEndpoint)
-        {
-            redisEndpoint = process.env.CLOUDCMS_REDIS_ENDPOINT;
-        }
-
-        var redisOptions = {};
-
-        //redis.debug_mode = true;
-
-        client = redis.createClient(redisPort, redisEndpoint, redisOptions);
+        var redisOptions = redisHelper.redisOptions(locksConfig);
+        client = new IORedis(redisOptions.url);
+        
+        redlock = new Redlock(
+            [client],
+            {
+                // the expected clock drift; for more details
+                // see http://redis.io/topics/distlock
+                driftFactor: 0.01, // multiplied by lock ttl to determine drift time
+        
+                // the max number of times Redlock will attempt
+                // to lock a resource before erroring
+                retryCount:  10,
+        
+                // the time in ms between attempts
+                retryDelay:  200, // time in ms
+        
+                // the max time in ms randomly added to retries
+                // to improve performance under high contention
+                // see https://www.awsarchitectureblog.com/2015/03/backoff.html
+                retryJitter:  200 // time in ms
+            }
+        );
 
-        callback();
+        return callback();
     };
 
     r.lock = function(key, fn)
     {
+        key = key.trim();
+        key = key.toLowerCase();
+        key = key.replace(/[\W_]+/g,"");
+        
         var lockKey = "cloudcms:locks:write:" + key;
-
-        var lock = redisLock.createLock(client);
-
-        var releaseCallbackFn = function(lock, lockKey) {
-            return function() {
-                logger.info("lock.release - " + lockKey);
-                lock.release(function(err) {
-
-                    if (err) {
-                        console.log("Failed to release redis lock: " + lockKey);
-                        console.log("Error: " + err);
-                        return;
-                    }
-
-                    logger.info("lock.released - " + lockKey);
-                });
-            }
-        }(lock, lockKey);
-
-        logger.info("lock.acquire - " + lockKey);
-        lock.acquire(lockKey, function(err) {
-
+    
+        logger.debug("lock.acquire:", lockKey);
+        
+        redlock.lock(lockKey, 2000, function(err, lock) {
+            
             if (err) {
-                console.log("Failed to acquire redis lock: " + lockKey);
-                console.log("Error: " + err);
-                return;
+                logger.error("Failed to acquire redis lock:", lockKey, err);
+                return fn(err);
             }
-
-            logger.info("lock.acquired - " + lockKey);
-
-            fn(releaseCallbackFn);
+    
+            logger.debug("lock.acquired:", lockKey);
+
+            var releaseCallbackFn = function(lock, lockKey) {
+                return function() {
+    
+                    logger.debug("lock.release:", lockKey);
+                    
+                    lock.unlock(function(err) {
+                        if (err) {
+                            logger.error("Failed to release redis lock:", lockKey, err);
+                        }
+                    });
+                }
+            }(lock, lockKey);
+    
+            logger.debug("lock.invokeFn");
+            fn(null, releaseCallbackFn);
+            
         });
     };
 

package/middleware/admin/admin.js

@@ -18,7 +18,7 @@ exports = module.exports = function()
         {
             var z = ref.indexOf("://");
 
-            var type = ref.substring(0, z + 3);
+            var type = ref.substring(0, z);
             var identifier = ref.substring(z + 3);
 
             var parts = identifier.split("/").reverse();
@@ -132,7 +132,7 @@ exports = module.exports = function()
                 {
                     assertAuthenticated(req, res, function() {
 
-                        doResetCache(req.virtualHost, req.ref, function(err) {
+                        doResetCache(req.virtualHost, req.query.ref, function(err) {
                             completionFn(req.virtualHost, res, err);
                         });
 

package/middleware/authentication/providers/saml.js

@@ -1,5 +1,6 @@
-var auth = require("../../../util/auth");
+//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

@@ -458,7 +458,12 @@ exports = module.exports = function()
     {
         // take out a cluster-wide lock on the "channelId"
         // so that two "threads" can't acquire/release at the same time for a given channel
-        _LOCK(channelId, function (releaseLockFn) {
+        _LOCK(channelId, function (err, releaseLockFn) {
+            
+            if (err) {
+                return callback(err);
+            }
+            
             provider.acquireLock(channelId, user, function(err, success) {
                 releaseLockFn();
                 callback(err, success);
@@ -477,7 +482,12 @@ exports = module.exports = function()
     {
         // take out a cluster-wide lock on the "channelId"
         // so that two "threads" can't acquire/release at the same time for a given channel
-        _LOCK(channelId, function (releaseLockFn) {
+        _LOCK(channelId, function (err, releaseLockFn) {
+            
+            if (err) {
+                return callback(err);
+            }
+            
             provider.releaseLock(channelId, userId, function(err, success) {
                 releaseLockFn();
                 callback(err, success);