redis 2.6.1 → 2.6.5

package/README.md

@@ -6,7 +6,7 @@ redis - a node.js redis client
 [![Windows Tests](https://img.shields.io/appveyor/ci/BridgeAR/node-redis/master.svg?label=Windows%20Tests)](https://ci.appveyor.com/project/BridgeAR/node-redis/branch/master)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/NodeRedis/node_redis?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
-This is a complete and feature rich Redis client for node.js. It supports all Redis commands and focuses on high performance.
+This is a complete and feature rich Redis client for node.js. __It supports all Redis commands__ and focuses on high performance.
 
 Install with:
 
@@ -189,8 +189,8 @@ __Tip:__ If the Redis server runs on the same machine as the client consider usi
 | socket_keepalive | true | If set to `true`, the keep-alive functionality is enabled on the underlying socket. |
 | no_ready_check | false |  When a connection is established to the Redis server, the server might still be loading the database from disk. While loading, the server will not respond to any commands. To work around this, `node_redis` has a "ready check" which sends the `INFO` command to the server. The response from the `INFO` command indicates whether the server is ready for more commands. When ready, `node_redis` emits a `ready` event. Setting `no_ready_check` to `true` will inhibit this check. |
 | enable_offline_queue |  true | By default, if there is no active connection to the Redis server, commands are added to a queue and are executed once the connection has been established. Setting `enable_offline_queue` to `false` will disable this feature and the callback will be executed immediately with an error, or an error will be emitted if no callback is specified. |
-| retry_max_delay | null | By default, every time the client tries to connect and fails, the reconnection delay almost doubles. This delay normally grows infinitely, but setting `retry_max_delay` limits it to the maximum value provided in milliseconds. |
-| connect_timeout | 3600000 | Setting `connect_timeout` limits the total time for the client to connect and reconnect. The value is provided in milliseconds and is counted from the moment a new client is created or from the time the connection is lost. The last retry is going to happen exactly at the timeout time. Default is to try connecting until the default system socket timeout has been exceeded and to try reconnecting until 1h has elapsed. |
+| retry_max_delay | null | __Deprecated__ _Please use `retry_strategy` instead._ By default, every time the client tries to connect and fails, the reconnection delay almost doubles. This delay normally grows infinitely, but setting `retry_max_delay` limits it to the maximum value provided in milliseconds. |
+| connect_timeout | 3600000 | __Deprecated__ _Please use `retry_strategy` instead._ Setting `connect_timeout` limits the total time for the client to connect and reconnect. The value is provided in milliseconds and is counted from the moment a new client is created or from the time the connection is lost. The last retry is going to happen exactly at the timeout time. Default is to try connecting until the default system socket timeout has been exceeded and to try reconnecting until 1h has elapsed. |
 | max_attempts | 0 | __Deprecated__ _Please use `retry_strategy` instead._ By default, a client will try reconnecting until connected. Setting `max_attempts` limits total amount of connection attempts. Setting this to 1 will prevent any reconnect attempt. |
 | retry_unfulfilled_commands | false | If set to `true`, all commands that were unfulfilled while the connection is lost will be retried after the connection has been reestablished. Use this with caution if you use state altering commands (e.g. `incr`). This is especially useful if you use blocking commands. |
 | password | null | If set, client will run Redis auth command on connect. Alias `auth_pass` __Note__ `node_redis` < 2.5 must use `auth_pass` |
@@ -224,7 +224,7 @@ retry_strategy example
 ```js
 var client = redis.createClient({
     retry_strategy: function (options) {
-        if (options.error.code === 'ECONNREFUSED') {
+        if (options.error && options.error.code === 'ECONNREFUSED') {
             // End reconnecting on a specific error and flush all commands with a individual error
             return new Error('The server refused the connection');
         }
@@ -237,7 +237,7 @@ var client = redis.createClient({
             return undefined;
         }
         // reconnect after
-        return Math.max(options.attempt * 100, 3000);
+        return Math.min(options.attempt * 100, 3000);
     }
 });
 ```
@@ -658,6 +658,33 @@ the second word as first parameter:
 Duplicate all current options and return a new redisClient instance. All options passed to the duplicate function are going to replace the original option.
 If you pass a callback, duplicate is going to wait until the client is ready and returns it in the callback. If an error occurs in the meanwhile, that is going to return an error instead in the callback.
 
+One example of when to use duplicate() would be to accomodate the connection- 
+blocking redis commands BRPOP, BLPOP, and BRPOPLPUSH.  If these commands
+are used on the same redisClient instance as non-blocking commands, the 
+non-blocking ones may be queued up until after the blocking ones finish.
+
+    var Redis=require('redis');
+    var client = Redis.createClient();
+    var clientBlocking = client.duplicate();
+
+    var get = function() {
+        console.log("get called");
+        client.get("any_key",function() { console.log("get returned"); });
+        setTimeout( get, 1000 );
+    };
+    var brpop = function() {
+        console.log("brpop called");
+        clientBlocking.brpop("nonexistent", 5, function() {
+            console.log("brpop return");
+            setTimeout( brpop, 1000 );
+        });
+    };
+    get();
+    brpop();
+    
+Another reason to use duplicate() is when multiple DBs on the same server are 
+accessed via the redis SELECT command.  Each DB could use its own connection.
+    
 ## client.send_command(command_name[, [args][, callback]])
 
 All Redis commands have been added to the `client` object. However, if new commands are introduced before this library is updated,

package/changelog.md

@@ -1,6 +1,32 @@
 Changelog
 =========
 
+## v.2.6.5 - 15 Jan, 2017
+
+Bugfixes
+
+-  Fixed parser not being reset in case the redis connection closed ASAP for overcoming of output buffer limits
+-  Fixed parser reset if (p)message_buffer listener is attached
+
+## v.2.6.4 - 12 Jan, 2017
+
+Bugfixes
+
+-  Fixed monitor mode not working in combination with IPv6, sockets or lua scripts (2.6.0 regression)
+
+## v.2.6.3 - 31 Oct, 2016
+
+Bugfixes
+
+-  Do not change the tls setting to camel_case
+-  Fix domain handling in combination with the offline queue (2.5.3 regression)
+
+## v.2.6.2 - 16 Jun, 2016
+
+Bugfixes
+
+-  Fixed individual callbacks of a transaction not being called (2.6.0 regression)
+
 ## v.2.6.1 - 02 Jun, 2016
 
 Bugfixes
@@ -13,7 +39,7 @@ In addition to the pre-releases the following changes exist in v.2.6.0:
 
 Features
 
--  Updated [redis-parser](https://github.com/NodeRedis/redis-parser) dependency ([changelog](https://github.com/NodeRedis/redis-parser/releases/tag/v.2.0.0))
+-  Updated [redis-parser](https://github.com/NodeRedis/node-redis-parser) dependency ([changelog](https://github.com/NodeRedis/node-redis-parser/releases/tag/v.2.0.0))
  -  The JS parser is from now on the new default as it is a lot faster than the hiredis parser
  -  This is no BC as there is no changed behavior for the user at all but just a performance improvement. Explicitly requireing the Hiredis parser is still possible.
 -  Added name property to all Redis functions (Node.js >= 4.0)

package/index.js

@@ -156,8 +156,6 @@ function RedisClient (options, stream) {
     this.buffers = options.return_buffers || options.detect_buffers;
     this.options = options;
     this.reply = 'ON'; // Returning replies is the default
-    // Init parser
-    this.reply_parser = create_parser(this);
     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) {
@@ -171,10 +169,16 @@ function RedisClient (options, stream) {
                 '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.'
             );
-        } else if (event === 'message_buffer' || event === 'pmessage_buffer' || event === 'messageBuffer' || event === 'pmessageBuffer' && !this.buffers) {
+        } else if ((event === 'message_buffer' || event === 'pmessage_buffer' || event === 'messageBuffer' || event === 'pmessageBuffer') && !this.buffers && !this.message_buffers) {
+            if (this.reply_parser.name !== 'javascript') {
+                return this.warn(
+                    'You attached the ' + event + ' without the hiredis parser without the returnBuffers option set to true.\n' +
+                    'Please use the JavaScript parser or set the returnBuffers option to true to return buffers.'
+                );
+            }
+            this.reply_parser.optionReturnBuffers = true;
             this.message_buffers = true;
             this.handle_reply = handle_detect_buffers_reply;
-            this.reply_parser = create_parser(this);
         }
     });
 }
@@ -224,6 +228,9 @@ function create_parser (self) {
 RedisClient.prototype.create_stream = function () {
     var self = this;
 
+    // Init parser
+    this.reply_parser = create_parser(this);
+
     if (this.options.stream) {
         // Only add the listeners once in case of a reconnect try (that won't work)
         if (this.stream) {
@@ -791,9 +798,6 @@ function return_pub_sub (self, reply) {
 }
 
 RedisClient.prototype.return_reply = function (reply) {
-    // If in monitor mode, all normal commands are still working and we only want to emit the streamlined commands
-    // As this is not the average use case and monitor is expensive anyway, let's change the code here, to improve
-    // the average performance of all other commands in case of no monitor mode
     if (this.monitoring) {
         var replyStr;
         if (this.buffers && Buffer.isBuffer(reply)) {
@@ -801,8 +805,7 @@ RedisClient.prototype.return_reply = function (reply) {
         } else {
             replyStr = reply;
         }
-        // While reconnecting the redis server does not recognize the client as in monitor mode anymore
-        // Therefore the monitor command has to finish before it catches further commands
+        // If in monitor mode, all normal commands are still working and we only want to emit the streamlined commands
         if (typeof replyStr === 'string' && utils.monitor_regex.test(replyStr)) {
             var timestamp = replyStr.slice(0, replyStr.indexOf(' '));
             var args = replyStr.slice(replyStr.indexOf('"') + 1, -1).split('" "').map(function (elem) {
@@ -868,16 +871,16 @@ RedisClient.prototype.internal_send_command = function (command_obj) {
     var big_data = false;
     var args_copy = new Array(len);
 
+    if (process.domain && command_obj.callback) {
+        command_obj.callback = process.domain.bind(command_obj.callback);
+    }
+
     if (this.ready === false || this.stream.writable === false) {
         // Handle offline commands right away
         handle_offline_command(this, command_obj);
         return false; // Indicate buffering
     }
 
-    if (process.domain && command_obj.callback) {
-        command_obj.callback = process.domain.bind(command_obj.callback);
-    }
-
     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

package/lib/multi.js

@@ -36,6 +36,7 @@ function pipeline_transaction_command (self, command_obj, index) {
         // 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;
     };
     self._client.internal_send_command(command_obj);
 }

package/lib/utils.js

@@ -57,6 +57,10 @@ 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
@@ -123,7 +127,7 @@ module.exports = {
     reply_to_object: replyToObject,
     print: print,
     err_code: /^([A-Z]+)\s+(.+)$/,
-    monitor_regex: /^[0-9]{10,11}\.[0-9]+ \[[0-9]{1,3} [0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}:[0-9]{1,5}\].*/,
+    monitor_regex: /^[0-9]{10,11}\.[0-9]+ \[[0-9]{1,3} (.(?!\]))+.\]( ".+?")+$/,
     clone: convenienceClone,
     callback_or_emit: callbackOrEmit,
     reply_in_order: replyInOrder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis",
-  "version": "2.6.1",
+  "version": "2.6.5",
   "description": "Redis client library",
   "keywords": [
     "database",
@@ -21,7 +21,7 @@
     "coverage": "nyc report --reporter=html",
     "benchmark": "node benchmarks/multi_bench.js",
     "test": "nyc --cache mocha ./test/*.js ./test/commands/*.js --timeout=8000",
-    "posttest": "eslint . --fix && npm run coverage",
+    "lint": "eslint . --fix && npm run coverage",
     "compare": "node benchmarks/diff_multi_bench_output.js beforeBench.txt afterBench.txt"
   },
   "dependencies": {
@@ -36,10 +36,10 @@
     "bluebird": "^3.0.2",
     "coveralls": "^2.11.2",
     "intercept-stdout": "~0.1.2",
-    "eslint": "^2.5.0",
+    "eslint": "^3.5.0",
     "metrics": "^0.1.9",
     "mocha": "^2.3.2",
-    "nyc": "^6.0.0",
+    "nyc": "^8.3.0",
     "tcp-port-used": "^0.1.2",
     "uuid": "^2.0.1",
     "win-spawn": "^2.0.0"