redis 0.10.2 → 0.12.1

package/.npmignore

@@ -1,2 +1,8 @@
-node_modules
-.tern-port
+examples/
+benches/
+test.js
+diff_multi_bench_output.js
+generate_commands.js
+multi_bench.js
+test-unref.js
+changelog.md

package/README.md

@@ -175,10 +175,15 @@ resume sending when you get `drain`.
 
 `client` will emit `idle` when there are no outstanding commands that are awaiting a response.
 
-## redis.createClient(port, host, options)
+## redis.createClient()
 
-Create a new client connection.  `port` defaults to `6379` and `host` defaults
-to `127.0.0.1`.  If you have `redis-server` running on the same computer as node, then the defaults for
+### overloading
+* redis.createClient() = redis.createClient(6379, '127.0.0.1', {})
+* redis.createClient(options) = redis.createClient(6379, '127.0.0.1', options)
+* redis.createClient(unix_socket, options)
+* redis.createClient(port, host, options)
+
+If you have `redis-server` running on the same computer as node, then the defaults for
 port and host are probably fine.  `options` in an object with the following possible properties:
 
 * `parser`: which Redis protocol reply parser to use.  Defaults to `hiredis` if that module is installed.
@@ -192,6 +197,7 @@ every command on a client.
 * `socket_nodelay`: defaults to `true`. Whether to call setNoDelay() on the TCP stream, which disables the
 Nagle algorithm on the underlying socket.  Setting this option to `false` can result in additional throughput at the
 cost of more latency.  Most applications will want this set to `true`.
+* `socket_keepalive` defaults to `true`. Whether the keep-alive functionality is enabled on the underlying socket. 
 * `no_ready_check`: defaults to `false`. When a connection is established to the Redis server, the server might still
 be loading the database from disk.  While loading, the server 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
@@ -210,10 +216,12 @@ limits total time for client to reconnect. Value is provided in milliseconds and
 * `max_attempts` defaults to `null`. By default client will try reconnecting until connected. Setting `max_attempts`
 limits total amount of reconnects.
 * `auth_pass` defaults to `null`. By default client will try connecting without auth. If set, client will run redis auth command on connect.
