cloudcms-server 3.3.1-beta.9 → 4.0.0-beta.1

package/middleware/awareness/providers/redis.js

@@ -1,378 +1,285 @@
 var AbstractAsyncProvider = require("./abstract-async");
 
-var redis = require("redis");
-var async = require("async");
-
-var logFactory = require("../../../util/logger");
+var redisClientFactory = require("../../../clients/redis");
+const redisHelper = require("../../../util/redis");
 
 class RedisProvider extends AbstractAsyncProvider
 {
     constructor(config)
     {
         super(config);
-
-        this.logger = logFactory("AWARENESS REDIS");
-
-        // allow for global redis default
-        // allow for redis broadcast specific
-        // otherwise default to error
-        if (typeof(process.env.CLOUDCMS_REDIS_DEBUG_LEVEL) !== "undefined") {
-            this.logger.setLevel(("" + process.env.CLOUDCMS_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-        }
-        else if (typeof(process.env.CLOUDCMS_AWARENESS_REDIS_DEBUG_LEVEL) !== "undefined") {
-            this.logger.setLevel(("" + process.env.CLOUDCMS_AWARENESS_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-        }
-        else {
-            this.logger.setLevel("error");
-        }
+    
+        this.logger = redisHelper.redisLogger("REDIS_AWARENESS", "CLOUDCMS_AWARENESS_", "error")
     }
 
     init(callback)
     {
         var self = this;
-
-        var redisPort = this.config.port;
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_AWARENESS_REDIS_PORT;
-        }
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_REDIS_PORT;
-        }
-
-        var redisHost = this.config.host;
-        if (typeof(redisHost) === "undefined" || !redisHost)
-        {
-            redisHost = process.env.CLOUDCMS_AWARENESS_REDIS_ENDPOINT;
-        }
-        if (typeof(redisHost) === "undefined" || !redisHost)
-        {
-            redisHost = process.env.CLOUDCMS_REDIS_ENDPOINT;
-        }
-
-        var redisOptions = {};
-
-        this.client = redis.createClient(redisPort, redisHost, redisOptions);
-
-        callback();
-    }
-
-    readOrCreateChannel(channelId, callback)
-    {
-        var self = this;
-
-        self.client.get("channel-" + channelId, function(err, channelJsonText) {
-
+    
+        redisClientFactory.create(self.config, function(err, _client) {
+    
             if (err) {
                 return callback(err);
             }
-
-            if (channelJsonText)
-            {
-                var channel = JSON.parse("" + channelJsonText);
-                return callback(null, channel);
-            }
-
-            var channel = {};
-            self.client.set("channel-" + channelId, JSON.stringify(channel), function(err) {
-
-                if (err) {
-                    return callback(err);
-                }
-
-                callback(null, channel);
-            });
+    
+            self.client = _client;
+    
+            return callback();
+    
         });
-    };
+    }
 
     readChannel(channelId, callback)
     {
         var self = this;
-
-        self.client.get("channel-" + channelId, function(err, channelJsonText) {
-
-            if (err) {
-                return callback(err);
+    
+        (async function() {
+    
+            try
+            {
+                var channel = null;
+                
+                var channelJsonText = await self.client.get("channel-" + channelId);
+                if (channelJsonText)
+                {
+                    channel = JSON.parse("" + channelJsonText);
+                }
+    
+                callback(null, channel);
             }
-
-            if (channelJsonText)
+            catch (err)
             {
-                var channel = JSON.parse("" + channelJsonText);
-                return callback(null, channel);
+                return callback(err);
             }
-
-            callback();
-        });
+            
+        })();
     };
 
     writeChannel(channelId, channel, callback)
     {
         var self = this;
-
-        self.client.set("channel-" + channelId, JSON.stringify(channel), function(err) {
-
-            if (err) {
+    
+        (async function() {
+    
+            try
+            {
+                await self.client.set("channel-" + channelId, JSON.stringify(channel));
+                
+                callback();
+            }
+            catch (err)
+            {
                 return callback(err);
             }
-
-            callback();
-        });
+            
+        })();
     };
 
     listChannelIds(callback)
     {
         var self = this;
+    
+        (async function() {
 
-        // fetch all keys for channels
-        self.client.keys("channel-*", function(err, channelKeys) {
-
-            if (err)
-            {
-                return callback(err);
-            }
-
-            if (!channelKeys || channelKeys.length === 0)
+            try
             {
-                return callback(null, []);
+                var channelKeys = await self.client.keys("channel-*");
+                if (!channelKeys || channelKeys.length === 0)
+                {
+                    return callback(null, []);
+                }
+    
+                var channelIds = [];
+                for (var i = 0; i < channelKeys.length; i++)
+                {
+                    var channelId = channelKeys[i].substring(channelKeys[i].indexOf("-") + 1);
+                    channelIds.push(channelId);
+                }
+    
+                callback(null, channelIds);
             }
-
-            var channelIds = [];
-            for (var i = 0; i < channelKeys.length; i++)
+            catch (err)
             {
-                var channelId = channelKeys[i].substring(channelKeys[i].indexOf("-") + 1);
-                channelIds.push(channelId);
+                callback(err);
             }
-
-            callback(null, channelIds);
-        });
+            
+        })();
     };
 
-    /**
-     * @override
-     */
-    expire(beforeMs, callback)
+    readLock(lockId, callback)
     {
         var self = this;
+    
+        (async function() {
 
-        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++)
+            try
             {
-                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();
-                            }
-
-                            if (channel.users)
-                            {
-                                // populate all of the user IDs that need to be removed
-                                var userIdsToRemove = [];
-                                for (var userId in channel.users)
-                                {
-                                    var entry = channel.users[userId];
-                                    if (entry.time < beforeMs)
-                                    {
-                                        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();
-                                });
-                            }
-
-                        });
-                    };
-                }(channelId, updatedMembershipChannelIds, expiredUserIdsByChannelId, beforeMs);
-                fns.push(fn);
-            }
-
-            async.parallel(fns, function(err) {
-
-                if (err) {
-                    return callback(err);
+                var lock = null;
+                
+                var lockJsonText = await self.client.get("lock-" + lockId);
+                if (lockJsonText)
+                {
+                    lock = JSON.parse("" + lockJsonText);
                 }
-
-                callback(null, updatedMembershipChannelIds, expiredUserIdsByChannelId);
-            });
-        });
-    };
-
-    readLock(lockId, callback)
-    {
-        var self = this;
-
-        self.client.get("lock-" + lockId, function(err, lockJsonText) {
-
-            if (err) {
-                return callback(err);
+    
+                callback(null, lock);
             }
-
-            if (lockJsonText)
+            catch (err)
             {
-                var lock = JSON.parse("" + lockJsonText);
-                return callback(null, lock);
+                callback(err);
             }
-
-            callback();
-        });
+            
+        })();
     };
 
     writeLock(lockId, lock, callback)
     {
         var self = this;
-
-        self.client.set("lock-" + lockId, JSON.stringify(lock), function(err) {
-
-            if (err) {
-                return callback(err);
+        
+        (async function() {
+    
+            try
+            {
+                await self.client.set("lock-" + lockId, JSON.stringify(lock));
+                
+                callback();
             }
-
-            callback();
-        });
+            catch (err)
+            {
+                callback(err);
+            }
+            
+        })();
     };
 
     deleteLock(lockId, callback)
     {
         var self = this;
+    
+        (async function() {
+    
+            try
+            {
+                await self.client.del("lock-" + lockId);
 
-        self.client.del("lock-" + lockId, function(err) {
-
-            if (err) {
-                return callback(err);
+                callback();
             }
-
-            callback();
-        });
+            catch (err)
+            {
+                callback(err);
+            }
+            
+        })();
     };
 
     listLockIds(callback)
     {
         var self = this;
-
-        // fetch all keys for locks
-        self.client.keys("lock-*", function(err, lockKeys) {
-
-            if (err)
-            {
-                return callback(err);
-            }
-
-            if (!lockKeys || lockKeys.length === 0)
+    
+        (async function() {
+            
+            try
             {
-                return callback(null, []);
+                var lockKeys = await self.client.keys("lock-*");
+                if (!lockKeys || lockKeys.length === 0)
+                {
+                    return callback(null, []);
+                }
+    
+                var lockIds = [];
+                for (var i = 0; i < lockKeys.length; i++)
+                {
+                    var lockId = lockKeys[i].substring(0, lockKeys[i].indexOf("-"));
+                    lockIds.push(lockId);
+                }
+    
+                callback(null, lockIds);
             }
-
-            var lockIds = [];
-            for (var i = 0; i < lockKeys.length; i++)
+            catch (err)
             {
-                var lockId = lockKeys[i].substring(0, lockKeys[i].indexOf("-"));
-                lockIds.push(lockId);
+                callback(err);
             }
-
-            callback(null, lockIds);
-        });
+            
+        })();
     };
 
     acquireSession(sessionId, callback)
     {
         var self = this;
-
-        self.client.get("session-" + sessionId, function(err, sessionJsonText) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            if (sessionJsonText)
+    
+        (async function() {
+            
+            var session = null;
+            
+            try
             {
-                var session = JSON.parse("" + sessionJsonText);
-                return callback(null, session);
-            }
-
-            // create a new session
-            var session = {};
-            self.client.set("session-" + sessionId, JSON.stringify(session), function(err) {
-
-                if (err) {
-                    return callback(err);
+                var sessionJsonText = await self.client.get("session-" + sessionId);
+                if (sessionJsonText)
+                {
+                    session = JSON.parse("" + sessionJsonText);
                 }
-
+                
+                if (session)
+                {
+                    return callback(null, session);
+                }
+    
+                // create a new session
+                session = {};
+                await self.client.set("session-" + sessionId, JSON.stringify(session));
+    
                 callback(null, session);
-            });
-        });
+            }
+            catch (err)
+            {
+                callback(err);
+            }
+            
+        })();
     }
 
     updateSession(sessionId, session, callback)
     {
         var self = this;
-
+    
         if (!session) {
             session = {};
         }
-
-        // create a new session
-        self.client.set("session-" + sessionId, JSON.stringify(session), function(err) {
-
-            if (err) {
-                return callback(err);
+    
+        (async function() {
+    
+            try
+            {
+                await self.client.set("session-" + sessionId, JSON.stringify(session));
+    
+                callback(null, session);
             }
-
-            callback(null, session);
-        });
+            catch (err)
+            {
+                callback(err);
+            }
+            
+        })();
     }
 
     deleteSession(sessionId, callback)
     {
         var self = this;
-
-        self.client.del("session-" + sessionId, function(err) {
-
-            if (err) {
-                return callback(err);
+        
+        (async function() {
+    
+            try
+            {
+                await self.client.del("session-" + sessionId);
+    
+                callback();
             }
-
-            callback();
-        });
+            catch (err)
+            {
+                callback(err);
+            }
+            
+        })();
     }
 
 }

package/middleware/cache/cache.js

@@ -27,8 +27,10 @@ exports = module.exports = function()
         if (!process.env.CLOUDCMS_CACHE_TYPE) {
 
             process.env.CLOUDCMS_CACHE_TYPE = "memory";
-
-            if (process.configuration.setup !== "single") {
+    
+            // auto-configure
+            if (process.env.CLOUDCMS_LAUNCHPAD_SETUP === "redis")
+            {
                 process.env.CLOUDCMS_CACHE_TYPE = "redis";
             }
         }