redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-07 13:22:56 +03:00
Code Activity

Remove snack_case and always use camelCase

Browse Source
This commit is contained in:
Ruben Bridgewater
2016-12-18 01:46:58 +01:00
committed by Ruben Bridgewater
parent a86c998a64
commit 28afc33c9a
43 changed files with 1048 additions and 1163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/command.js
View File

@@ -2,12 +2,12 @@
var betterStackTraces = /development/i.test(process.env.NODE_ENV) || /\bredis\b/i.test(process.env.NODE_DEBUG);
function Command (command, args, callback, call_on_write) {
function Command (command, args, callback, callOnWrite) {
this.command = command;
this.args = args;
this.buffer_args = false;
this.bufferArgs = false;
this.callback = callback;
this.call_on_write = call_on_write;
this.callOnWrite = callOnWrite;
if (betterStackTraces) {
this.error = new Error();
}

2
lib/commands.js
View File

@@ -59,7 +59,7 @@ commands.list.forEach(function (command) {
arr[i] = arguments[i];
}
}
return this.internal_send_command(new Command(command, arr, callback));
return this.internalSendCommand(new Command(command, arr, callback));
};
if (changeFunctionName) {
Object.defineProperty(RedisClient.prototype[command], 'name', {

35
lib/createClient.js
View File

@@ -3,27 +3,28 @@
var utils = require('./utils');
var URL = require('url');
module.exports = function createClient (port_arg, host_arg, options) {
module.exports = function createClient (portArg, hostArg, options) {
if (typeof port_arg === 'number' || typeof port_arg === 'string' && /^\d+$/.test(port_arg)) {
if (typeof portArg === 'number' || typeof portArg === 'string' && /^\d+$/.test(portArg)) {
var host;
if (typeof host_arg === 'string') {
host = host_arg;
if (typeof hostArg === 'string') {
host = hostArg;
} else {
if (options && host_arg) {
if (options && hostArg) {
throw new TypeError('Unknown type of connection in createClient()');
}
options = options || host_arg;
options = options || hostArg;
}
options = utils.clone(options);
options.host = host || options.host;
options.port = port_arg;
options.port = portArg;
} else if (typeof port_arg === 'string' || port_arg && port_arg.url) {
} else if (typeof portArg === 'string' || portArg && portArg.url) {
options = utils.clone(port_arg.url ? port_arg : host_arg || options);
var parsed = URL.parse(port_arg.url || port_arg, true, true);
options = utils.clone(portArg.url ? portArg : hostArg || options);
var parsed = URL.parse(portArg.url || portArg, true, true);
// [redis:]//[[user][:password]@][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]
if (parsed.slashes) { // We require slashes
@@ -31,7 +32,7 @@ module.exports = function createClient (port_arg, host_arg, options) {
options.password = parsed.auth.split(':')[1];
}
if (parsed.protocol && parsed.protocol !== 'redis:') {
console.warn('node_redis: WARNING: You passed "' + parsed.protocol.substring(0, parsed.protocol.length - 1) + '" as protocol instead of the "redis" protocol!');
console.warn('nodeRedis: WARNING: You passed "' + parsed.protocol.substring(0, parsed.protocol.length - 1) + '" as protocol instead of the "redis" protocol!');
}
if (parsed.pathname && parsed.pathname !== '/') {
options.db = parsed.pathname.substr(1);
@@ -48,7 +49,7 @@ module.exports = function createClient (port_arg, host_arg, options) {
// If options are passed twice, only the parsed options will be used
if (elem in options) {
if (options[elem] === parsed.query[elem]) {
console.warn('node_redis: WARNING: You passed the ' + elem + ' option twice!');
console.warn('nodeRedis: WARNING: You passed the ' + elem + ' option twice!');
} else {
throw new RangeError('The ' + elem + ' option is added twice and does not match');
}
@@ -59,14 +60,14 @@ module.exports = function createClient (port_arg, host_arg, options) {
} else if (parsed.hostname) {
throw new RangeError('The redis url must begin with slashes "//" or contain slashes after the redis protocol');
} else {
options.path = port_arg;
options.path = portArg;
}
} else if (typeof port_arg === 'object' || port_arg === undefined) {
options = utils.clone(port_arg || options);
options.host = options.host || host_arg;
} else if (typeof portArg === 'object' || portArg === undefined) {
options = utils.clone(portArg || options);
options.host = options.host || hostArg;
if (port_arg && arguments.length !== 1) {
if (portArg && arguments.length !== 1) {
throw new TypeError('To many arguments passed to createClient. Please only pass the options object');
}
}

2
lib/debug.js
View File

@@ -3,7 +3,7 @@
var index = require('../');
function debug () {
if (index.debug_mode) {
if (index.debugMode) {
console.error.apply(null, arguments);
}
}

34
lib/extendedApi.js
View File

@@ -11,7 +11,7 @@ All documented and exposed API belongs in here
**********************************************/
// Redirect calls to the appropriate function and use to send arbitrary / not supported commands
RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = function (command, args, callback) {
RedisClient.prototype.sendCommand = function (command, args, callback) {
// Throw to fail early instead of relying in order in this case
if (typeof command !== 'string') {
throw new TypeError('Wrong input type "' + (command !== null && command !== undefined ? command.constructor.name : command) + '" for command name');
@@ -37,7 +37,7 @@ RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = functio
// but this might change from time to time and at the moment there's no good way to distinguishe them
// from each other, so let's just do it do it this way for the time being
if (command === 'multi' || typeof this[command] !== 'function') {
return this.internal_send_command(new Command(command, args, callback));
return this.internalSendCommand(new Command(command, args, callback));
}
if (typeof callback === 'function') {
args = args.concat([callback]); // Prevent manipulating the input array
@@ -48,20 +48,20 @@ RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = functio
RedisClient.prototype.end = function (flush) {
// Flush queue if wanted
if (flush) {
this.flush_and_error({
this.flushAndError({
message: 'Connection forcefully ended and command aborted.',
code: 'NR_CLOSED'
});
} else if (arguments.length === 0) {
this.warn(
'Using .end() without the flush parameter is deprecated and throws from v.3.0.0 on.\n' +
'Please check the doku (https://github.com/NodeRedis/node_redis) and explictly use flush.'
'Please check the doku (https://github.com/NodeRedis/nodeRedis) and explictly use flush.'
);
}
// Clear retry_timer
if (this.retry_timer) {
clearTimeout(this.retry_timer);
this.retry_timer = null;
// Clear retryTimer
if (this.retryTimer) {
clearTimeout(this.retryTimer);
this.retryTimer = null;
}
this.stream.removeAllListeners();
this.stream.on('error', noop);
@@ -88,24 +88,24 @@ RedisClient.prototype.duplicate = function (options, callback) {
callback = options;
options = null;
}
var existing_options = utils.clone(this.options);
var existingOptions = utils.clone(this.options);
options = utils.clone(options);
for (var elem in options) {
existing_options[elem] = options[elem];
existingOptions[elem] = options[elem];
}
var client = new RedisClient(existing_options);
client.selected_db = this.selected_db;
var client = new RedisClient(existingOptions);
client.selectedDb = this.selectedDb;
if (typeof callback === 'function') {
var ready_listener = function () {
var readyListener = function () {
callback(null, client);
client.removeAllListeners(error_listener);
client.removeAllListeners(errorListener);
};
var error_listener = function (err) {
var errorListener = function (err) {
callback(err);
client.end(true);
};
client.once('ready', ready_listener);
client.once('error', error_listener);
client.once('ready', readyListener);
client.once('error', errorListener);
return;
}
return client;

156
lib/individualCommands.js
View File

@@ -4,7 +4,7 @@ var utils = require('./utils');
var debug = require('./debug');
var Multi = require('./multi');
var Command = require('./command');
var no_password_is_set = /no password is set/;
var noPasswordIsSet = /no password is set/;
var loading = /LOADING/;
var RedisClient = require('../').RedisClient;
@@ -14,7 +14,7 @@ var RedisClient = require('../').RedisClient;
The callback may be hooked as needed. The same does not apply to the rest of the function.
State should not be set outside of the callback if not absolutly necessary.
This is important to make sure it works the same as single command or in a multi context.
To make sure everything works with the offline queue use the "call_on_write" function.
To make sure everything works with the offline queue use the "callOnWrite" function.
This is going to be executed while writing to the stream.
TODO: Implement individal command generation as soon as possible to prevent divergent code
@@ -23,7 +23,7 @@ var RedisClient = require('../').RedisClient;
RedisClient.prototype.multi = RedisClient.prototype.MULTI = function multi (args) {
var multi = new Multi(this, args);
multi.exec = multi.EXEC = multi.exec_transaction;
multi.exec = multi.EXEC = multi.execTransaction;
return multi;
};
@@ -32,45 +32,45 @@ RedisClient.prototype.batch = RedisClient.prototype.BATCH = function batch (args
return new Multi(this, args);
};
function select_callback (self, db, callback) {
function selectCallback (self, db, callback) {
return function (err, res) {
if (err === null) {
// Store db in this.select_db to restore it on reconnect
self.selected_db = db;
// Store db in this.selectDb to restore it on reconnect
self.selectedDb = db;
}
utils.callback_or_emit(self, callback, err, res);
utils.callbackOrEmit(self, callback, err, res);
};
}
RedisClient.prototype.select = RedisClient.prototype.SELECT = function select (db, callback) {
return this.internal_send_command(new Command('select', [db], select_callback(this, db, callback)));
return this.internalSendCommand(new Command('select', [db], selectCallback(this, db, callback)));
};
Multi.prototype.select = Multi.prototype.SELECT = function select (db, callback) {
this.queue.push(new Command('select', [db], select_callback(this._client, db, callback)));
this.queue.push(new Command('select', [db], selectCallback(this._client, db, callback)));
return this;
};
RedisClient.prototype.monitor = RedisClient.prototype.MONITOR = function monitor (callback) {
// Use a individual command, as this is a special case that does not has to be checked for any other command
var self = this;
var call_on_write = function () {
var callOnWrite = function () {
// Activating monitor mode has to happen before Redis returned the callback. The monitor result is returned first.
// Therefore we expect the command to be properly processed. If this is not the case, it's not an issue either.
self.monitoring = true;
};
return this.internal_send_command(new Command('monitor', [], callback, call_on_write));
return this.internalSendCommand(new Command('monitor', [], callback, callOnWrite));
};
// Only works with batch, not in a transaction
Multi.prototype.monitor = Multi.prototype.MONITOR = function monitor (callback) {
// Use a individual command, as this is a special case that does not has to be checked for any other command
if (this.exec !== this.exec_transaction) {
if (this.exec !== this.execTransaction) {
var self = this;
var call_on_write = function () {
var callOnWrite = function () {
self._client.monitoring = true;
};
this.queue.push(new Command('monitor', [], callback, call_on_write));
this.queue.push(new Command('monitor', [], callback, callOnWrite));
return this;
}
// Set multi monitoring to indicate the exec that it should abort
@@ -79,7 +79,7 @@ Multi.prototype.monitor = Multi.prototype.MONITOR = function monitor (callback)
return this;
};
function quit_callback (self, callback) {
function quitCallback (self, callback) {
return function (err, res) {
if (err && err.code === 'NR_CLOSED') {
// Pretent the quit command worked properly in this case.
@@ -90,7 +90,7 @@ function quit_callback (self, callback) {
err = null;
res = 'OK';
}
utils.callback_or_emit(self, callback, err, res);
utils.callbackOrEmit(self, callback, err, res);
if (self.stream.writable) {
// If the socket is still alive, kill it. This could happen if quit got a NR_CLOSED error code
self.stream.destroy();
@@ -101,40 +101,40 @@ function quit_callback (self, callback) {
RedisClient.prototype.QUIT = RedisClient.prototype.quit = function quit (callback) {
// TODO: Consider this for v.3
// Allow the quit command to be fired as soon as possible to prevent it landing in the offline queue.
// this.ready = this.offline_queue.length === 0;
var backpressure_indicator = this.internal_send_command(new Command('quit', [], quit_callback(this, callback)));
// this.ready = this.offlineQueue.length === 0;
var backpressureIndicator = this.internalSendCommand(new Command('quit', [], quitCallback(this, callback)));
// Calling quit should always end the connection, no matter if there's a connection or not
this.closing = true;
this.ready = false;
return backpressure_indicator;
return backpressureIndicator;
};
// Only works with batch, not in a transaction
Multi.prototype.QUIT = Multi.prototype.quit = function quit (callback) {
var self = this._client;
var call_on_write = function () {
var callOnWrite = function () {
// If called in a multi context, we expect redis is available
self.closing = true;
self.ready = false;
};
this.queue.push(new Command('quit', [], quit_callback(self, callback), call_on_write));
this.queue.push(new Command('quit', [], quitCallback(self, callback), callOnWrite));
return this;
};
function info_callback (self, callback) {
function infoCallback (self, callback) {
return function (err, res) {
if (res) {
var obj = {};
var lines = res.toString().split('\r\n');
var line, parts, sub_parts;
var line, parts, subParts;
for (var i = 0; i < lines.length; i++) {
parts = lines[i].split(':');
if (parts[1]) {
if (parts[0].indexOf('db') === 0) {
sub_parts = parts[1].split(',');
subParts = parts[1].split(',');
obj[parts[0]] = {};
while (line = sub_parts.pop()) {
while (line = subParts.pop()) {
line = line.split('=');
obj[parts[0]][line[0]] = +line[1];
}
@@ -150,15 +150,15 @@ function info_callback (self, callback) {
});
}
// Expose info key/vals to users
self.server_info = obj;
self.serverInfo = obj;
} else {
self.server_info = {};
self.serverInfo = {};
}
utils.callback_or_emit(self, callback, err, res);
utils.callbackOrEmit(self, callback, err, res);
};
}
// Store info in this.server_info after each call
// Store info in this.serverInfo after each call
RedisClient.prototype.info = RedisClient.prototype.INFO = function info (section, callback) {
var args = [];
if (typeof section === 'function') {
@@ -166,7 +166,7 @@ RedisClient.prototype.info = RedisClient.prototype.INFO = function info (section
} else if (section !== undefined) {
args = Array.isArray(section) ? section : [section];
}
return this.internal_send_command(new Command('info', args, info_callback(this, callback)));
return this.internalSendCommand(new Command('info', args, infoCallback(this, callback)));
};
Multi.prototype.info = Multi.prototype.INFO = function info (section, callback) {
@@ -176,14 +176,14 @@ Multi.prototype.info = Multi.prototype.INFO = function info (section, callback)
} else if (section !== undefined) {
args = Array.isArray(section) ? section : [section];
}
this.queue.push(new Command('info', args, info_callback(this._client, callback)));
this.queue.push(new Command('info', args, infoCallback(this._client, callback)));
return this;
};
function auth_callback (self, pass, callback) {
function authCallback (self, pass, callback) {
return function (err, res) {
if (err) {
if (no_password_is_set.test(err.message)) {
if (noPasswordIsSet.test(err.message)) {
self.warn('Warning: Redis server does not require a password, but a password was supplied.');
err = null;
res = 'OK';
@@ -196,29 +196,29 @@ function auth_callback (self, pass, callback) {
return;
}
}
utils.callback_or_emit(self, callback, err, res);
utils.callbackOrEmit(self, callback, err, res);
};
}
RedisClient.prototype.auth = RedisClient.prototype.AUTH = function auth (pass, callback) {
debug('Sending auth to ' + this.address + ' id ' + this.connection_id);
debug('Sending auth to ' + this.address + ' id ' + this.connectionId);
// Stash auth for connect and reconnect.
this.auth_pass = pass;
this.authPass = pass;
var ready = this.ready;
this.ready = ready || this.offline_queue.length === 0;
var tmp = this.internal_send_command(new Command('auth', [pass], auth_callback(this, pass, callback)));
this.ready = ready || this.offlineQueue.length === 0;
var tmp = this.internalSendCommand(new Command('auth', [pass], authCallback(this, pass, callback)));
this.ready = ready;
return tmp;
};
// Only works with batch, not in a transaction
Multi.prototype.auth = Multi.prototype.AUTH = function auth (pass, callback) {
debug('Sending auth to ' + this.address + ' id ' + this.connection_id);
debug('Sending auth to ' + this.address + ' id ' + this.connectionId);
// Stash auth for connect and reconnect.
this.auth_pass = pass;
this.queue.push(new Command('auth', [pass], auth_callback(this._client, callback)));
this.authPass = pass;
this.queue.push(new Command('auth', [pass], authCallback(this._client, callback)));
return this;
};
@@ -253,18 +253,18 @@ RedisClient.prototype.client = RedisClient.prototype.CLIENT = function client ()
}
}
var self = this;
var call_on_write = undefined;
var callOnWrite = undefined;
// CLIENT REPLY ON|OFF|SKIP
/* istanbul ignore next: TODO: Remove this as soon as Travis runs Redis 3.2 */
if (arr.length === 2 && arr[0].toString().toUpperCase() === 'REPLY') {
var reply_on_off = arr[1].toString().toUpperCase();
if (reply_on_off === 'ON' || reply_on_off === 'OFF' || reply_on_off === 'SKIP') {
call_on_write = function () {
self.reply = reply_on_off;
var replyOnOff = arr[1].toString().toUpperCase();
if (replyOnOff === 'ON' || replyOnOff === 'OFF' || replyOnOff === 'SKIP') {
callOnWrite = function () {
self.reply = replyOnOff;
};
}
}
return this.internal_send_command(new Command('client', arr, callback, call_on_write));
return this.internalSendCommand(new Command('client', arr, callback, callOnWrite));
};
Multi.prototype.client = Multi.prototype.CLIENT = function client () {
@@ -298,18 +298,18 @@ Multi.prototype.client = Multi.prototype.CLIENT = function client () {
}
}
var self = this._client;
var call_on_write = undefined;
var callOnWrite = undefined;
// CLIENT REPLY ON|OFF|SKIP
/* istanbul ignore next: TODO: Remove this as soon as Travis runs Redis 3.2 */
if (arr.length === 2 && arr[0].toString().toUpperCase() === 'REPLY') {
var reply_on_off = arr[1].toString().toUpperCase();
if (reply_on_off === 'ON' || reply_on_off === 'OFF' || reply_on_off === 'SKIP') {
call_on_write = function () {
self.reply = reply_on_off;
var replyOnOff = arr[1].toString().toUpperCase();
if (replyOnOff === 'ON' || replyOnOff === 'OFF' || replyOnOff === 'SKIP') {
callOnWrite = function () {
self.reply = replyOnOff;
};
}
}
this.queue.push(new Command('client', arr, callback, call_on_write));
this.queue.push(new Command('client', arr, callback, callOnWrite));
return this;
};
@@ -349,7 +349,7 @@ RedisClient.prototype.hmset = RedisClient.prototype.HMSET = function hmset () {
arr[i] = arguments[i];
}
}
return this.internal_send_command(new Command('hmset', arr, callback));
return this.internalSendCommand(new Command('hmset', arr, callback));
};
Multi.prototype.hmset = Multi.prototype.HMSET = function hmset () {
@@ -413,10 +413,10 @@ RedisClient.prototype.subscribe = RedisClient.prototype.SUBSCRIBE = function sub
}
}
var self = this;
var call_on_write = function () {
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
var callOnWrite = function () {
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
return this.internal_send_command(new Command('subscribe', arr, callback, call_on_write));
return this.internalSendCommand(new Command('subscribe', arr, callback, callOnWrite));
};
Multi.prototype.subscribe = Multi.prototype.SUBSCRIBE = function subscribe () {
@@ -440,10 +440,10 @@ Multi.prototype.subscribe = Multi.prototype.SUBSCRIBE = function subscribe () {
}
}
var self = this._client;
var call_on_write = function () {
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
var callOnWrite = function () {
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
this.queue.push(new Command('subscribe', arr, callback, call_on_write));
this.queue.push(new Command('subscribe', arr, callback, callOnWrite));
return this;
};
@@ -468,11 +468,11 @@ RedisClient.prototype.unsubscribe = RedisClient.prototype.UNSUBSCRIBE = function
}
}
var self = this;
var call_on_write = function () {
var callOnWrite = function () {
// Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
return this.internal_send_command(new Command('unsubscribe', arr, callback, call_on_write));
return this.internalSendCommand(new Command('unsubscribe', arr, callback, callOnWrite));
};
Multi.prototype.unsubscribe = Multi.prototype.UNSUBSCRIBE = function unsubscribe () {
@@ -496,11 +496,11 @@ Multi.prototype.unsubscribe = Multi.prototype.UNSUBSCRIBE = function unsubscribe
}
}
var self = this._client;
var call_on_write = function () {
var callOnWrite = function () {
// Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
this.queue.push(new Command('unsubscribe', arr, callback, call_on_write));
this.queue.push(new Command('unsubscribe', arr, callback, callOnWrite));
return this;
};
@@ -525,10 +525,10 @@ RedisClient.prototype.psubscribe = RedisClient.prototype.PSUBSCRIBE = function p
}
}
var self = this;
var call_on_write = function () {
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
var callOnWrite = function () {
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
return this.internal_send_command(new Command('psubscribe', arr, callback, call_on_write));
return this.internalSendCommand(new Command('psubscribe', arr, callback, callOnWrite));
};
Multi.prototype.psubscribe = Multi.prototype.PSUBSCRIBE = function psubscribe () {
@@ -552,10 +552,10 @@ Multi.prototype.psubscribe = Multi.prototype.PSUBSCRIBE = function psubscribe ()
}
}
var self = this._client;
var call_on_write = function () {
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
var callOnWrite = function () {
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
this.queue.push(new Command('psubscribe', arr, callback, call_on_write));
this.queue.push(new Command('psubscribe', arr, callback, callOnWrite));
return this;
};
@@ -580,11 +580,11 @@ RedisClient.prototype.punsubscribe = RedisClient.prototype.PUNSUBSCRIBE = functi
}
}
var self = this;
var call_on_write = function () {
var callOnWrite = function () {
// Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
return this.internal_send_command(new Command('punsubscribe', arr, callback, call_on_write));
return this.internalSendCommand(new Command('punsubscribe', arr, callback, callOnWrite));
};
Multi.prototype.punsubscribe = Multi.prototype.PUNSUBSCRIBE = function punsubscribe () {
@@ -608,10 +608,10 @@ Multi.prototype.punsubscribe = Multi.prototype.PUNSUBSCRIBE = function punsubscr
}
}
var self = this._client;
var call_on_write = function () {
var callOnWrite = function () {
// Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
self.pubSubMode = self.pubSubMode || self.commandQueue.length + 1;
};
this.queue.push(new Command('punsubscribe', arr, callback, call_on_write));
this.queue.push(new Command('punsubscribe', arr, callback, callOnWrite));
return this;
};

102
lib/multi.js
View File

@@ -7,25 +7,25 @@ var Command = require('./command');
function Multi (client, args) {
this._client = client;
this.queue = new Queue();
var command, tmp_args;
var command, tmpArgs;
if (args) { // Either undefined or an array. Fail hard if it's not an array
for (var i = 0; i < args.length; i++) {
command = args[i][0];
tmp_args = args[i].slice(1);
tmpArgs = args[i].slice(1);
if (Array.isArray(command)) {
this[command[0]].apply(this, command.slice(1).concat(tmp_args));
this[command[0]].apply(this, command.slice(1).concat(tmpArgs));
} else {
this[command].apply(this, tmp_args);
this[command].apply(this, tmpArgs);
}
}
}
}
function pipeline_transaction_command (self, command_obj, index) {
function pipelineTransactionCommand (self, commandObj, index) {
// Queueing is done first, then the commands are executed
var tmp = command_obj.callback;
command_obj.callback = function (err, reply) {
// Ignore the multi command. This is applied by node_redis and the user does not benefit by it
var tmp = commandObj.callback;
commandObj.callback = function (err, reply) {
// Ignore the multi command. This is applied by nodeRedis and the user does not benefit by it
if (err && index !== -1) {
if (tmp) {
tmp(err);
@@ -34,22 +34,22 @@ function pipeline_transaction_command (self, command_obj, index) {
self.errors.push(err);
}
// Keep track of who wants buffer responses:
// By the time the callback is called the command_obj got the buffer_args attribute attached
self.wants_buffers[index] = command_obj.buffer_args;
command_obj.callback = tmp;
// By the time the callback is called the commandObj got the bufferArgs attribute attached
self.wantsBuffers[index] = commandObj.bufferArgs;
commandObj.callback = tmp;
};
self._client.internal_send_command(command_obj);
self._client.internalSendCommand(commandObj);
}
Multi.prototype.exec_atomic = Multi.prototype.EXEC_ATOMIC = Multi.prototype.execAtomic = function exec_atomic (callback) {
Multi.prototype.execAtomic = Multi.prototype.EXEC_ATOMIC = Multi.prototype.execAtomic = function execAtomic (callback) {
if (this.queue.length < 2) {
return this.exec_batch(callback);
return this.execBatch(callback);
}
return this.exec(callback);
};
function multi_callback (self, err, replies) {
var i = 0, command_obj;
function multiCallback (self, err, replies) {
var i = 0, commandObj;
if (err) {
err.errors = self.errors;
@@ -63,22 +63,22 @@ function multi_callback (self, err, replies) {
}
if (replies) {
while (command_obj = self.queue.shift()) {
while (commandObj = self.queue.shift()) {
if (replies[i] instanceof Error) {
var match = replies[i].message.match(utils.err_code);
var match = replies[i].message.match(utils.errCode);
// LUA script could return user errors that don't behave like all other errors!
if (match) {
replies[i].code = match[1];
}
replies[i].command = command_obj.command.toUpperCase();
if (typeof command_obj.callback === 'function') {
command_obj.callback(replies[i]);
replies[i].command = commandObj.command.toUpperCase();
if (typeof commandObj.callback === 'function') {
commandObj.callback(replies[i]);
}
} else {
// If we asked for strings, even in detect_buffers mode, then return strings:
replies[i] = self._client.handle_reply(replies[i], command_obj.command, self.wants_buffers[i]);
if (typeof command_obj.callback === 'function') {
command_obj.callback(null, replies[i]);
// If we asked for strings, even in detectBuffers mode, then return strings:
replies[i] = self._client.handleReply(replies[i], commandObj.command, self.wantsBuffers[i]);
if (typeof commandObj.callback === 'function') {
commandObj.callback(null, replies[i]);
}
}
i++;
@@ -90,37 +90,37 @@ function multi_callback (self, err, replies) {
}
}
Multi.prototype.exec_transaction = function exec_transaction (callback) {
Multi.prototype.execTransaction = function execTransaction (callback) {
if (this.monitoring || this._client.monitoring) {
var err = new RangeError(
'Using transaction with a client that is in monitor mode does not work due to faulty return values of Redis.'
);
err.command = 'EXEC';
err.code = 'EXECABORT';
return utils.reply_in_order(this._client, callback, err);
return utils.replyInOrder(this._client, callback, err);
}
var self = this;
var len = self.queue.length;
self.errors = [];
self.callback = callback;
self._client.cork();
self.wants_buffers = new Array(len);
pipeline_transaction_command(self, new Command('multi', []), -1);
self.wantsBuffers = new Array(len);
pipelineTransactionCommand(self, new Command('multi', []), -1);
// Drain queue, callback will catch 'QUEUED' or error
for (var index = 0; index < len; index++) {
// The commands may not be shifted off, since they are needed in the result handler
pipeline_transaction_command(self, self.queue.get(index), index);
pipelineTransactionCommand(self, self.queue.get(index), index);
}
self._client.internal_send_command(new Command('exec', [], function (err, replies) {
multi_callback(self, err, replies);
self._client.internalSendCommand(new Command('exec', [], function (err, replies) {
multiCallback(self, err, replies);
}));
self._client.uncork();
return !self._client.should_buffer;
return !self._client.shouldBuffer;
};
function batch_callback (self, cb, i) {
return function batch_callback (err, res) {
function batchCallback (self, cb, i) {
return function batchCallback (err, res) {
if (err) {
self.results[i] = err;
// Add the position to the error
@@ -132,24 +132,24 @@ function batch_callback (self, cb, i) {
};
}
Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = function exec_batch (callback) {
Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.execBatch = function execBatch (callback) {
var self = this;
var len = self.queue.length;
var index = 0;
var command_obj;
var commandObj;
if (len === 0) {
utils.reply_in_order(self._client, callback, null, []);
return !self._client.should_buffer;
utils.replyInOrder(self._client, callback, null, []);
return !self._client.shouldBuffer;
}
self._client.cork();
if (!callback) {
while (command_obj = self.queue.shift()) {
self._client.internal_send_command(command_obj);
while (commandObj = self.queue.shift()) {
self._client.internalSendCommand(commandObj);
}
self._client.uncork();
return !self._client.should_buffer;
return !self._client.shouldBuffer;
}
var callback_without_own_cb = function (err, res) {
var callbackWithoutOwnCb = function (err, res) {
if (err) {
self.results.push(err);
// Add the position to the error
@@ -161,27 +161,27 @@ Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = funct
// Do not emit an error here. Otherwise each error would result in one emit.
// The errors will be returned in the result anyway
};
var last_callback = function (cb) {
var lastCallback = function (cb) {
return function (err, res) {
cb(err, res);
callback(null, self.results);
};
};
self.results = [];
while (command_obj = self.queue.shift()) {
if (typeof command_obj.callback === 'function') {
command_obj.callback = batch_callback(self, command_obj.callback, index);
while (commandObj = self.queue.shift()) {
if (typeof commandObj.callback === 'function') {
commandObj.callback = batchCallback(self, commandObj.callback, index);
} else {
command_obj.callback = callback_without_own_cb;
commandObj.callback = callbackWithoutOwnCb;
}
if (typeof callback === 'function' && index === len - 1) {
command_obj.callback = last_callback(command_obj.callback);
commandObj.callback = lastCallback(commandObj.callback);
}
this._client.internal_send_command(command_obj);
this._client.internalSendCommand(commandObj);
index++;
}
self._client.uncork();
return !self._client.should_buffer;
return !self._client.shouldBuffer;
};
module.exports = Multi;

45
lib/utils.js
View File

@@ -30,10 +30,8 @@ function replyToStrings (reply) {
return reply;
}
var camelCase;
// Deep clone arbitrary objects with arrays. Can't handle cyclic structures (results in a range error)
// Any attribute with a non primitive value besides object and array will be passed by reference (e.g. Buffers, Maps, Functions)
// All capital letters are going to be replaced with a lower case letter and a underscore infront of it
function clone (obj) {
var copy;
if (Array.isArray(obj)) {
@@ -48,18 +46,7 @@ function clone (obj) {
var elems = Object.keys(obj);
var elem;
while (elem = elems.pop()) {
if (elem === 'tls') { // special handle tls
copy[elem] = obj[elem];
continue;
}
// Accept camelCase options and convert them to snake_case
var snake_case = elem.replace(/[A-Z][^A-Z]/g, '_$&').toLowerCase();
// If camelCase is detected, pass it to the client, so all variables are going to be camelCased
// There are no deep nested options objects yet, but let's handle this future proof
if (snake_case !== elem.toLowerCase()) {
camelCase = true;
}
copy[snake_case] = clone(obj[elem]);
copy[elem] = clone(obj[elem]);
}
return copy;
}
@@ -67,12 +54,7 @@ function clone (obj) {
}
function convenienceClone (obj) {
camelCase = false;
obj = clone(obj) || {};
if (camelCase) {
obj.camel_case = true;
}
return obj;
return clone(obj) || {};
}
function callbackOrEmit (self, callback, err, res) {
@@ -86,20 +68,19 @@ function callbackOrEmit (self, callback, err, res) {
function replyInOrder (self, callback, err, res, queue) {
// If the queue is explicitly passed, use that, otherwise fall back to the offline queue first,
// as there might be commands in both queues at the same time
var command_obj;
/* istanbul ignore if: TODO: Remove this as soon as we test Redis 3.2 on travis */
var commandObj;
if (queue) {
command_obj = queue.peekBack();
commandObj = queue.peekBack();
} else {
command_obj = self.offline_queue.peekBack() || self.command_queue.peekBack();
commandObj = self.offlineQueue.peekBack() || self.commandQueue.peekBack();
}
if (!command_obj) {
if (!commandObj) {
process.nextTick(function () {
callbackOrEmit(self, callback, err, res);
});
} else {
var tmp = command_obj.callback;
command_obj.callback = tmp ?
var tmp = commandObj.callback;
commandObj.callback = tmp ?
function (e, r) {
tmp(e, r);
callbackOrEmit(self, callback, err, res);
@@ -114,11 +95,11 @@ function replyInOrder (self, callback, err, res, queue) {
}
module.exports = {
reply_to_strings: replyToStrings,
reply_to_object: replyToObject,
err_code: /^([A-Z]+)\s+(.+)$/,
replyToStrings: replyToStrings,
replyToObject: replyToObject,
errCode: /^([A-Z]+)\s+(.+)$/,
monitor_regex: /^[0-9]{10,11}\.[0-9]+ \[[0-9]+ .+\]( ".+?")+$/,
clone: convenienceClone,
callback_or_emit: callbackOrEmit,
reply_in_order: replyInOrder
callbackOrEmit: callbackOrEmit,
replyInOrder: replyInOrder
};