cloudcms-server 0.9.256 → 0.9.257

package/broadcast/providers/redis.js

@@ -1,8 +1,7 @@
-var path = require("path");
+var redisClientFactory = require("../../clients/redis");
+var redisHelper = require("../../util/redis");
 
-var NRP = require('node-redis-pubsub');
-
-var logFactory = require("../../util/logger");
+var NRP = require("../../clients/nrp");
 
 /**
  * Redis broadcast provider.
@@ -12,55 +11,31 @@ var logFactory = require("../../util/logger");
 exports = module.exports = function(broadcastConfig)
 {
     var nrp = null;
-
-    var logger = logFactory("REDIS BROADCAST");
-    logger.setLevel("error");
-
-    // 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_BROADCAST_REDIS_DEBUG_LEVEL) !== "undefined") {
-        logger.setLevel(("" + process.env.CLOUDCMS_BROADCAST_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-    }
-
+    
+    var logger = redisHelper.redisLogger("REDIS_BROADCAST", "CLOUDCMS_BROADCAST_", "error")
+    
     var r = {};
 
     r.start = function(callback)
     {
-        var redisPort = broadcastConfig.port;
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_BROADCAST_REDIS_PORT;
-        }
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_REDIS_PORT;
-        }
-
-        var redisEndpoint = broadcastConfig.endpoint;
-        if (typeof(redisEndpoint) === "undefined" || !redisEndpoint)
-        {
-            redisEndpoint = process.env.CLOUDCMS_BROADCAST_REDIS_ENDPOINT;
-        }
-        if (typeof(redisEndpoint) === "undefined" || !redisEndpoint)
-        {
-            redisEndpoint = process.env.CLOUDCMS_REDIS_ENDPOINT;
-        }
-
-        var nrpConfig = {
-            "port": redisPort,
-            "host": redisEndpoint,
-            "scope": "broadcast_cache"
-        };
-
-        logger.info("using config = " + nrpConfig);
-        
-        nrp = new NRP(nrpConfig);
-
-        callback();
+        redisClientFactory.create(broadcastConfig, function(err, client) {
+            
+            if (err) {
+                return callback(err);
+            }
+    
+            var nrpConfig = {
+                "client": client,
+                "scope": "broadcast_cache"
+            };
+    
+            logger.info("using config = " + nrpConfig);
+    
+            nrp = new NRP(nrpConfig);
+            nrp.connect(function(err) {
+                callback(err);
+            });
+        });
     };
 
     r.publish = function(topic, message, callback)

package/clients/nrp.js

@@ -0,0 +1,117 @@
+// a revision of
+// https://raw.githubusercontent.com/louischatriot/node-redis-pubsub/master/lib/node-redis-pubsub.js
+// that works with Redis 6+
+
+"use strict";
+var redis = require('redis');
+
+/**
+ * Create a new NodeRedisPubsub instance that can subscribe to channels and publish messages
+ * @param {Object} options Options for the client creations:
+ *                 client - a connected Redis client
+ *                 scope - Optional, two NodeRedisPubsubs with different scopes will not share messages
+ */
+function NodeRedisPubsub(options)
+{
+    if (!(this instanceof NodeRedisPubsub)){ return new NodeRedisPubsub(options); }
+    
+    options || (options = {});
+    
+    this.emitter = options.client.duplicate();
+    this.emitter.setMaxListeners(0);
+    this.receiver = options.client.duplicate();
+    this.receiver.setMaxListeners(0);
+    
+    this.prefix = options.scope ? options.scope + ':' : '';
+}
+
+NodeRedisPubsub.prototype.connect = function(callback)
+{
+    var self = this;
+    
+    (async function() {
+        await self.emitter.connect();
+        await self.receiver.connect();
+        callback();
+    })();
+};
+
+/**
+ * Subscribe to a channel
+ * @param {String} channel The channel to subscribe to, can be a pattern e.g. 'user.*'
+ * @param {Function} handler Function to call with the received message.
+ * @param {Function} cb Optional callback to call once the handler is registered.
+ */
+NodeRedisPubsub.prototype.on = NodeRedisPubsub.prototype.subscribe = function(channel, handler, callback)
+{
+    if (!callback)
+    {
+        callback = function(){};
+    }
+    
+    var self = this;
+    
+    if (channel === "error")
+    {
+        self.errorHandler = handler;
+        self.emitter.on("error", handler);
+        self.receiver.on("error", handler);
+        return callback();
+    }
+    
+    var listener = function(self, handler)
+    {
+        return function(message, channel) {
+    
+            var jsonmsg = message;
+            try{
+                jsonmsg = JSON.parse(message);
+            } catch (ex){
+                if(typeof self.errorHandler === 'function'){
+                    return self.errorHandler("Invalid JSON received! Channel: " + self.prefix + channel + " Message: " + message);
+                }
+            }
+            return handler(jsonmsg, channel);
+        }
+    }(self, handler);
+    
+    (async function() {
+        await self.receiver.pSubscribe(self.prefix + channel, listener);
+    })();
+    
+    callback();
+};
+
+/**
+ * Emit an event
+ * @param {String} channel Channel on which to emit the message
+ * @param {Object} message
+ */
+NodeRedisPubsub.prototype.emit = NodeRedisPubsub.prototype.publish = function (channel, message)
+{
+    var self = this;
+    
+    (async function() {
+        return await self.emitter.publish(self.prefix + channel, JSON.stringify(message));
+    })();
+};
+
+/**
+ * Safely close the redis connections 'soon'
+ */
+NodeRedisPubsub.prototype.quit = function()
+{
+    this.emitter.quit();
+    this.receiver.quit();
+};
+
+/**
+ * Dangerously close the redis connections immediately
+ */
+NodeRedisPubsub.prototype.end = function()
+{
+    this.emitter.end(true);
+    this.receiver.end(true);
+};
+
+module.exports = NodeRedisPubsub;

