You've already forked node-redis
mirror of
https://github.com/redis/node-redis.git
synced 2025-08-09 00:22:08 +03:00
7a5a4aa535
There is likely a better and more performant way to fix this but this works so far and should be good enough to release and improve later. Make test more robust Add another test
960 lines
37 KiB
JavaScript
960 lines
37 KiB
JavaScript
'use strict';
|
|
|
|
var net = require('net');
|
|
var tls = require('tls');
|
|
var util = require('util');
|
|
var utils = require('./lib/utils');
|
|
var Queue = require('double-ended-queue');
|
|
var Command = require('./lib/command').Command;
|
|
var OfflineCommand = require('./lib/command').OfflineCommand;
|
|
var EventEmitter = require('events');
|
|
var Parser = require('redis-parser');
|
|
var commands = require('redis-commands');
|
|
var debug = require('./lib/debug');
|
|
var unifyOptions = require('./lib/createClient');
|
|
|
|
// Newer Node.js versions > 0.10 return the EventEmitter right away and using .EventEmitter was deprecated
|
|
if (typeof EventEmitter !== 'function') {
|
|
EventEmitter = EventEmitter.EventEmitter;
|
|
}
|
|
|
|
function noop () {}
|
|
|
|
function handle_detect_buffers_reply (reply, command, buffer_args) {
|
|
if (buffer_args === false) {
|
|
// If detect_buffers option was specified, then the reply from the parser will be a buffer.
|
|
// If this command did not use Buffer arguments, then convert the reply to Strings here.
|
|
reply = utils.reply_to_strings(reply);
|
|
}
|
|
|
|
if (command === 'hgetall') {
|
|
reply = utils.reply_to_object(reply);
|
|
}
|
|
return reply;
|
|
}
|
|
|
|
exports.debug_mode = /\bredis\b/i.test(process.env.NODE_DEBUG);
|
|
|
|
// Attention: The second parameter might be removed at will and is not officially supported.
|
|
// Do not rely on this
|
|
function RedisClient (options, stream) {
|
|
// Copy the options so they are not mutated
|
|
options = utils.clone(options);
|
|
EventEmitter.call(this);
|
|
var cnx_options = {};
|
|
var self = this;
|
|
if (stream) {
|
|
// The stream from the outside is used so no connection from this side is triggered but from the server this client should talk to
|
|
// Reconnect etc won't work with this. This requires monkey patching to work, so it is not officially supported
|
|
options.stream = stream;
|
|
this.address = '"Private stream"';
|
|
} else if (options.path) {
|
|
cnx_options.path = options.path;
|
|
this.address = options.path;
|
|
} else {
|
|
cnx_options.port = +options.port || 6379;
|
|
cnx_options.host = options.host || '127.0.0.1';
|
|
cnx_options.family = (!options.family && net.isIP(cnx_options.host)) || (options.family === 'IPv6' ? 6 : 4);
|
|
this.address = cnx_options.host + ':' + cnx_options.port;
|
|
}
|
|
/* istanbul ignore next: travis does not work with stunnel atm. Therefor the tls tests are skipped on travis */
|
|
for (var tls_option in options.tls) { // jshint ignore: line
|
|
cnx_options[tls_option] = options.tls[tls_option];
|
|
}
|
|
// Warn on misusing deprecated functions
|
|
if (typeof options.retry_strategy === 'function') {
|
|
if ('max_attempts' in options) {
|
|
self.warn('WARNING: You activated the retry_strategy and max_attempts at the same time. This is not possible and max_attempts will be ignored.');
|
|
// Do not print deprecation warnings twice
|
|
delete options.max_attempts;
|
|
}
|
|
if ('retry_max_delay' in options) {
|
|
self.warn('WARNING: You activated the retry_strategy and retry_max_delay at the same time. This is not possible and retry_max_delay will be ignored.');
|
|
// Do not print deprecation warnings twice
|
|
delete options.retry_max_delay;
|
|
}
|
|
}
|
|
|
|
this.connection_options = cnx_options;
|
|
this.connection_id = RedisClient.connection_id++;
|
|
this.connected = false;
|
|
this.ready = false;
|
|
if (options.socket_nodelay === undefined) {
|
|
options.socket_nodelay = true;
|
|
} else if (!options.socket_nodelay) { // Only warn users with this set to false
|
|
self.warn(
|
|
'socket_nodelay is deprecated and will be removed in v.3.0.0.\n' +
|
|
'Setting socket_nodelay to false likely results in a reduced throughput. Please use .batch for pipelining instead.\n' +
|
|
'If you are sure you rely on the NAGLE-algorithm you can activate it by calling client.stream.setNoDelay(false) instead.'
|
|
);
|
|
}
|
|
if (options.socket_keepalive === undefined) {
|
|
options.socket_keepalive = true;
|
|
}
|
|
for (var command in options.rename_commands) { // jshint ignore: line
|
|
options.rename_commands[command.toLowerCase()] = options.rename_commands[command];
|
|
}
|
|
options.return_buffers = !!options.return_buffers;
|
|
options.detect_buffers = !!options.detect_buffers;
|
|
// Override the detect_buffers setting if return_buffers is active and print a warning
|
|
if (options.return_buffers && options.detect_buffers) {
|
|
self.warn('WARNING: You activated return_buffers and detect_buffers at the same time. The return value is always going to be a buffer.');
|
|
options.detect_buffers = false;
|
|
}
|
|
if (options.detect_buffers) {
|
|
// We only need to look at the arguments if we do not know what we have to return
|
|
this.handle_reply = handle_detect_buffers_reply;
|
|
}
|
|
this.should_buffer = false;
|
|
this.max_attempts = options.max_attempts | 0;
|
|
if ('max_attempts' in options) {
|
|
self.warn(
|
|
'max_attempts is deprecated and will be removed in v.3.0.0.\n' +
|
|
'To reduce the amount of options and the improve the reconnection handling please use the new `retry_strategy` option instead.\n' +
|
|
'This replaces the max_attempts and retry_max_delay option.'
|
|
);
|
|
}
|
|
this.command_queue = new Queue(); // Holds sent commands to de-pipeline them
|
|
this.offline_queue = new Queue(); // Holds commands issued but not able to be sent
|
|
// ATTENTION: connect_timeout should change in v.3.0 so it does not count towards ending reconnection attempts after x seconds
|
|
// This should be done by the retry_strategy. Instead it should only be the timeout for connecting to redis
|
|
this.connect_timeout = +options.connect_timeout || 3600000; // 60 * 60 * 1000 ms
|
|
this.enable_offline_queue = options.enable_offline_queue === false ? false : true;
|
|
this.retry_max_delay = +options.retry_max_delay || null;
|
|
if ('retry_max_delay' in options) {
|
|
self.warn(
|
|
'retry_max_delay is deprecated and will be removed in v.3.0.0.\n' +
|
|
'To reduce the amount of options and the improve the reconnection handling please use the new `retry_strategy` option instead.\n' +
|
|
'This replaces the max_attempts and retry_max_delay option.'
|
|
);
|
|
}
|
|
this.initialize_retry_vars();
|
|
this.pub_sub_mode = 0;
|
|
this.subscription_set = {};
|
|
this.monitoring = false;
|
|
this.closing = false;
|
|
this.server_info = {};
|
|
this.auth_pass = options.auth_pass || options.password;
|
|
this.selected_db = options.db; // Save the selected db here, used when reconnecting
|
|
this.old_state = null;
|
|
this.send_anyway = false;
|
|
this.pipeline = 0;
|
|
this.times_connected = 0;
|
|
this.options = options;
|
|
this.buffers = options.return_buffers || options.detect_buffers;
|
|
// Init parser
|
|
this.reply_parser = Parser({
|
|
returnReply: function (data) {
|
|
self.return_reply(data);
|
|
},
|
|
returnError: function (data) {
|
|
self.return_error(data);
|
|
},
|
|
returnFatalError: function (err) {
|
|
// Error out all fired commands. Otherwise they might rely on faulty data. We have to reconnect to get in a working state again
|
|
self.flush_and_error(err, ['command_queue']);
|
|
self.stream.destroy();
|
|
self.return_error(err);
|
|
},
|
|
returnBuffers: this.buffers,
|
|
name: options.parser
|
|
});
|
|
this.create_stream();
|
|
// The listeners will not be attached right away, so let's print the deprecation message while the listener is attached
|
|
this.on('newListener', function (event) {
|
|
if (event === 'idle') {
|
|
this.warn(
|
|
'The idle event listener is deprecated and will likely be removed in v.3.0.0.\n' +
|
|
'If you rely on this feature please open a new ticket in node_redis with your use case'
|
|
);
|
|
} else if (event === 'drain') {
|
|
this.warn(
|
|
'The drain event listener is deprecated and will be removed in v.3.0.0.\n' +
|
|
'If you want to keep on listening to this event please listen to the stream drain event directly.'
|
|
);
|
|
}
|
|
});
|
|
}
|
|
util.inherits(RedisClient, EventEmitter);
|
|
|
|
RedisClient.connection_id = 0;
|
|
|
|
// Attention: the function name "create_stream" should not be changed, as other libraries need this to mock the stream (e.g. fakeredis)
|
|
RedisClient.prototype.create_stream = function () {
|
|
var self = this;
|
|
|
|
if (this.options.stream) {
|
|
// Only add the listeners once in case of a reconnect try (that won't work)
|
|
if (this.stream) {
|
|
return;
|
|
}
|
|
this.stream = this.options.stream;
|
|
} else {
|
|
// On a reconnect destroy the former stream and retry
|
|
if (this.stream) {
|
|
this.stream.removeAllListeners();
|
|
this.stream.destroy();
|
|
}
|
|
|
|
/* istanbul ignore if: travis does not work with stunnel atm. Therefor the tls tests are skipped on travis */
|
|
if (this.options.tls) {
|
|
this.stream = tls.connect(this.connection_options);
|
|
} else {
|
|
this.stream = net.createConnection(this.connection_options);
|
|
}
|
|
}
|
|
|
|
if (this.options.connect_timeout) {
|
|
this.stream.setTimeout(this.connect_timeout, function () {
|
|
self.retry_totaltime = self.connect_timeout;
|
|
self.connection_gone('timeout', new Error('Redis connection gone from timeout event'));
|
|
});
|
|
}
|
|
|
|
/* istanbul ignore next: travis does not work with stunnel atm. Therefor the tls tests are skipped on travis */
|
|
var connect_event = this.options.tls ? 'secureConnect' : 'connect';
|
|
this.stream.once(connect_event, function () {
|
|
this.removeAllListeners('timeout');
|
|
self.times_connected++;
|
|
self.on_connect();
|
|
});
|
|
|
|
this.stream.on('data', function (buffer_from_socket) {
|
|
// The buffer_from_socket.toString() has a significant impact on big chunks and therefor this should only be used if necessary
|
|
debug('Net read ' + self.address + ' id ' + self.connection_id); // + ': ' + buffer_from_socket.toString());
|
|
self.reply_parser.execute(buffer_from_socket);
|
|
self.emit_idle();
|
|
});
|
|
|
|
this.stream.on('error', function (err) {
|
|
self.on_error(err);
|
|
});
|
|
|
|
/* istanbul ignore next: difficult to test and not important as long as we keep this listener */
|
|
this.stream.on('clientError', function (err) {
|
|
debug('clientError occured');
|
|
self.on_error(err);
|
|
});
|
|
|
|
this.stream.once('close', function (hadError) {
|
|
self.connection_gone('close', new Error('Stream connection closed' + (hadError ? ' because of a transmission error' : '')));
|
|
});
|
|
|
|
this.stream.once('end', function () {
|
|
self.connection_gone('end', new Error('Stream connection ended'));
|
|
});
|
|
|
|
this.stream.on('drain', function () {
|
|
self.drain();
|
|
});
|
|
|
|
if (this.options.socket_nodelay) {
|
|
this.stream.setNoDelay();
|
|
}
|
|
|
|
// Fire the command before redis is connected to be sure it's the first fired command
|
|
if (this.auth_pass !== undefined) {
|
|
this.auth(this.auth_pass);
|
|
}
|
|
};
|
|
|
|
RedisClient.prototype.handle_reply = function (reply, command) {
|
|
if (command === 'hgetall') {
|
|
reply = utils.reply_to_object(reply);
|
|
}
|
|
return reply;
|
|
};
|
|
|
|
RedisClient.prototype.cork = noop;
|
|
RedisClient.prototype.uncork = noop;
|
|
|
|
RedisClient.prototype.duplicate = function (options) {
|
|
var existing_options = utils.clone(this.options);
|
|
options = utils.clone(options);
|
|
for (var elem in options) { // jshint ignore: line
|
|
existing_options[elem] = options[elem];
|
|
}
|
|
var client = new RedisClient(existing_options);
|
|
client.selected_db = this.selected_db;
|
|
return client;
|
|
};
|
|
|
|
RedisClient.prototype.initialize_retry_vars = function () {
|
|
this.retry_timer = null;
|
|
this.retry_totaltime = 0;
|
|
this.retry_delay = 200;
|
|
this.retry_backoff = 1.7;
|
|
this.attempts = 1;
|
|
};
|
|
|
|
RedisClient.prototype.unref = function () {
|
|
if (this.connected) {
|
|
debug("Unref'ing the socket connection");
|
|
this.stream.unref();
|
|
} else {
|
|
debug('Not connected yet, will unref later');
|
|
this.once('connect', function () {
|
|
this.unref();
|
|
});
|
|
}
|
|
};
|
|
|
|
RedisClient.prototype.warn = function (msg) {
|
|
var self = this;
|
|
// Warn on the next tick. Otherwise no event listener can be added
|
|
// for warnings that are emitted in the redis client constructor
|
|
process.nextTick(function () {
|
|
if (self.listeners('warning').length !== 0) {
|
|
self.emit('warning', msg);
|
|
} else {
|
|
console.warn('node_redis:', msg);
|
|
}
|
|
});
|
|
};
|
|
|
|
// Flush provided queues, erroring any items with a callback first
|
|
RedisClient.prototype.flush_and_error = function (error, queue_names) {
|
|
queue_names = queue_names || ['offline_queue', 'command_queue'];
|
|
for (var i = 0; i < queue_names.length; i++) {
|
|
for (var command_obj = this[queue_names[i]].shift(); command_obj; command_obj = this[queue_names[i]].shift()) {
|
|
if (typeof command_obj.callback === 'function') {
|
|
error.command = command_obj.command.toUpperCase();
|
|
command_obj.callback(error);
|
|
}
|
|
}
|
|
this[queue_names[i]] = new Queue();
|
|
}
|
|
};
|
|
|
|
RedisClient.prototype.on_error = function (err) {
|
|
if (this.closing) {
|
|
return;
|
|
}
|
|
|
|
err.message = 'Redis connection to ' + this.address + ' failed - ' + err.message;
|
|
debug(err.message);
|
|
this.connected = false;
|
|
this.ready = false;
|
|
|
|
// Only emit the error if the retry_stategy option is not set
|
|
if (!this.options.retry_strategy) {
|
|
this.emit('error', err);
|
|
}
|
|
// 'error' events get turned into exceptions if they aren't listened for. If the user handled this error
|
|
// then we should try to reconnect.
|
|
this.connection_gone('error', err);
|
|
};
|
|
|
|
RedisClient.prototype.on_connect = function () {
|
|
debug('Stream connected ' + this.address + ' id ' + this.connection_id);
|
|
|
|
this.connected = true;
|
|
this.ready = false;
|
|
this.emitted_end = false;
|
|
this.stream.setKeepAlive(this.options.socket_keepalive);
|
|
this.stream.setTimeout(0);
|
|
|
|
this.emit('connect');
|
|
this.initialize_retry_vars();
|
|
|
|
if (this.options.no_ready_check) {
|
|
this.on_ready();
|
|
} else {
|
|
this.ready_check();
|
|
}
|
|
};
|
|
|
|
RedisClient.prototype.on_ready = function () {
|
|
var self = this;
|
|
|
|
debug('on_ready called ' + this.address + ' id ' + this.connection_id);
|
|
this.ready = true;
|
|
|
|
var cork;
|
|
if (!this.stream.cork) {
|
|
cork = function (len) {
|
|
self.pipeline = len;
|
|
self.pipeline_queue = new Queue(len);
|
|
};
|
|
} else {
|
|
cork = function (len) {
|
|
self.pipeline = len;
|
|
self.pipeline_queue = new Queue(len);
|
|
self.stream.cork();
|
|
};
|
|
this.uncork = function () {
|
|
self.stream.uncork();
|
|
};
|
|
}
|
|
this.cork = cork;
|
|
|
|
// Restore modal commands from previous connection. The order of the commands is important
|
|
if (this.selected_db !== undefined) {
|
|
this.send_command('select', [this.selected_db]);
|
|
}
|
|
if (this.old_state !== null) {
|
|
this.monitoring = this.old_state.monitoring;
|
|
this.pub_sub_mode = this.old_state.pub_sub_mode;
|
|
}
|
|
if (this.monitoring) { // Monitor has to be fired before pub sub commands
|
|
this.send_command('monitor', []);
|
|
}
|
|
var callback_count = Object.keys(this.subscription_set).length;
|
|
if (!this.options.disable_resubscribing && callback_count) {
|
|
// only emit 'ready' when all subscriptions were made again
|
|
// TODO: Remove the countdown for ready here. This is not coherent with all other modes and should therefor not be handled special
|
|
// We know we are ready as soon as all commands were fired
|
|
var callback = function () {
|
|
callback_count--;
|
|
if (callback_count === 0) {
|
|
self.emit('ready');
|
|
}
|
|
};
|
|
debug('Sending pub/sub on_ready commands');
|
|
for (var key in this.subscription_set) { // jshint ignore: line
|
|
var command = key.slice(0, key.indexOf('_'));
|
|
var args = self.subscription_set[key];
|
|
self.send_command(command, [args], callback);
|
|
}
|
|
this.send_offline_queue();
|
|
return;
|
|
}
|
|
this.send_offline_queue();
|
|
this.emit('ready');
|
|
};
|
|
|
|
RedisClient.prototype.on_info_cmd = function (err, res) {
|
|
if (err) {
|
|
if (err.message === "ERR unknown command 'info'") {
|
|
this.on_ready();
|
|
return;
|
|
}
|
|
err.message = 'Ready check failed: ' + err.message;
|
|
this.emit('error', err);
|
|
return;
|
|
}
|
|
|
|
/* istanbul ignore if: some servers might not respond with any info data. This is just a safety check that is difficult to test */
|
|
if (!res) {
|
|
debug('The info command returned without any data.');
|
|
this.on_ready();
|
|
return;
|
|
}
|
|
|
|
if (!this.server_info.loading || this.server_info.loading === '0') {
|
|
// If the master_link_status exists but the link is not up, try again after 50 ms
|
|
if (this.server_info.master_link_status && this.server_info.master_link_status !== 'up') {
|
|
this.server_info.loading_eta_seconds = 0.05;
|
|
} else {
|
|
// Eta loading should change
|
|
debug('Redis server ready.');
|
|
this.on_ready();
|
|
return;
|
|
}
|
|
}
|
|
|
|
var retry_time = +this.server_info.loading_eta_seconds * 1000;
|
|
if (retry_time > 1000) {
|
|
retry_time = 1000;
|
|
}
|
|
debug('Redis server still loading, trying again in ' + retry_time);
|
|
setTimeout(function (self) {
|
|
self.ready_check();
|
|
}, retry_time, this);
|
|
};
|
|
|
|
RedisClient.prototype.ready_check = function () {
|
|
var self = this;
|
|
debug('Checking server ready state...');
|
|
// Always fire this info command as first command even if other commands are already queued up
|
|
this.ready = true;
|
|
this.info(function (err, res) {
|
|
self.on_info_cmd(err, res);
|
|
});
|
|
this.ready = false;
|
|
};
|
|
|
|
RedisClient.prototype.send_offline_queue = function () {
|
|
for (var command_obj = this.offline_queue.shift(); command_obj; command_obj = this.offline_queue.shift()) {
|
|
debug('Sending offline command: ' + command_obj.command);
|
|
this.send_command(command_obj.command, command_obj.args, command_obj.callback);
|
|
}
|
|
this.drain();
|
|
// Even though items were shifted off, Queue backing store still uses memory until next add, so just get a new Queue
|
|
this.offline_queue = new Queue();
|
|
};
|
|
|
|
var retry_connection = function (self, error) {
|
|
debug('Retrying connection...');
|
|
|
|
self.emit('reconnecting', {
|
|
delay: self.retry_delay,
|
|
attempt: self.attempts,
|
|
error: error,
|
|
times_connected: self.times_connected,
|
|
total_retry_time: self.retry_totaltime
|
|
});
|
|
|
|
self.retry_totaltime += self.retry_delay;
|
|
self.attempts += 1;
|
|
self.retry_delay = Math.round(self.retry_delay * self.retry_backoff);
|
|
self.create_stream();
|
|
self.retry_timer = null;
|
|
};
|
|
|
|
RedisClient.prototype.connection_gone = function (why, error) {
|
|
// If a retry is already in progress, just let that happen
|
|
if (this.retry_timer) {
|
|
return;
|
|
}
|
|
|
|
debug('Redis connection is gone from ' + why + ' event.');
|
|
this.connected = false;
|
|
this.ready = false;
|
|
// Deactivate cork to work with the offline queue
|
|
this.cork = noop;
|
|
this.pipeline = 0;
|
|
|
|
var state = {
|
|
monitoring: this.monitoring,
|
|
pub_sub_mode: this.pub_sub_mode
|
|
};
|
|
this.old_state = state;
|
|
this.monitoring = false;
|
|
this.pub_sub_mode = 0;
|
|
|
|
// since we are collapsing end and close, users don't expect to be called twice
|
|
if (!this.emitted_end) {
|
|
this.emit('end');
|
|
this.emitted_end = true;
|
|
}
|
|
|
|
// If this is a requested shutdown, then don't retry
|
|
if (this.closing) {
|
|
debug('Connection ended from quit command, not retrying.');
|
|
this.flush_and_error(new Error('Redis connection gone from ' + why + ' event.'));
|
|
return;
|
|
}
|
|
|
|
if (typeof this.options.retry_strategy === 'function') {
|
|
this.retry_delay = this.options.retry_strategy({
|
|
attempt: this.attempts,
|
|
error: error,
|
|
total_retry_time: this.retry_totaltime,
|
|
times_connected: this.times_connected
|
|
});
|
|
if (typeof this.retry_delay !== 'number') {
|
|
// Pass individual error through
|
|
if (this.retry_delay instanceof Error) {
|
|
error = this.retry_delay;
|
|
}
|
|
this.flush_and_error(error);
|
|
this.emit('error', error);
|
|
this.end(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (this.max_attempts !== 0 && this.attempts >= this.max_attempts || this.retry_totaltime >= this.connect_timeout) {
|
|
var message = this.retry_totaltime >= this.connect_timeout ?
|
|
'connection timeout exceeded.' :
|
|
'maximum connection attempts exceeded.';
|
|
error = new Error('Redis connection in broken state: ' + message);
|
|
error.code = 'CONNECTION_BROKEN';
|
|
this.flush_and_error(error);
|
|
this.emit('error', error);
|
|
this.end(false);
|
|
return;
|
|
}
|
|
|
|
// Retry commands after a reconnect instead of throwing an error. Use this with caution
|
|
if (this.options.retry_unfulfilled_commands) {
|
|
this.offline_queue.unshift.apply(this.offline_queue, this.command_queue.toArray());
|
|
this.command_queue.clear();
|
|
} else if (this.command_queue.length !== 0) {
|
|
error = new Error('Redis connection lost and command aborted in uncertain state. It might have been processed.');
|
|
error.code = 'UNCERTAIN_STATE';
|
|
this.flush_and_error(error, ['command_queue']);
|
|
error.message = 'Redis connection lost and commands aborted in uncertain state. They might have been processed.';
|
|
this.emit('error', error);
|
|
}
|
|
|
|
if (this.retry_max_delay !== null && this.retry_delay > this.retry_max_delay) {
|
|
this.retry_delay = this.retry_max_delay;
|
|
} else if (this.retry_totaltime + this.retry_delay > this.connect_timeout) {
|
|
// Do not exceed the maximum
|
|
this.retry_delay = this.connect_timeout - this.retry_totaltime;
|
|
}
|
|
|
|
debug('Retry connection in ' + this.retry_delay + ' ms');
|
|
|
|
this.retry_timer = setTimeout(retry_connection, this.retry_delay, this, error);
|
|
};
|
|
|
|
RedisClient.prototype.return_error = function (err) {
|
|
var command_obj = this.command_queue.shift();
|
|
if (command_obj && command_obj.command && command_obj.command.toUpperCase) {
|
|
err.command = command_obj.command.toUpperCase();
|
|
}
|
|
|
|
var match = err.message.match(utils.err_code);
|
|
// LUA script could return user errors that don't behave like all other errors!
|
|
if (match) {
|
|
err.code = match[1];
|
|
}
|
|
|
|
utils.callback_or_emit(this, command_obj && command_obj.callback, err);
|
|
};
|
|
|
|
RedisClient.prototype.drain = function () {
|
|
this.emit('drain');
|
|
this.should_buffer = false;
|
|
};
|
|
|
|
RedisClient.prototype.emit_idle = function () {
|
|
if (this.command_queue.length === 0 && this.pub_sub_mode === 0) {
|
|
this.emit('idle');
|
|
}
|
|
};
|
|
|
|
function normal_reply (self, reply) {
|
|
var command_obj = self.command_queue.shift();
|
|
if (typeof command_obj.callback === 'function') {
|
|
if ('exec' !== command_obj.command) {
|
|
reply = self.handle_reply(reply, command_obj.command, command_obj.buffer_args);
|
|
}
|
|
command_obj.callback(null, reply);
|
|
} else {
|
|
debug('No callback for reply');
|
|
}
|
|
}
|
|
|
|
function set_subscribe (self, type, command_obj, subscribe, reply) {
|
|
var i = 0;
|
|
if (subscribe) {
|
|
// The channels have to be saved one after the other and the type has to be the same too,
|
|
// to make sure partly subscribe / unsubscribe works well together
|
|
for (; i < command_obj.args.length; i++) {
|
|
self.subscription_set[type + '_' + command_obj.args[i]] = command_obj.args[i];
|
|
}
|
|
} else {
|
|
type = type === 'unsubscribe' ? 'subscribe' : 'psubscribe'; // Make types consistent
|
|
for (; i < command_obj.args.length; i++) {
|
|
delete self.subscription_set[type + '_' + command_obj.args[i]];
|
|
}
|
|
if (reply[2] === 0) { // No channels left that this client is subscribed to
|
|
var running_command;
|
|
i = 0;
|
|
// This should be a rare case and therefor handling it this way should be good performance wise for the general case
|
|
while (running_command = self.command_queue.get(i++)) {
|
|
if (
|
|
running_command.command === 'subscribe' ||
|
|
running_command.command === 'psubscribe' ||
|
|
running_command.command === 'unsubscribe' ||
|
|
running_command.command === 'punsubscribe'
|
|
) {
|
|
self.pub_sub_mode = i;
|
|
return;
|
|
}
|
|
}
|
|
self.pub_sub_mode = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
function subscribe_unsubscribe (self, reply, type, subscribe) {
|
|
// Subscribe commands take an optional callback and also emit an event, but only the _last_ response is included in the callback
|
|
var command_obj = self.command_queue.get(0);
|
|
var buffer = self.options.return_buffers || self.options.detect_buffers && command_obj && command_obj.buffer_args || reply[1] === null;
|
|
var channel = buffer ? reply[1] : reply[1].toString();
|
|
var count = reply[2];
|
|
debug('Subscribe / unsubscribe command');
|
|
|
|
// Emit first, then return the callback
|
|
if (channel !== null) { // Do not emit something if there was no channel to unsubscribe from
|
|
self.emit(type, channel, count);
|
|
}
|
|
// The pub sub commands return each argument in a separate return value and have to be handled that way
|
|
if (command_obj.sub_commands_left <= 1) {
|
|
if (count !== 0 && !subscribe && command_obj.args.length === 0) {
|
|
command_obj.sub_commands_left = count;
|
|
return;
|
|
}
|
|
self.command_queue.shift();
|
|
set_subscribe(self, type, command_obj, subscribe, reply);
|
|
if (typeof command_obj.callback === 'function') {
|
|
// TODO: The current return value is pretty useless.
|
|
// Evaluate to change this in v.3 to return all subscribed / unsubscribed channels in an array including the number of channels subscribed too
|
|
command_obj.callback(null, channel);
|
|
}
|
|
} else {
|
|
command_obj.sub_commands_left--;
|
|
}
|
|
}
|
|
|
|
function return_pub_sub (self, reply) {
|
|
var type = reply[0].toString();
|
|
if (type === 'message') { // channel, message
|
|
// TODO: Implement message_buffer
|
|
// if (self.buffers) {
|
|
// self.emit('message_buffer', reply[1], reply[2]);
|
|
// }
|
|
if (!self.options.return_buffers) { // backwards compatible. Refactor this in v.3 to always return a string on the normal emitter
|
|
self.emit('message', reply[1].toString(), reply[2].toString());
|
|
} else {
|
|
self.emit('message', reply[1], reply[2]);
|
|
}
|
|
} else if (type === 'pmessage') { // pattern, channel, message
|
|
// if (self.buffers) {
|
|
// self.emit('pmessage_buffer', reply[1], reply[2], reply[3]);
|
|
// }
|
|
if (!self.options.return_buffers) { // backwards compatible. Refactor this in v.3 to always return a string on the normal emitter
|
|
self.emit('pmessage', reply[1].toString(), reply[2].toString(), reply[3].toString());
|
|
} else {
|
|
self.emit('pmessage', reply[1], reply[2], reply[3]);
|
|
}
|
|
} else if (type === 'subscribe' || type === 'psubscribe') {
|
|
subscribe_unsubscribe(self, reply, type, true);
|
|
} else if (type === 'unsubscribe' || type === 'punsubscribe') {
|
|
subscribe_unsubscribe(self, reply, type, false);
|
|
} else {
|
|
normal_reply(self, reply);
|
|
}
|
|
}
|
|
|
|
RedisClient.prototype.return_reply = function (reply) {
|
|
if (this.pub_sub_mode === 1 && reply instanceof Array && reply.length !== 0 && reply[0]) {
|
|
return_pub_sub(this, reply);
|
|
} else {
|
|
if (this.pub_sub_mode !== 0 && this.pub_sub_mode !== 1) {
|
|
this.pub_sub_mode--;
|
|
}
|
|
normal_reply(this, reply);
|
|
}
|
|
};
|
|
|
|
function handle_offline_command (self, command_obj) {
|
|
var command = command_obj.command;
|
|
var callback = command_obj.callback;
|
|
var err, msg;
|
|
if (self.closing || !self.enable_offline_queue) {
|
|
command = command.toUpperCase();
|
|
if (!self.closing) {
|
|
if (self.stream.writable) {
|
|
msg = 'The connection is not yet established and the offline queue is deactivated.';
|
|
} else {
|
|
msg = 'Stream not writeable.';
|
|
}
|
|
} else {
|
|
msg = 'The connection has already been closed.';
|
|
}
|
|
err = new Error(command + " can't be processed. " + msg);
|
|
err.command = command;
|
|
utils.reply_in_order(self, callback, err);
|
|
} else {
|
|
debug('Queueing ' + command + ' for next server connection.');
|
|
self.offline_queue.push(command_obj);
|
|
}
|
|
self.should_buffer = true;
|
|
}
|
|
|
|
RedisClient.prototype.send_command = function (command, args, callback) {
|
|
var args_copy, arg, prefix_keys;
|
|
var i = 0;
|
|
var command_str = '';
|
|
var len = 0;
|
|
var big_data = false;
|
|
var buffer_args = false;
|
|
|
|
if (process.domain && callback) {
|
|
callback = process.domain.bind(callback);
|
|
}
|
|
|
|
if (this.ready === false || this.stream.writable === false) {
|
|
// Handle offline commands right away
|
|
handle_offline_command(this, new OfflineCommand(command, args, callback));
|
|
return false; // Indicate buffering
|
|
}
|
|
|
|
if (typeof args === 'undefined') {
|
|
args_copy = [];
|
|
} else {
|
|
len = args.length;
|
|
args_copy = new Array(len);
|
|
}
|
|
|
|
for (i = 0; i < len; i += 1) {
|
|
if (typeof args[i] === 'string') {
|
|
// 30000 seemed to be a good value to switch to buffers after testing and checking the pros and cons
|
|
if (args[i].length > 30000) {
|
|
big_data = true;
|
|
args_copy[i] = new Buffer(args[i], 'utf8');
|
|
if (this.pipeline !== 0) {
|
|
this.pipeline += 2;
|
|
this.writeDefault = this.writeBuffers;
|
|
}
|
|
} else {
|
|
args_copy[i] = args[i];
|
|
}
|
|
} else if (typeof args[i] === 'object') { // Checking for object instead of Buffer.isBuffer helps us finding data types that we can't handle properly
|
|
if (args[i] instanceof Date) { // Accept dates as valid input
|
|
args_copy[i] = args[i].toString();
|
|
} else if (args[i] === null) {
|
|
this.warn(
|
|
'Deprecated: The ' + command.toUpperCase() + ' command contains a "null" argument.\n' +
|
|
'This is converted to a "null" string now and will return an error from v.3.0 on.\n' +
|
|
'Please handle this in your code to make sure everything works as you intended it to.'
|
|
);
|
|
args_copy[i] = 'null'; // Backwards compatible :/
|
|
} else if (Buffer.isBuffer(args[i])) {
|
|
args_copy[i] = args[i];
|
|
buffer_args = true;
|
|
big_data = true;
|
|
if (this.pipeline !== 0) {
|
|
this.pipeline += 2;
|
|
this.writeDefault = this.writeBuffers;
|
|
}
|
|
} else {
|
|
this.warn(
|
|
'Deprecated: The ' + command.toUpperCase() + ' command contains a argument of type ' + args[i].constructor.name + '.\n' +
|
|
'This is converted to "' + args[i].toString() + '" by using .toString() now and will return an error from v.3.0 on.\n' +
|
|
'Please handle this in your code to make sure everything works as you intended it to.'
|
|
);
|
|
args_copy[i] = args[i].toString(); // Backwards compatible :/
|
|
}
|
|
} else if (typeof args[i] === 'undefined') {
|
|
this.warn(
|
|
'Deprecated: The ' + command.toUpperCase() + ' command contains a "undefined" argument.\n' +
|
|
'This is converted to a "undefined" string now and will return an error from v.3.0 on.\n' +
|
|
'Please handle this in your code to make sure everything works as you intended it to.'
|
|
);
|
|
args_copy[i] = 'undefined'; // Backwards compatible :/
|
|
} else {
|
|
// Seems like numbers are converted fast using string concatenation
|
|
args_copy[i] = '' + args[i];
|
|
}
|
|
}
|
|
args = null;
|
|
var command_obj = new Command(command, args_copy, callback);
|
|
command_obj.buffer_args = buffer_args;
|
|
|
|
if (command === 'subscribe' || command === 'psubscribe' || command === 'unsubscribe' || command === 'punsubscribe') {
|
|
// If pub sub is already activated, keep it that way, otherwise set the number of commands to resolve until pub sub mode activates
|
|
// Deactivation of the pub sub mode happens in the result handler
|
|
if (!this.pub_sub_mode) {
|
|
this.pub_sub_mode = this.command_queue.length + 1;
|
|
}
|
|
} else if (command === 'quit') {
|
|
this.closing = true;
|
|
}
|
|
this.command_queue.push(command_obj);
|
|
|
|
if (this.options.prefix) {
|
|
prefix_keys = commands.getKeyIndexes(command, args_copy);
|
|
for (i = prefix_keys.pop(); i !== undefined; i = prefix_keys.pop()) {
|
|
args_copy[i] = this.options.prefix + args_copy[i];
|
|
}
|
|
}
|
|
if (typeof this.options.rename_commands !== 'undefined' && this.options.rename_commands[command]) {
|
|
command = this.options.rename_commands[command];
|
|
}
|
|
// Always use 'Multi bulk commands', but if passed any Buffer args, then do multiple writes, one for each arg.
|
|
// This means that using Buffers in commands is going to be slower, so use Strings if you don't already have a Buffer.
|
|
command_str = '*' + (len + 1) + '\r\n$' + command.length + '\r\n' + command + '\r\n';
|
|
|
|
if (big_data === false) { // Build up a string and send entire command in one write
|
|
for (i = 0; i < len; i += 1) {
|
|
arg = args_copy[i];
|
|
command_str += '$' + Buffer.byteLength(arg) + '\r\n' + arg + '\r\n';
|
|
}
|
|
debug('Send ' + this.address + ' id ' + this.connection_id + ': ' + command_str);
|
|
this.write(command_str);
|
|
} else {
|
|
debug('Send command (' + command_str + ') has Buffer arguments');
|
|
this.write(command_str);
|
|
|
|
for (i = 0; i < len; i += 1) {
|
|
arg = args_copy[i];
|
|
if (typeof arg === 'string') {
|
|
this.write('$' + Buffer.byteLength(arg) + '\r\n' + arg + '\r\n');
|
|
} else { // buffer
|
|
this.write('$' + arg.length + '\r\n');
|
|
this.write(arg);
|
|
this.write('\r\n');
|
|
}
|
|
debug('send_command: buffer send ' + arg.length + ' bytes');
|
|
}
|
|
}
|
|
return !this.should_buffer;
|
|
};
|
|
|
|
RedisClient.prototype.writeDefault = RedisClient.prototype.writeStrings = function (data) {
|
|
var str = '';
|
|
for (var command = this.pipeline_queue.shift(); command; command = this.pipeline_queue.shift()) {
|
|
// Write to stream if the string is bigger than 4mb. The biggest string may be Math.pow(2, 28) - 15 chars long
|
|
if (str.length + command.length > 4 * 1024 * 1024) {
|
|
this.stream.write(str);
|
|
str = '';
|
|
}
|
|
str += command;
|
|
}
|
|
this.should_buffer = !this.stream.write(str + data);
|
|
};
|
|
|
|
RedisClient.prototype.writeBuffers = function (data) {
|
|
for (var command = this.pipeline_queue.shift(); command; command = this.pipeline_queue.shift()) {
|
|
this.stream.write(command);
|
|
}
|
|
this.should_buffer = !this.stream.write(data);
|
|
};
|
|
|
|
RedisClient.prototype.write = function (data) {
|
|
if (this.pipeline === 0) {
|
|
this.should_buffer = !this.stream.write(data);
|
|
return;
|
|
}
|
|
|
|
this.pipeline--;
|
|
if (this.pipeline === 0) {
|
|
this.writeDefault(data);
|
|
return;
|
|
}
|
|
|
|
this.pipeline_queue.push(data);
|
|
return;
|
|
};
|
|
|
|
RedisClient.prototype.end = function (flush) {
|
|
// Flush queue if wanted
|
|
if (flush) {
|
|
this.flush_and_error(new Error("The command can't be processed. The connection has already been 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.'
|
|
);
|
|
}
|
|
// Clear retry_timer
|
|
if (this.retry_timer){
|
|
clearTimeout(this.retry_timer);
|
|
this.retry_timer = null;
|
|
}
|
|
this.stream.removeAllListeners();
|
|
this.stream.on('error', noop);
|
|
this.connected = false;
|
|
this.ready = false;
|
|
this.closing = true;
|
|
return this.stream.destroySoon();
|
|
};
|
|
|
|
exports.createClient = function () {
|
|
return new RedisClient(unifyOptions.apply(null, arguments));
|
|
};
|
|
exports.RedisClient = RedisClient;
|
|
exports.print = utils.print;
|
|
exports.Multi = require('./lib/multi');
|
|
|
|
// Add all redis commands to the client
|
|
require('./lib/individualCommands');
|
|
require('./lib/commands');
|