+* `family` defaults to `IPv4`. The client connects in IPv4 if not specified or if the DNS resolution returns an IPv4 address. 
+You can force an IPv6 if you set the family to 'IPv6'. See nodejs net or dns modules how to use the family type. 
 
 ```js
     var redis = require("redis"),
-        client = redis.createClient(null, null, {detect_buffers: true});
+        client = redis.createClient({detect_buffers: true});
 
     client.set("foo_rand000000000000", "OK");
 
@@ -231,24 +239,6 @@ limits total amount of reconnects.
 
 `createClient()` returns a `RedisClient` object that is named `client` in all of the examples here.
 
-### Unix Domain Socket
-
-You can also create a connection to Redis server via the unix domain socket if the server
-has it enabled:
-
-```js
-var redis = require("redis");
-var client = redis.createClient("/tmp/redis.sock");
-```
-
-Sample `redis.conf` configuration to enable unix domain socket listening:
-
-```conf
-unixsocket /tmp/redis.sock
-unixsocketperm 755
-```
-
-See [issue #204](https://github.com/mranney/node_redis/issues/204) for more information.
 
 ## client.auth(password, callback)
 

package/connection_breaker.js

@@ -0,0 +1,80 @@
+var net = require('net');
+
+var proxyPort = 6379;
+var counter = 0;
+
+function breaker(conn) {
+    conn.end();
+    conn.destroy();
+}
+
+var server = net.createServer(function(conn) {
+    counter++;
+    var proxyConn = net.createConnection({
+        port: proxyPort
+    });
+    conn.pipe(proxyConn);
+    proxyConn.pipe(conn);
+    proxyConn.on('end', function() {
+        conn.end();
+    });
+    conn.on('end', function() {
+        proxyConn.end();
+    });
+    conn.on('close', function() {
+        proxyConn.end();
+    });
+    proxyConn.on('close', function() {
+        conn.end();
+    });
+    proxyConn.on('error', function() {
+        conn.end();
+    });
+    conn.on('error', function() {
+        proxyConn.end();
+    });
+
+    setTimeout(breaker.bind(null, conn), Math.floor(Math.random() * 2000));
+});
+server.listen(6479);
+
+var redis = require('./');
+
+var port = 6479;
+
+var client = redis.createClient(6479, 'localhost');
+
+function iter() {
+    var k = "k" + Math.floor(Math.random() * 10);
+    var coinflip = Math.random() > 0.5;
+    if (coinflip) {
+        client.set(k, k, function(err, resp) {
+            if (!err && resp !== "OK") {
+                console.log("Unexpected set response " + resp);
+            }
+        });
+    } else {
+        client.get(k, function(err, resp) {
+            if (!err) {
+                if (k !== resp) {
+                    console.log("Key response mismatch: " + k + " " + resp);
+                }
+            }
+        });
+    }
+}
+
+function iters() {
+    for (var i = 0; i < 100; ++i) {
+        iter();
+    }
+    setTimeout(iters, 10);
+}
+
+client.on("connect", function () {
+    iters();
+});
+
+client.on("error", function (err) {
+    console.log("Client error " + err);
+});

package/index.js

@@ -43,6 +43,9 @@ function RedisClient(stream, options) {
     if (this.options.socket_nodelay === undefined) {
         this.options.socket_nodelay = true;
     }
+    if (this.options.socket_keepalive === undefined) {
+        this.options.socket_keepalive = true;
+    }
     this.should_buffer = false;
     this.command_queue_high_water = this.options.command_queue_high_water || 1000;
     this.command_queue_low_water = this.options.command_queue_low_water || 0;
@@ -81,6 +84,14 @@ function RedisClient(stream, options) {
 
     this.old_state = null;
 
+    this.install_stream_listeners();
+
+    events.EventEmitter.call(this);
+}
+util.inherits(RedisClient, events.EventEmitter);
+exports.RedisClient = RedisClient;
+
+RedisClient.prototype.install_stream_listeners = function() {
     var self = this;
 
     this.stream.on("connect", function () {
@@ -107,11 +118,7 @@ function RedisClient(stream, options) {
         self.should_buffer = false;
         self.emit("drain");
     });
-
-    events.EventEmitter.call(this);
-}
-util.inherits(RedisClient, events.EventEmitter);
-exports.RedisClient = RedisClient;
+};
 
 RedisClient.prototype.initialize_retry_vars = function () {
     this.retry_timer = null;
@@ -147,7 +154,9 @@ RedisClient.prototype.flush_and_error = function (message) {
             try {
                 command_obj.callback(error);
             } catch (callback_err) {
-                this.emit("error", callback_err);
+                process.nextTick(function () {
+                    throw callback_err;
+                });
             }
         }
     }
@@ -159,7 +168,9 @@ RedisClient.prototype.flush_and_error = function (message) {
             try {
                 command_obj.callback(error);
             } catch (callback_err) {
-                this.emit("error", callback_err);
+                process.nextTick(function () {
+                    throw callback_err;
+                });
             }
         }
     }
@@ -167,7 +178,7 @@ RedisClient.prototype.flush_and_error = function (message) {
 };
 
 RedisClient.prototype.on_error = function (msg) {
-    var message = "Redis connection to " + this.host + ":" + this.port + " failed - " + msg;
+    var message = "Redis connection to " + this.address + " failed - " + msg;
 
     if (this.closing) {
         return;
@@ -192,7 +203,7 @@ RedisClient.prototype.do_auth = function () {
     var self = this;
 
     if (exports.debug_mode) {
-        console.log("Sending auth to " + self.host + ":" + self.port + " id " + self.connection_id);
+        console.log("Sending auth to " + self.address + " id " + self.connection_id);
     }
     self.send_anyway = true;
     self.send_command("auth", [this.auth_pass], function (err, res) {
@@ -216,7 +227,7 @@ RedisClient.prototype.do_auth = function () {
             return self.emit("error", new Error("Auth failed: " + res.toString()));
         }
         if (exports.debug_mode) {
-            console.log("Auth succeeded " + self.host + ":" + self.port + " id " + self.connection_id);
+            console.log("Auth succeeded " + self.address + " id " + self.connection_id);
         }
         if (self.auth_callback) {
             self.auth_callback(err, res);
@@ -238,7 +249,7 @@ RedisClient.prototype.do_auth = function () {
 
 RedisClient.prototype.on_connect = function () {
     if (exports.debug_mode) {
-        console.log("Stream connected " + this.host + ":" + this.port + " id " + this.connection_id);
+        console.log("Stream connected " + this.address + " id " + this.connection_id);
     }
 
     this.connected = true;
@@ -249,6 +260,7 @@ RedisClient.prototype.on_connect = function () {
     if (this.options.socket_nodelay) {
         this.stream.setNoDelay();
     }
+    this.stream.setKeepAlive(this.options.socket_keepalive);
     this.stream.setTimeout(0);
 
     this.init_parser();
@@ -520,14 +532,15 @@ RedisClient.prototype.connection_gone = function (why) {
             return;
         }
 
-        self.stream.connect(self.port, self.host);
+        self.stream = net.createConnection(self.connectionOption);
+        self.install_stream_listeners();
         self.retry_timer = null;
     }, this.retry_delay);
 };
 
 RedisClient.prototype.on_data = function (data) {
     if (exports.debug_mode) {
-        console.log("net read " + this.host + ":" + this.port + " id " + this.connection_id + ": " + data.toString());
+        console.log("net read " + this.address + " id " + this.connection_id + ": " + data.toString());
     }
 
     try {
@@ -557,26 +570,37 @@ RedisClient.prototype.return_error = function (err) {
         try {
             command_obj.callback(err);
         } catch (callback_err) {
-            this.emit("error", callback_err);
+            // if a callback throws an exception, re-throw it on a new stack so the parser can keep going
+            process.nextTick(function () {
+                throw callback_err;
+            });
         }
     } else {
         console.log("node_redis: no callback to send error: " + err.message);
-        this.emit("error", err);
+        // this will probably not make it anywhere useful, but we might as well throw
+        process.nextTick(function () {
+            throw err;
+        });
     }
 };
 
 // if a callback throws an exception, re-throw it on a new stack so the parser can keep going.
 // if a domain is active, emit the error on the domain, which will serve the same function.
 // put this try/catch in its own function because V8 doesn't optimize this well yet.
-function try_callback(client, callback, reply) {
+function try_callback(callback, reply) {
     try {
         callback(null, reply);
     } catch (err) {
         if (process.domain) {
-            process.domain.emit('error', err);
-            process.domain.exit();
+            var currDomain = process.domain;
+            currDomain.emit('error', err);
+            if (process.domain === currDomain) {
+                currDomain.exit();
+            }
         } else {
-            client.emit("error", err);
+            process.nextTick(function () {
+                throw err;
+            });
         }
     }
 }
@@ -658,7 +682,7 @@ RedisClient.prototype.return_reply = function (reply) {
                 reply = reply_to_object(reply);
             }
 
-            try_callback(this, command_obj.callback, reply);
+            try_callback(command_obj.callback, reply);
         } else if (exports.debug_mode) {
             console.log("no callback for reply: " + (reply && reply.toString && reply.toString()));
         }
@@ -684,7 +708,7 @@ RedisClient.prototype.return_reply = function (reply) {
                 // reply[1] can be null
                 var reply1String = (reply[1] === null) ? null : reply[1].toString();
                 if (command_obj && typeof command_obj.callback === "function") {
-                    try_callback(this, command_obj.callback, reply1String);
+                    try_callback(command_obj.callback, reply1String);
                 }
                 this.emit(type, reply1String, reply[2]); // channel, count
             } else {
@@ -828,7 +852,7 @@ RedisClient.prototype.send_command = function (command, args, callback) {
             command_str += "$" + Buffer.byteLength(arg) + "\r\n" + arg + "\r\n";
         }
         if (exports.debug_mode) {
-            console.log("send " + this.host + ":" + this.port + " id " + this.connection_id + ": " + command_str);
+            console.log("send " + this.address + " id " + this.connection_id + ": " + command_str);
         }
         buffered_writes += !stream.write(command_str);
     } else {
@@ -908,6 +932,14 @@ RedisClient.prototype.pub_sub_command = function (command_obj) {
 
 RedisClient.prototype.end = function () {
     this.stream._events = {};
+
+    //clear retry_timer
+    if(this.retry_timer){
+        clearTimeout(this.retry_timer);
+        this.retry_timer=null;
+    }
+    this.stream.on("error", function(){});
+
     this.connected = false;
     this.ready = false;
     this.closing = true;
@@ -1181,17 +1213,64 @@ RedisClient.prototype.eval = RedisClient.prototype.EVAL = function () {
 };
 
 
-exports.createClient = function (port_arg, host_arg, options) {
-    var port = port_arg || default_port,
-        host = host_arg || default_host,
-        redis_client, net_client;
+exports.createClient = function(arg0, arg1, arg2){
+    if( arguments.length === 0 ){
+
+        // createClient()
+        return createClient_tcp(default_port, default_host, {});
+
+    } else if( typeof arg0 === 'number' ||
+        typeof arg0 === 'string' && arg0.match(/^\d+$/) ){
+
+        // createClient( 3000, host, options)
+        // createClient('3000', host, options)
+        return createClient_tcp(arg0, arg1, arg2);
+
+    } else if( typeof arg0 === 'string' ){
+
+        // createClient( '/tmp/redis.sock', options)
+        return createClient_unix(arg0,arg1);
+
+    } else if( arg0 !== null && typeof arg0 === 'object' ){
+
+        // createClient(options)
+        return createClient_tcp(default_port, default_host, arg0 );
+
+    } else if( arg0 === null && arg1 === null ){
+
+        // for backward compatibility
+        // createClient(null,null,options)
+        return createClient_tcp(default_port, default_host, arg2);
 
-    net_client = net.createConnection(port, host);
+    } else {
+        throw new Error('unknown type of connection in createClient()');
+    }
+}
+
+var createClient_unix = function(path, options){
+    var cnxOptions = {
+        path: path
+    };
+    var net_client = net.createConnection(cnxOptions);
+    var redis_client = new RedisClient(net_client, options || {});
 
-    redis_client = new RedisClient(net_client, options);
+    redis_client.connectionOption = cnxOptions;
+    redis_client.address = path;
+
+    return redis_client;
+}
+
+var createClient_tcp = function (port_arg, host_arg, options) {
+    var cnxOptions = {
+        'port' : port_arg || default_port,
+        'host' : host_arg || default_host,
+        'family' : (options && options.family === 'IPv6') ? 6 : 4
+    };
+    var net_client = net.createConnection(cnxOptions);
+    var redis_client = new RedisClient(net_client, options || {});
 
-    redis_client.port = port;
-    redis_client.host = host;
+    redis_client.connectionOption = cnxOptions;
+    redis_client.address = cnxOptions.host + ':' + cnxOptions.port;
 
     return redis_client;
 };

package/lib/commands.js

@@ -1,4 +1,4 @@
-// This file was generated by ./generate_commands.js on Sun Dec 15 2013 15:58:20 GMT+0000 (GMT)
+// This file was generated by ./generate_commands.js on Wed Apr 23 2014 14:51:21 GMT-0700 (PDT)
 module.exports = [
     "append",
     "auth",
@@ -6,12 +6,14 @@ module.exports = [
     "bgsave",
     "bitcount",
     "bitop",
+    "bitpos",
     "blpop",
     "brpop",
     "brpoplpush",
     "client kill",
     "client list",
     "client getname",
+    "client pause",
     "client setname",
     "config get",
     "config rewrite",
@@ -78,6 +80,9 @@ module.exports = [
     "persist",
     "pexpire",
     "pexpireat",
+    "pfadd",
+    "pfcount",
+    "pfmerge",
     "ping",
     "psetex",
     "psubscribe",
@@ -137,10 +142,13 @@ module.exports = [
     "zcount",
     "zincrby",
     "zinterstore",
+    "zlexcount",
     "zrange",
+    "zrangebylex",
     "zrangebyscore",
     "zrank",
     "zrem",
+    "zremrangebylex",
     "zremrangebyrank",
     "zremrangebyscore",
     "zrevrange",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis",
-  "version": "0.10.2",
+  "version": "0.12.1",
   "description": "Redis client library",
   "keywords": [
     "redis",

package/benches/buffer_bench.js

@@ -1,89 +0,0 @@
-var source = new Buffer(100),
-    dest = new Buffer(100), i, j, k, tmp, count = 1000000, bytes = 100;
-    
-for (i = 99 ; i >= 0 ; i--) {
-    source[i] = 120;
-}
-
-var str = "This is a nice String.",
-    buf = new Buffer("This is a lovely Buffer.");
-
-var start = new Date();
-for (i = count * 100; i > 0 ; i--) {
-    if (Buffer.isBuffer(str)) {}
-}
-var end = new Date();
-console.log("Buffer.isBuffer(str) " + (end - start) + " ms");
-
-var start = new Date();
-for (i = count * 100; i > 0 ; i--) {
-    if (Buffer.isBuffer(buf)) {}
-}
-var end = new Date();
-console.log("Buffer.isBuffer(buf) " + (end - start) + " ms");
-
-var start = new Date();
-for (i = count * 100; i > 0 ; i--) {
-    if (str instanceof Buffer) {}
-}
-var end = new Date();
-console.log("str instanceof Buffer " + (end - start) + " ms");
-
-var start = new Date();
-for (i = count * 100; i > 0 ; i--) {
-    if (buf instanceof Buffer) {}
-}
-var end = new Date();
-console.log("buf instanceof Buffer " + (end - start) + " ms");
-
-for (i = bytes ; i > 0 ; i --) {
-    var start = new Date();
-    for (j = count ; j > 0; j--) {
-        tmp = source.toString("ascii", 0, bytes);
-    }
-    var end = new Date();
-    console.log("toString() " + i + " bytes " + (end - start) + " ms");
-}
-
-for (i = bytes ; i > 0 ; i --) {
-    var start = new Date();
-    for (j = count ; j > 0; j--) {
-        tmp = "";
-        for (k = 0; k <= i ; k++) {
-            tmp += String.fromCharCode(source[k]);
-        }
-    }
-    var end = new Date();
-    console.log("manual string " + i + " bytes " + (end - start) + " ms");
-}
-
-for (i = bytes ; i > 0 ; i--) {
-    var start = new Date();
-    for (j = count ; j > 0 ; j--) {
-        for (k = i ; k > 0 ; k--) {
-            dest[k] = source[k];
-        }
-    }
-    var end = new Date();
-    console.log("Manual copy " + i + " bytes " + (end - start) + " ms");
-}
-
-for (i = bytes ; i > 0 ; i--) {
-    var start = new Date();
-    for (j = count ; j > 0 ; j--) {
-        for (k = i ; k > 0 ; k--) {
-            dest[k] = 120;
-        }
-    }
-    var end = new Date();
-    console.log("Direct assignment " + i + " bytes " + (end - start) + " ms");
-}
-
-for (i = bytes ; i > 0 ; i--) {
-    var start = new Date();
-    for (j = count ; j > 0 ; j--) {
-        source.copy(dest, 0, 0, i);
-    }
-    var end = new Date();
-    console.log("Buffer.copy() " + i + " bytes " + (end - start) + " ms");
-}

package/benches/hiredis_parser.js

@@ -1,38 +0,0 @@
-var Parser = require('../lib/parser/hiredis').Parser;
-var assert = require('assert');
-
-/*
-This test makes sure that exceptions thrown inside of "reply" event handlers
-are not trapped and mistakenly emitted as parse errors.
-*/
-(function testExecuteDoesNotCatchReplyCallbackExceptions() {
-  var parser = new Parser();
-  var replies = [{}];
-
-  parser.reader = {
-    feed: function() {},
-    get: function() {
-      return replies.shift();
-    }
-  };
-
-  var emittedError = false;
-  var caughtException = false;
-
-  parser
-    .on('error', function() {
-      emittedError = true;
-    })
-    .on('reply', function() {
-      throw new Error('bad');
-    });
-
-  try {
-    parser.execute();
-  } catch (err) {
-    caughtException = true;
-  }
-
-  assert.equal(caughtException, true);
-  assert.equal(emittedError, false);
-})();

package/benches/re_sub_test.js

@@ -1,14 +0,0 @@
-var client = require('../index').createClient()
-  , client2 = require('../index').createClient()
-  , assert = require('assert');
-
-client.once('subscribe', function (channel, count) {
-  client.unsubscribe('x');
-  client.subscribe('x', function () {
-    client.quit();
-    client2.quit();
-  });
-  client2.publish('x', 'hi');
-});
-
-client.subscribe('x');

package/benches/reconnect_test.js

@@ -1,29 +0,0 @@
-var redis = require("../index").createClient(null, null, {
-//    max_attempts: 4
-});
-
-redis.on("error", function (err) {
-    console.log("Redis says: " + err);
-});
-
-redis.on("ready", function () {
-    console.log("Redis ready.");
-});
-
-redis.on("reconnecting", function (arg) {
-    console.log("Redis reconnecting: " + JSON.stringify(arg));
-});
-redis.on("connect", function () {
-    console.log("Redis connected.");
-});
-
-setInterval(function () {
-    var now = Date.now();
-    redis.set("now", now, function (err, res) {
-        if (err) {
-            console.log(now + " Redis reply error: " + err);
-        } else {
-            console.log(now + " Redis reply: " + res);
-        }
-    });
-}, 100);

package/benches/stress/codec.js

@@ -1,16 +0,0 @@
-var json = {
-	encode: JSON.stringify,
-	decode: JSON.parse
-};
-
-var MsgPack = require('node-msgpack');
-msgpack = {
-	encode: MsgPack.pack,
-	decode: function(str) { return MsgPack.unpack(new Buffer(str)); }
-};
-
-bison = require('bison');
-
-module.exports = json;
-//module.exports = msgpack;
-//module.exports = bison;