package/clients/redis.js

@@ -0,0 +1,48 @@
+var redis = require("redis");
+var redisHelper = require("../util/redis");
+
+var clients = {};
+
+/**
+ * Redis client factory.
+ *
+ * @type {*}
+ */
+exports = module.exports = {};
+
+var create = exports.create = function(config, callback)
+{
+    if (typeof(config) === "function") {
+        callback = config;
+        config = {};
+    }
+    
+    if (!config) {
+        config = {};
+    }
+    
+    var redisOptions = redisHelper.redisOptions(config);
+    var url = redisOptions.url;
+    
+    // cached client?
+    var client = clients[url];
+    if (client) {
+        return callback(null, client);
+    }
+    
+    // connect
+    (async function() {
+        await redisHelper.createAndConnect(redisOptions, function(err, client) {
+            
+            if (err) {
+                return callback(err);
+            }
+            
+            // cache it
+            clients[url] = client;
+            
+            // return
+            return callback(null, client);
+        });
+    })();
+};

package/locks/providers/redis.js

@@ -1,7 +1,8 @@
-var path = require("path");
-var redis = require("redis");
 var logFactory = require("../../util/logger");
-var redisHelper = require("../../util/redis");
+//var redisHelper = require("../../util/redis");
+
+var redisClientFactory = require("../../clients/redis");
+const redisHelper = require("../../util/redis");
 
 /**
  * Redis lock service.
@@ -17,33 +18,24 @@ exports = module.exports = function(locksConfig)
         delay: 50
     });
 
-    var nrp = 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 redisOptions = redisHelper.redisOptions(locksConfig, "CLOUDCMS_LOCKS");
-
-        client = redis.createClient(redisOptions);
-
-        callback();
+        redisClientFactory.create(locksConfig, function(err, _client) {
+    
+            if (err) {
+                return callback(err);
+            }
+    
+            client = _client;
+    
+            return callback();
+        });
     };
 
     r.lock = function(key, fn)

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/awareness/providers/redis.js

@@ -1,132 +1,152 @@
 var AbstractAsyncProvider = require("./abstract-async");
 
-var redis = require("redis");
+//var redis = require("redis");
 var async = require("async");
 
 var logFactory = require("../../../util/logger");
-var redisHelper = require("../../../util/redis");
+//var redisHelper = require("../../../util/redis");
+
+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;
+    
+        redisClientFactory.create(config, function(err, _client) {
+    
+            if (err) {
+                return callback(err);
+            }
+    
+            self.client = _client;
+    
+            return callback();
+    
+        });
+    
+        (async function() {
+            var redisOptions = redisHelper.redisOptions(this.config, "CLOUDCMS_AWARENESS");
+            await redisHelper.createAndConnect(redisOptions, function(err, _client) {
         
-        var redisOptions = redisHelper.redisOptions(this.config, "CLOUDCMS_AWARENESS");
-
-        this.client = redis.createClient(redisOptions);
-
-        callback();
+            });
+        })();
     }
 
     readOrCreateChannel(channelId, callback)
     {
         var self = this;
+    
+        (async function() {
 
-        self.client.get("channel-" + channelId, function(err, channelJsonText) {
-
-            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) {
-
+            await self.client.get("channel-" + channelId, function(err, channelJsonText) {
+    
                 if (err) {
                     return callback(err);
                 }
-
-                callback(null, channel);
+    
+                if (channelJsonText)
+                {
+                    var channel = JSON.parse("" + channelJsonText);
+                    return callback(null, channel);
+                }
+                
+                (async function() {
+                    var channel = {};
+                    await self.client.set("channel-" + channelId, JSON.stringify(channel), function (err) {
+        
+                        if (err) {
+                            return callback(err);
+                        }
+        
+                        callback(null, channel);
+                    });
+                })();
             });
-        });
+            
+        })();
     };
 
     readChannel(channelId, callback)
     {
         var self = this;
-
-        self.client.get("channel-" + channelId, function(err, channelJsonText) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            if (channelJsonText)
-            {
-                var channel = JSON.parse("" + channelJsonText);
-                return callback(null, channel);
-            }
-
-            callback();
-        });
+    
+        (async function() {
+    
+            await self.client.get("channel-" + channelId, function(err, channelJsonText) {
+    
+                if (err) {
+                    return callback(err);
+                }
+    
+                if (channelJsonText)
+                {
+                    var channel = JSON.parse("" + channelJsonText);
+                    return callback(null, channel);
+                }
+    
+                callback();
+            });
+            
+        })();
     };
 
     writeChannel(channelId, channel, callback)
     {
         var self = this;
+    
+        (async function() {
 
-        self.client.set("channel-" + channelId, JSON.stringify(channel), function(err) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            callback();
-        });
+            await self.client.set("channel-" + channelId, JSON.stringify(channel), function(err) {
+    
+                if (err) {
+                    return callback(err);
+                }
+    
+                callback();
+            });
+            
+        })();
     };
 
     listChannelIds(callback)
     {
         var self = this;
-
-        // fetch all keys for channels
-        self.client.keys("channel-*", function(err, channelKeys) {
-
-            if (err)
-            {
-                return callback(err);
-            }
-
-            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);
-        });
+    
+        (async function() {
+
+            // fetch all keys for channels
+            await self.client.keys("channel-*", function(err, channelKeys) {
+    
+                if (err)
+                {
+                    return callback(err);
+                }
+    
+                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);
+            });
+        })();
     };
 
     /**
@@ -221,106 +241,126 @@ class RedisProvider extends AbstractAsyncProvider
     readLock(lockId, callback)
     {
         var self = this;
+    
+        (async function() {
 
-        self.client.get("lock-" + lockId, function(err, lockJsonText) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            if (lockJsonText)
-            {
-                var lock = JSON.parse("" + lockJsonText);
-                return callback(null, lock);
-            }
-
-            callback();
-        });
+            await self.client.get("lock-" + lockId, function(err, lockJsonText) {
+    
+                if (err) {
+                    return callback(err);
+                }
+    
+                if (lockJsonText)
+                {
+                    var lock = JSON.parse("" + lockJsonText);
+                    return callback(null, lock);
+                }
+    
+                callback();
+            });
+        })();
     };
 
     writeLock(lockId, lock, callback)
     {
         var self = this;
-
-        self.client.set("lock-" + lockId, JSON.stringify(lock), function(err) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            callback();
-        });
+    
+        (async function() {
+            
+            await self.client.set("lock-" + lockId, JSON.stringify(lock), function(err) {
+                
+                if (err) {
+                    return callback(err);
+                }
+    
+                callback();
+            });
+            
+        })();
     };
 
     deleteLock(lockId, callback)
     {
         var self = this;
+    
+        (async function() {
+        
+            await self.client.del("lock-" + lockId, function(err) {
 
-        self.client.del("lock-" + lockId, function(err) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            callback();
-        });
+                if (err) {
+                    return callback(err);
+                }
+    
+                callback();
+            });
+            
+        })();
     };
 
     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)
-            {
-                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);
-        });
+    
+        (async function() {
+
+            // fetch all keys for locks
+            await self.client.keys("lock-*", function(err, lockKeys) {
+    
+                if (err)
+                {
+                    return callback(err);
+                }
+    
+                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);
+            });
+            
+        })();
     };
 
     acquireSession(sessionId, callback)
     {
         var self = this;
-
-        self.client.get("session-" + sessionId, function(err, sessionJsonText) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            if (sessionJsonText)
-            {
-                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) {
-
+    
+        (async function() {
+            
+            await self.client.get("session-" + sessionId, function(err, sessionJsonText) {
+    
                 if (err) {
                     return callback(err);
                 }
-
-                callback(null, session);
+    
+                if (sessionJsonText)
+                {
+                    var session = JSON.parse("" + sessionJsonText);
+                    return callback(null, session);
+                }
+    
+                // create a new session
+                (async function() {
+                    var session = {};
+                    await self.client.set("session-" + sessionId, JSON.stringify(session), function(err) {
+        
+                        if (err) {
+                            return callback(err);
+                        }
+        
+                        callback(null, session);
+                    });
+                })();
             });
-        });
+        })();
     }
 
     updateSession(sessionId, session, callback)
@@ -330,30 +370,35 @@ class RedisProvider extends AbstractAsyncProvider
         if (!session) {
             session = {};
         }
-
-        // create a new session
-        self.client.set("session-" + sessionId, JSON.stringify(session), function(err) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            callback(null, session);
-        });
+    
+        (async function() {
+    
+            // create a new session
+            await self.client.set("session-" + sessionId, JSON.stringify(session), function (err) {
+        
+                if (err) {
+                    return callback(err);
+                }
+        
+                callback(null, session);
+            });
+        })();
     }
 
     deleteSession(sessionId, callback)
     {
         var self = this;
-
-        self.client.del("session-" + sessionId, function(err) {
-
-            if (err) {
-                return callback(err);
-            }
-
-            callback();
-        });
+    
+        (async function() {
+            await self.client.del("session-" + sessionId, function (err) {
+        
+                if (err) {
+                    return callback(err);
+                }
+        
+                callback();
+            });
+        })();
     }
 
 }

package/middleware/cache/providers/redis.js

@@ -1,7 +1,10 @@
-var path = require("path");
+//var path = require("path");
 
-var redis = require("redis");
+//var redis = require("redis");
 var logFactory = require("../../../util/logger");
+//const redisHelper = require("../../../util/redis");
+
+var redisClientFactory = require("../../../clients/redis");
 const redisHelper = require("../../../util/redis");
 
 /**
@@ -12,103 +15,161 @@ const redisHelper = require("../../../util/redis");
 exports = module.exports = function(cacheConfig)
 {
     var client = null;
-
-    var logger = this.logger = logFactory("REDIS CACHE");
-    logger.setLevel("error");
-
-    // 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_CACHE_REDIS_DEBUG_LEVEL) !== "undefined") {
-        logger.setLevel(("" + process.env.CLOUDCMS_CACHE_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-    }
+    
+    var logger = redisHelper.redisLogger("REDIS_CACHE", "CLOUDCMS_CACHE_", "error")
 
     var r = {};
 
     r.init = function(callback)
     {
-        var self = this;
+        redisClientFactory.create(cacheConfig, function(err, _client) {
     
-        var redisOptions = redisHelper.redisOptions(cacheConfig, "CLOUDCMS_CACHE");
-
-        client = redis.createClient(redisOptions);
-        
-        callback();
+            if (err) {
+                return callback(err);
+            }
+    
+            client = _client;
+    
+            return callback();
+    
+        });
     };
 
     r.write = function(key, value, seconds, callback)
     {
-        if (seconds <= -1)
-        {
-            client.set([key, JSON.stringify(value)], function(err, reply) {
-                if (err) {
-                    logger.error("write error. key: " + key + " value: " + JSON.stringify(value) + ". error:" + err);
+        logger.info('write, key = ' + key + ', value = ' + value + '', seconds = ' + seconds');
+        (async function() {
+    
+            var reply = null;
+            var err = null;
+    
+            try
+            {
+                if (seconds <= -1)
+                {
+                    reply = await client.set([key, JSON.stringify(value)]);
                 }
-                logger.info("write -> reply = " + reply);
-                callback(err, reply);
-            });
-        }
-        else
-        {
-            client.set([key, JSON.stringify(value), "EX", seconds], function(err, reply) {
-                if (err) {
-                    logger.error("write.ex error. key: " + key + " value: " + JSON.stringify(value) + ". error:" + err);
+                else
+                {
+                    reply = await client.set([key, JSON.stringify(value), "EX", seconds]);
                 }
-                logger.info("write.ex -> reply = " + reply);
-                callback(err, reply);
-            });
-        }
+            }
+            catch (e)
+            {
+                err = e;
+            }
+    
+            if (reply) {
+                logger.info("write -> reply = " + reply);
+            }
+    
+            if (err) {
+                logger.error("write error. key: " + key + " value: " + JSON.stringify(value) + ". error:" + err);
+            }
+    
+            callback(err, reply);
+            
+        })();
     };
 
-    r.read = function(key, callback)
-    {
-        client.get([key], function(err, reply) {
+    r.read = function(key, callback)
+    {
+        logger.info('read, key = ' + key);
 
+        (async function() {
+    
+            var err = null;
+            var reply = null;
+    
+            try
+            {
+                reply = await client.get([key]);
+            }
+            catch (e)
+            {
+                err = e;
+            }
+    
             if (err) {
                 logger.error("read error. key: " + key + ". error:" + err);
             }
-            logger.info("read. key: " + key + " -> reply = " + reply);
-            
+    
+            if (reply) {
+                logger.info("read. key: " + key + " -> reply = " + reply);
+            }
+    
             var result = null;
-            try
+            try
             {
-                result = JSON.parse(reply);
-            }
+                result = JSON.parse(reply);
+            }
             catch (ex)
             {
-                result = null;
-                err = ex;
-                if (err) {
+                result = null;
+                err = ex;
+        
+                if (err)
+                {
                     logger.error("error parsing reply. key: " + key + ". error:" + err);
                 }
-            }
-
+            }
+    
             callback(err, result);
-        });
-    };
+        })();
+    };
 
     r.remove = function(key, callback)
     {
-        logger.info("remove. key: " + key);
-        client.del([key], function(err) {
+        logger.info('remove, key = ' + key);
+    
+        (async function() {
+    
+            var err = null;
+            
+            try
+            {
+                await client.del([key]);
+                logger.info("remove. key: " + key);
+            }
+            catch (e)
+            {
+                err = e;
+            }
+    
             callback(err);
-        });
+        })();
     };
     
     r.keys = function(prefix, callback)
-    {
-        logger.info('keys. prefix = ' + prefix);
-        client.keys([prefix + '*'], function(err, reply) {
+    {
+        logger.info('keys, prefix = ' + prefix);
+        
+        (async function() {
+    
+            var err = null;
+            var reply = null;
+    
+            try
+            {
+                reply = await client.keys([prefix + '*']);
+            }
+            catch (e)
+            {
+                err = e;
+            }
+    
             if (err) {
                 logger.error("error reading prefix: " + prefix + ". error:" + err);
             }
-            logger.info("[keys -> reply = " + reply);
-            callback(err, reply);
-        });
-    };
+    
+            if (reply) {
+                logger.info("[keys -> reply = " + reply);
+            }
+    
+            callback(err, reply);
+            
+        })();
+    };
 
     return r;
 };

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "cloudcms-server",
   "description": "Cloud CMS Application Server Module",
-  "version": "0.9.256",
+  "version": "0.9.257",
   "repository": {
     "type": "git",
     "url": "git://github.com/gitana/cloudcms-server.git"
@@ -51,7 +51,6 @@
     "mkdirp": "^0.5.1",
     "moment": "^2.24.0",
     "morgan": "^1.9.1",
-    "node-redis-pubsub": "^5.0.0",
     "object-hash": "^1.3.1",
     "object-merge": "^2.5.1",
     "on-headers": "^1.0.2",

package/server/index.js

@@ -671,25 +671,20 @@ var startSlave = function(config, afterStartFn)
             }
             else if (process.configuration.session.type === "redis")
             {
-                var redisPort = process.env.CLOUDCMS_REDIS_PORT;
-                var redisHost = process.env.CLOUDCMS_REDIS_ENDPOINT;
-                
-                if (!redisPort)
-                {
-                    console.error("Cannot configure session for Redis storage because CLOUDCMS_REDIS_PORT is not defined");
-                }
-                else if (!redisHost)
-                {
-                    console.error("Cannot configure session for Redis storage because CLOUDCMS_REDIS_ENDPOINT is not defined");
-                }
-                else
-                {
+                (async function() {
                     var redisOptions = redisHelper.redisOptions();
-                    var redisClient = redis.createClient(redisOptions);
-                    
-                    var RedisStore = connectRedis(session);
-                    sessionConfig.store = new RedisStore({ client: redisClient });
-                }
+                    redisHelper.createAndConnect(redisOptions, function(err, redisClient) {
+    
+                        if (err) {
+                            console.error(err);
+                        }
+                        else
+                        {
+                            var RedisStore = connectRedis(session);
+                            sessionConfig.store = new RedisStore({ client: redisClient });
+                        }
+                    });
+                })();
             }
             else if (process.configuration.session.type === "memory" || !process.configuration.session.type)
             {

package/util/redis.js

@@ -1,5 +1,39 @@
+var redis = require("redis");
+const logFactory = require("./logger");
+
 exports = module.exports;
 
+var redisLogger = exports.redisLogger = function(name, prefix, defaultLevel)
+{
+    if (!defaultLevel) {
+        defaultLevel = "error";
+    }
+    
+    var level = null;
+    
+    // allow for global redis default
+    // allow for prefix specific
+    if (typeof(process.env["CLOUDCMS_REDIS_DEBUG_LEVEL"]) !== "undefined") {
+        level = "" + process.env["CLOUDCMS_REDIS_DEBUG_LEVEL"].toLowerCase();
+    }
+    
+    if (!level && prefix)
+    {
+        if (typeof(process.env[prefix + "REDIS_DEBUG_LEVEL"]) !== "undefined") {
+            level = "" + process.env[prefix + "REDIS_DEBUG_LEVEL"].toLowerCase();
+        }
+    }
+    
+    if (!level) {
+        level = defaultLevel;
+    }
+    
+    var logger = logFactory(name);
+    logger.setLevel(level);
+    
+    return logger;
+}
+
 var redisOptions = exports.redisOptions = function(config, prefix)
 {
     if (!config) {
@@ -57,7 +91,23 @@ var redisOptions = exports.redisOptions = function(config, prefix)
     
     var redisOptions = {};
     redisOptions.url = redisUrl;
-    redisOptions.legacyMode = true;
     
     return redisOptions;
 }
+
+var createAndConnect = exports.createAndConnect = async function(redisOptions, callback)
+{
+    var client = redis.createClient(redisOptions);
+    
+    var connectErr = null;
+    client.on('error', function(err) {
+        console.log('Redis Client Error', err);
+        connectErr = err;
+    });
+    
+    // connect
+    await client.connect();
+    //console.log("Connected to redis, options: " + JSON.stringify(redisOptions, null, 2) + ", err: " + connectErr + ", client: " + client);
+
+    return callback(connectErr, client);
+}