Redis Caching

redis

var _ = require('lodash');
var HD = require('hd').utils;
var Domains = require('hd').domains;
var Redis = require("redis");

var internals = { };

internals = {
    client: null,
    connected: false
};

internals.isValid = function(value) {
    return !_.isUndefined(value) && value != null;
}

internals.init = function () {
    var serverConfig = Domains.serverconfig();
    if(serverConfig.redis && serverConfig.redis.enabled) {
        console.dir(serverConfig.redis);
        internals.client = Redis.createClient(serverConfig.redis.port, serverConfig.redis.host, serverConfig.redis.options);
        internals.client.select(serverConfig.redis.dbId);
        internals.client.on("ready", function (err) {
            internals.connected = true;
            if(err)
                console.log("*** Redis PUBSUB ready error " + err);
            else
                console.log("*** Redis PUBSUB ready");
        });
        internals.client.on("connect", function (err) {
            if(err)
                console.log("*** Redis PUBSUB connect error " + err);
            else
                console.log("*** Redis PUBSUB connect");
        });
        internals.client.on("end", function (err) {
            internals.connected = false;
            if(err)
                console.log("*** Redis PUBSUB end error " + err);
            else
                console.log("*** Redis PUBSUB end");
        });
    }
}

internals.canExecute = function() {
    return internals.client && internals.connected;
}

internals.setObj = function(id, obj) {
    var sessionData = JSON.stringify(obj);
    try {
        internals.client.SET(id, sessionData);
    } catch(ex) {
        console.log(' *** ERROR Redis: setObj');
        console.dir(ex);
    }
}

internals.setObjEX = function(id, obj, timeInSec) {
    var data = JSON.stringify(obj);
    try {
        internals.client.SETEX(id, timeInSec, data);
    } catch(ex) {
        console.log(' *** ERROR Redis: setObjEX');
        console.dir(ex);
    }
}

internals.getObj = function(id, cb) {
    internals.client.GET(id, function(err, retData) {
        cb(err, JSON.parse(retData));
    });
}

internals.set = function(id, data) {
    try {
        internals.client.SET(id, data);
    } catch(ex) {
        console.log(' *** ERROR Redis: set');
        console.dir(ex);
    }
}

internals.setEX = function(id, data, timeInSec) {
    try {
        internals.client.SETEX(id, timeInSec, data);
    } catch(ex) {
        console.log(' *** ERROR Redis: setEX');
        console.dir(ex);
    }
}

internals.hsetObj = function(id, field, obj) {
    var hashData = JSON.stringify(obj);
    if(internals.isValid(id) && internals.isValid(field) && internals.isValid(hashData))
        internals.client.HSET(id, field, hashData, function(err) {
            if(err)
                console.log(err);
        });
    else {
        console.log(' *** ERRR Redis hsetObj: ' + id + " - " + field);
        console.dir(obj);
    }
}

internals.get = function(id, cb) {
    internals.client.GET(id, function(err, retData) {
        cb(err, retData);
    });
}

internals.hget = function(id, field, cb) {
    internals.client.HGET(id, field, function(err, retData) {
        cb(err, retData);
    });
}

internals.hgetObj = function(id, field, cb) {
    internals.client.HGET(id, field, function(err, retData) {
        var obj = JSON.parse(retData);
        cb(err, obj);
    });
}

internals.del = function(id, cb) {
    internals.client.DEL(id, function(err) {
        cb(err);
    });
}

// cache functions
internals.getCache = function(cacheName, id, cb) {
    var objCache = Domains.serverconfig().cache[cacheName];
    if(objCache !== -1) {
        internals.getObj(cacheName + ':' + id, function(err, retCachedData) {
            cb(err, retCachedData);
        });
    } else {
        cb(null, null);
    }
}

internals.delCache = function(cacheName, id) {
    internals.del(cacheName + ':' + id, function() {});
}

internals.setCache = function(cacheName, id, obj) {
    var ttl = Domains.serverconfig().cache[cacheName];
    if(ttl !== -1) {
        if(ttl === 0)
            internals.setObj(cacheName + ':' + id, obj);
        else
            internals.setObjEX(cacheName + ':' + id, obj, ttl);
    }
}

// Index Caching
internals.setIndexCache = function(id, field, obj) {
    if(internals.isValid(field) && internals.isValid(field)) {
        internals.hsetObj(id, field, obj);
    } else {
        console.log(' *** ERRR Redis setIndexCache: ' + id + ' field: ' + field);
        console.dir(obj);
    }
}

internals.getIndexCache = function(id, field, cb) {
    if(internals.isValid(id) && internals.isValid(field)) {
        internals.hgetObj(id, field, function(err, retData) {
            if(err) {
                console.log('getIndexCache');
                console.dir(err);
            }
            cb(err, retData);
        });
    } else {
        console.log(' *** ERRR Redis setIndexCache: ' + id + ' field: ' + field);
    }
}

module.exports = {
    init: internals.init,
    getObj: internals.getObj,
    setObj: internals.setObj,
    setObjEX: internals.setObjEX,
    get: internals.get,
    set: internals.set,
    setEX: internals.setEX,
    del: internals.del,
    client: internals.client,
    canExecute: internals.canExecute,
    // cache functions
    getCache: internals.getCache,
    delCache: internals.delCache,
    setCache: internals.setCache,
    // Index cache
    setIndexCache: internals.setIndexCache,
    getIndexCache: internals.getIndexCache
};