listen: function(queueName, handler) { if(!queueName) { throw new Error(consolePrefix, "Queue name must be provided. eg. 'emailQueue'."); } if(!handler) { throw new Error(consolePrefix, "You must provide a hander to .listen."); } if(alreadyListening) { throw new Error(consolePrefix, "You can only .listen once in an app. To listen to another queue, create another app."); } if(!blockingClient) { blockingClient = redis.createClient.apply(redis, redisArgs); } process.on("SIGINT", onKillSignal); process.on("SIGTERM", onKillSignal); alreadyListening = true; if(handler.length < 2) { console.log(consolePrefix, 'Assuming that the handler returns a promise.'); } continueListening("cumin." + queueName, handler); }
that.connect = function() { addClient = redis.createClient.apply(redis, arguments); addClient.on('error', function(err) { console.error(err); }); addClient.on('ready', function() { checkReady(); }); shuffleClient = redis.createClient.apply(redis, arguments); shuffleClient.on('error', function(err) { console.error(err); }); shuffleClient.on('ready', function() { checkReady(); }); return that; };
util.enableRedis = function (port, host, options) { if (!_useRedis && redis.createClient) { if (port && host) { options = options || {}; redis = redis.createClient.apply(this, arguments); } else { redis = redis.createClient(); } _useRedis = true; } };
var RedisCache = function () { var redis = require('redis'); this.client = redis.createClient.apply(redis, arguments); this.client.on('ready', function () { debug('Redis Cache ready'); }); this.client.on('error', function (err) { debug('Redis Cache error - ' + err); }); this.defaultOptions = { autodisconnect: true, expiry: 60 }; };
exports.initialize = function initializeSchema(dataSource, callback) { if (!redis) return; if (dataSource.settings.url) { var url = require('url'); var redisUrl = url.parse(dataSource.settings.url); var redisAuth = (redisUrl.auth || '').split(':'); dataSource.settings.host = redisUrl.hostname; dataSource.settings.port = redisUrl.port; if (redisAuth.length > 1) { dataSource.settings.db = redisAuth[0]; dataSource.settings.password = redisAuth.slice(1).join(':'); } } var params = []; if (dataSource.settings.port) { params.push(dataSource.settings.port); } if (dataSource.settings.host) { params.push(dataSource.settings.host); } if (dataSource.settings.options) { params.push(dataSource.settings.options); } dataSource.client = redis.createClient.apply(redis.createClient, params); dataSource.client.auth(dataSource.settings.password); var callbackCalled = false; var database = dataSource.settings.hasOwnProperty('database') && dataSource.settings.database; dataSource.client.on('connect', function () { if (!callbackCalled && database === false) { callbackCalled = true; callback(); } else if (database !== false) { if (callbackCalled) { return dataSource.client.select(dataSource.settings.database); } else { callbackCalled = true; return dataSource.client.select(dataSource.settings.database, callback); } } }); dataSource.client.on('error', function (error) { console.log(error); }) var clientWrapper = new Client(dataSource.client); dataSource.connector = new BridgeToRedis(clientWrapper); clientWrapper._adapter = dataSource.connector; };
var Redback = exports.Redback = function (client, options) { if (typeof client === 'object' && client && client.command_queue && client.offline_queue) { this.client = client; } else { this.client = redis.createClient.apply(this, arguments); options = arguments[1] instanceof Object ? arguments[1] : arguments[2]; } this.namespace = ''; if (typeof options === 'object' && options.namespace) { this.namespace = options.namespace; } }
Pooldis.prototype._createClient = function(callback){ var client = Redis.createClient.apply(Redis, this.connectArgs); if (this.connectAuth) { debug("authenticating client"); return client.auth(this.connectAuth, function(error){ debug("authenticated"); debug("connected"); callback(error, client); }); } process.nextTick(function(){ debug("connected"); callback(null, client); }); };
Client.prototype.connect = function(hallow) { var self = this; self.redisClient = redis.createClient.apply(null, self.redisSettings); self.redisClient.on('error', function(err) { self.emit('error', err); }); self.redisClient.once('connect', function() { var m = self.redisClient.multi(); if (self.redisOptions && self.redisOptions.overwriteConfig) { _.forEach(self.redisOptions, function(val, key) { if (/^config_\w+/.test(key)) { m.config('set', key.replace('config_', ''), val); } }); } m.exec(function(err) { if (err) { return self.emit('error', err); } if (hallow) { self.db = { s: { databaseName: hallow }, hallow: true }; self.emit('connect', new CacheLayer(self, self.db, self.redisClient)); } else { mongo.MongoClient.connect.apply(null, [self.mongoSettings[0], self.mongoSettings[1], function(err, db) { if (err) { self.emit('error', err); } else { self.db = db; self.emit('connect', new CacheLayer(self, self.db, self.redisClient) ); } } ]); } }); }); return self; };
middleWare.sio.on('connection', function (socket) { socket.pubsubClient = redis.createClient.apply(redis, middleWare.redisClientArgs); socket.on('redis-web', function (data) { data.args.push(function () { var d = { id: data.id, args: Array.prototype.slice.call(arguments) }; socket.emit('redis-web', d); }); socket.pubsubClient[data.cmd].apply(socket.pubsubClient, data.args); }); socket.on('disconnect', function () { socket.pubsubClient.quit(); }) });
function RedisTemp(options) { Temp.call(this, options); if ('undefined' == typeof options.prefix) { this.options.prefix = 'rtcs.io:' } if ('undefined' == typeof options.prefixUserSockets) { this.options.prefixUserSockets = 'userSockets:' } if ('undefined' == typeof options.prefixUserRooms) { this.options.prefixUserRooms = 'userRooms:' } if ('undefined' == typeof options.prefixRoomUsers) { this.options.prefixRoomUsers = 'roomUsers:' } if ('undefined' == typeof options.prefixToken) { this.options.prefixToken = 'token:' } this.options.prefixUserSockets = this.options.prefix + this.options.prefixUserSockets; this.options.prefixUserRooms = this.options.prefix + this.options.prefixUserRooms; this.options.prefixRoomUsers = this.options.prefix + this.options.prefixRoomUsers; this.options.prefixToken = this.options.prefix + this.options.prefixToken; if (options.client) { this.redis = options.client; } else { var args = []; if (options.socket) { args.push(options.socket); } else if (options.port && options.host) { args.push(options.port); args.push(options.host); } args.push(options); this.redis = redis.createClient.apply(null, args); } var self = this; self.redis.on('error', function (err) { self.emit('error', err); }); }
Client.prototype.createCacheClient = function(cb) { var self = this; var newRedisClient = redis.createClient.apply(null, self.redisSettings); var called; newRedisClient.once('error', function(err) { if (!called) { called = true; if (typeof cb === 'function') { cb(err); } } else if (called && err) { throw err; } }); newRedisClient.once('connect', function() { if (!called && typeof cb === 'function') { called = true; cb(null, newRedisClient); } }); return self; };
module.exports.createClient = function() { var client = redis.createClient.apply(redis, arguments); return require('co-redis')(client); };
function RedisScanner() { this._client = redis.createClient.apply(redis, arguments); this._patternArray = []; this._handlerByPattern = {}; this._isScanning = false; }
constructor(){ this.pubLoginRedis = redis.createClient.apply(null, config.redis); this.subLoginRedis = redis.createClient.apply(null, config.redis); [this.pubLoginRedis, this.subLoginRedis].forEach(r => {r.on('error', utils.log.error);}); }
module.exports = function(port, host, options) { var redisArgs = arguments; var nonBlockingClient = redis.createClient.apply(redis, redisArgs), blockingClient; var redisBlpopTimeout = 1; var alreadyListening = false, killSignalReceived = false, pendingTasks = 0, killWaitTimeout = 20; function onKillSignal() { if(!killSignalReceived) { killSignalReceived = true; console.info("\n" + consolePrefix, "Attempting clean shutdown..."); console.info(consolePrefix, "To force shutdown, hit Ctrl+C again."); console.info(consolePrefix, "Waiting upto", redisBlpopTimeout, "seconds for next chance to kill the redis connection..."); setTimeout(function() { console.info(consolePrefix, "Forcing kill due to", killWaitTimeout, "seconds timeout."); process.exit(); }, killWaitTimeout * 1000) } else { console.info("\n" + consolePrefix, "Forcing shutdown now."); setTimeout(process.exit, 500); } } function attemptCleanShutdown() { console.info(consolePrefix, "Not reconnecting to redis because of kill signal received."); if(pendingTasks == 0) { console.info(consolePrefix, "No pending tasks. Exiting now."); process.exit(); } else { console.info(consolePrefix, "Waiting for pending tasks to be completed. Pending count:", pendingTasks); } } function continueListening(queueName, handler) { var promiseMode = (handler.length < 2); if(killSignalReceived) return attemptCleanShutdown(); blockingClient.blpop(queueName, redisBlpopTimeout, function(err, data) { if(err) return console.log(err); if(data) { var bareQueueName = queueName.slice(("cumin.").length); nonBlockingClient.hset("cuminmeta." + bareQueueName, "lastDequeued", Date.now()); nonBlockingClient.publish("cumin.dequeued", data[1]); var queueItem = JSON.parse(data[1]); var handlerOnComplete = function() { pendingTasks--; nonBlockingClient.hset("cuminmeta." + bareQueueName, "completed", Date.now()); nonBlockingClient.publish("cumin.processed", data[1]); if(killSignalReceived && pendingTasks) { console.info(consolePrefix, "Waiting for pending tasks to be completed. Pending count:", pendingTasks); } if(killSignalReceived && !pendingTasks) { console.info(consolePrefix, "Pending tasks completed. Shutting down now."); process.exit(); } } pendingTasks++; if(promiseMode) { handler(queueItem.data).then(handlerOnComplete); } else { handler(queueItem.data, handlerOnComplete); } } process.nextTick(function() { continueListening(queueName, handler); }); }); } return { enqueue: promisify(function(queueName, queueData, done) { if(!queueName) { throw new Error("Queue name must be provided. eg. 'emailQueue'."); } var now = Date.now(); var message = JSON.stringify({ byPid: process.pid, byTitle: process.title, queueName: queueName, date: now, data: queueData, retryCount: 0 }); nonBlockingClient.sadd("cuminqueues", queueName); nonBlockingClient.hset("cuminmeta." + queueName, "lastEnqueued", now); nonBlockingClient.rpush("cumin." + queueName, message); nonBlockingClient.publish("cumin.enqueued", message, done); }), listen: function(queueName, handler) { if(!queueName) { throw new Error(consolePrefix, "Queue name must be provided. eg. 'emailQueue'."); } if(!handler) { throw new Error(consolePrefix, "You must provide a hander to .listen."); } if(alreadyListening) { throw new Error(consolePrefix, "You can only .listen once in an app. To listen to another queue, create another app."); } if(!blockingClient) { blockingClient = redis.createClient.apply(redis, redisArgs); } process.on("SIGINT", onKillSignal); process.on("SIGTERM", onKillSignal); alreadyListening = true; if(handler.length < 2) { console.log(consolePrefix, 'Assuming that the handler returns a promise.'); } continueListening("cumin." + queueName, handler); } } }
module.exports = function () { var middleWare = function (req, res, next) { if (req.url.indexOf('/redis-web.js') >= 0) { res.setHeader('content-type', 'text/javascript'); return res.end(clientScript); } if (req.url.indexOf('/redis-web-post') >= 0) { req.body = ''; req.on('data', function (d) { req.body += d.toString('utf8'); }); req.on('end', function (d) { if (d) { req.body += d.toString('utf8'); } try { var data = JSON.parse(req.body); data.args.push(function (err, results) { return res.end(JSON.stringify({ err: err, results: results })); }); middleWare.cmdClient[data.cmd].apply(middleWare.cmdClient, data.args); } catch (ex) { return next(new Error("Invalid POST body")); } }); return; } return next(); }; middleWare.redisClientArgs = arguments; middleWare.setSocketIo = function (sio) { middleWare.sio = sio; middleWare.sio.on('connection', function (socket) { socket.pubsubClient = redis.createClient.apply(redis, middleWare.redisClientArgs); socket.on('redis-web', function (data) { data.args.push(function () { var d = { id: data.id, args: Array.prototype.slice.call(arguments) }; socket.emit('redis-web', d); }); socket.pubsubClient[data.cmd].apply(socket.pubsubClient, data.args); }); socket.on('disconnect', function () { socket.pubsubClient.quit(); }) }); }; middleWare.cmdClient = redis.createClient.apply(redis, middleWare.redisClientArgs); return middleWare; };
var redisClient = function (args) { return redis.createClient.apply(redis, args); };
var makeClient = function (clientName) { this[clientName] = redis.createClient.apply(redis, this.settings.redis.params); this[clientName].on('error', this.emit.bind(this, 'error')); this[clientName].select(this.settings.redis.db, reportReady); }.bind(this);