redis 3.0.6 → 3.0.7

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MWU4NjJlZTMzODJmNjI0MTk5ZWQ4Yzk1OGIxNGUwYmQzNzcwZGM0Zg==
-  data.tar.gz: !binary |-
-    ZmQzMjMxMmU2NWRhY2E3NGE1N2I1OWExMjQxMzQ2YmY1MzcxOTM2Mw==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NTZjYTMwZjU5ZWMwZDI0ZWM4OTZmZGU3YmMzMGJlZmZjMDUxNjUwMzNhZGMy
-    OTZkOWJmNTM5NTQzMWUyZTRjZmMzNWQ5MDY1NDljNzJiNWMzMGE4NGZjMDI0
-    YzM4YTE5MGM5MWVmN2YyYTI3YTViMzljMDg2YzQyYTZlY2M0OTE=
-  data.tar.gz: !binary |-
-    Mzk0NmVkMmEwYjc1MzIzOTU4MDEwN2QwNmRhZThkMzA2NzIyOTU5YjlmMzMz
-    Y2NkZjUyZTE5YmI2MjFiZTA4YjNkOWMzZWEwYWRkMjZlNDgzNTc3NDViOTRl
-    ZDMyZDlhYThhZjMxOGM5YzE1NjNkZDQzNjAwODEyNjM3ZmQ3OWE=
+SHA1:
+  metadata.gz: f19cb52776a7c819c4e77758ef023e958a9929f8
+  data.tar.gz: 38c26138524df7d89fe8c876d23d22d424cbeace
+SHA512:
+  metadata.gz: d448483ee949db61aafe63bfa1a81ca0eba4ebf3310303d06642a48bb806736219d39e16a739cba2ebdd080270e93307c46a07ee5caa1e390ba11f7e3ca7f66f
+  data.tar.gz: c2bc48a670e248fa68b8bb149d73bac42e060212019f8ae7cbc0c14555040b9616e3673ca809bfa97f8038a10e02c94a49d1211a6300c323d83bc3742c8b1a68

data/.travis.yml

@@ -16,11 +16,14 @@ gemfile:
   - .travis/Gemfile
 
 env:
-  - conn=ruby      REDIS_BRANCH=2.6
-  - conn=hiredis   REDIS_BRANCH=2.6
-  - conn=synchrony REDIS_BRANCH=2.6
-  - conn=ruby      REDIS_BRANCH=2.8
-  - conn=ruby      REDIS_BRANCH=unstable
+  global:
+    - TIMEOUT=1
+  matrix:
+    - conn=ruby      REDIS_BRANCH=2.6
+    - conn=hiredis   REDIS_BRANCH=2.6
+    - conn=synchrony REDIS_BRANCH=2.6
+    - conn=ruby      REDIS_BRANCH=2.8
+    - conn=ruby      REDIS_BRANCH=unstable
 
 matrix:
   exclude:

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# (unreleased)
+
+...
+
+# 3.0.7
+
+* Added method `Redis#dup` to duplicate a Redis connection.
+
+* IPv6 support.
+
 # 3.0.6
 
 * Added support for `SCAN` and variants.

data/README.md

@@ -38,15 +38,31 @@ listening on `localhost`, port 6379. If you need to connect to a remote
 server or a different port, try:
 
 ```ruby
-redis = Redis.new(:host => "10.0.1.1", :port => 6380)
+redis = Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15)
 ```
 
+You can also specify connection options as an URL:
+
+```ruby
+redis = Redis.new(:url => "redis://:p4ssw0rd@10.0.1.1:6380/15")
+```
+
+By default, the client will try to read the `REDIS_URL` environment variable
+and use that as URL to connect to. The above statement is therefore equivalent
+to setting this environment variable and calling `Redis.new` without arguments.
+
 To connect to Redis listening on a Unix socket, try:
 
 ```ruby
 redis = Redis.new(:path => "/tmp/redis.sock")
 ```
 
+To connect to a password protected Redis instance, use:
+
+```ruby
+redis = Redis.new(:password => "mysecret")
+```
+
 The Redis class exports methods that are named identical to the commands
 they execute. The arguments these methods accept are often identical to
 the arguments specified on the [Redis website][redis-commands]. For

data/lib/redis.rb

@@ -27,6 +27,7 @@ class Redis
   include MonitorMixin
 
   def initialize(options = {})
+    @options = options.dup
     @original_client = @client = Client.new(options)
 
     super() # Monitor#initialize
@@ -128,7 +129,7 @@ class Redis
 
   # Get or set server configuration parameters.
   #
-  # @param [String] action e.g. `get`, `set`, `resetstat`
+  # @param [Symbol] action e.g. `:get`, `:set`, `:resetstat`
   # @return [String, Hash] string reply, or hash when retrieving more than one
   #   property with `CONFIG GET`
   def config(action, *args)
@@ -2422,6 +2423,10 @@ class Redis
     "#<Redis client v#{Redis::VERSION} for #{id}>"
   end
 
+  def dup
+    self.class.new(@options)
+  end
+
   def method_missing(command, *args)
     synchronize do |client|
       client.call([command] + args)

data/lib/redis/client.rb

@@ -19,6 +19,10 @@ class Redis
       :tcp_keepalive => 0
     }
 
+    def options
+      Marshal.load(Marshal.dump(@options))
+    end
+
     def scheme
       @options[:scheme]
     end
@@ -51,6 +55,10 @@ class Redis
       @options[:db] = db.to_i
     end
 
+    def driver
+      @options[:driver]
+    end
+
     attr_accessor :logger
     attr_reader :connection
     attr_reader :command_map
@@ -66,9 +74,13 @@ class Redis
     def connect
       @pid = Process.pid
 
-      establish_connection
-      call [:auth, password] if password
-      call [:select, db] if db != 0
+      # Don't try to reconnect when the connection is fresh
+      with_reconnect(false) do
+        establish_connection
+        call [:auth, password] if password
+        call [:select, db] if db != 0
+      end
+
       self
     end
 

data/lib/redis/connection/ruby.rb

@@ -114,11 +114,9 @@ class Redis
 
         include SocketMixin
 
-        def self.connect(host, port, timeout)
-          # Limit lookup to IPv4, as Redis doesn't yet do IPv6...
-          addr = ::Socket.getaddrinfo(host, nil, Socket::AF_INET)
-          sock = new(::Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-          sockaddr = ::Socket.pack_sockaddr_in(port, addr[0][3])
+        def self.connect_addrinfo(ai, port, timeout)
+          sock = new(::Socket.const_get(ai[0]), Socket::SOCK_STREAM, 0)
+          sockaddr = ::Socket.pack_sockaddr_in(port, ai[3])
 
           begin
             sock.connect_nonblock(sockaddr)
@@ -135,6 +133,39 @@ class Redis
 
           sock
         end
+
+        def self.connect(host, port, timeout)
+          # Don't pass AI_ADDRCONFIG as flag to getaddrinfo(3)
+          #
+          # From the man page for getaddrinfo(3):
+          #
+          #   If hints.ai_flags includes the AI_ADDRCONFIG flag, then IPv4
+          #   addresses are returned in the list pointed to by res only if the
+          #   local system has at least one IPv4 address configured, and IPv6
+          #   addresses are returned only if the local system has at least one
+          #   IPv6 address configured. The loopback address is not considered
+          #   for this case as valid as a configured address.
+          #
+          # We do want the IPv6 loopback address to be returned if applicable,
+          # even if it is the only configured IPv6 address on the machine.
+          # Also see: https://github.com/redis/redis-rb/pull/394.
+          addrinfo = ::Socket.getaddrinfo(host, nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM)
+
+          # From the man page for getaddrinfo(3):
+          #
+          #   Normally, the application should try using the addresses in the
+          #   order in which they are returned. The sorting function used
+          #   within getaddrinfo() is defined in RFC 3484 [...].
+          #
+          addrinfo.each_with_index do |ai, i|
+            begin
+              return connect_addrinfo(ai, port, timeout)
+            rescue SystemCallError
+              # Raise if this was our last attempt.
+              raise if addrinfo.length == i+1
+            end
+          end
+        end
       end
 
       class UNIXSocket < ::Socket

data/lib/redis/distributed.rb

@@ -16,9 +16,10 @@ class Redis
     attr_reader :ring
 
     def initialize(node_configs, options = {})
-      @tag = options.delete(:tag) || /^\{(.+?)\}/
-      @ring = options.delete(:ring) || HashRing.new
-      @default_options = options
+      @tag = options[:tag] || /^\{(.+?)\}/
+      @ring = options[:ring] || HashRing.new
+      @node_configs = node_configs.dup
+      @default_options = options.dup
       node_configs.each { |node_config| add_node(node_config) }
       @subscribed_node = nil
     end
@@ -807,6 +808,10 @@ class Redis
       "#<Redis client v#{Redis::VERSION} for #{nodes.map(&:id).join(', ')}>"
     end
 
+    def dup
+      self.class.new(@node_configs, @default_options)
+    end
+
   protected
 
     def on_each_node(command, *args)

data/lib/redis/pipeline.rb

@@ -78,7 +78,7 @@ class Redis
         # EXEC command failed.
         raise exec if exec.is_a?(CommandError)
 
-        if exec.size < futures.size - 2
+        if exec.size < futures.size
           # Some command wasn't recognized by Redis.
           raise replies.detect { |r| r.is_a?(CommandError) }
         end

data/lib/redis/subscribe.rb

@@ -39,7 +39,8 @@ class Redis
           break if unsubscribed
         end
       ensure
-        send(stop) if !unsubscribed
+        # No need to unsubscribe here. The real client closes the connection
+        # whenever an exception is raised (see #ensure_connected).
       end
     end
   end

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.0.6"
+  VERSION = "3.0.7"
 end

data/redis.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |s|
     client-side sharding, pipelining, and an obsession for performance.
   EOS
 
+  s.license = "MIT"
+
   s.authors = [
     "Ezra Zygmuntowicz",
     "Taylor Weibley",

data/test/commands_on_strings_test.rb

@@ -82,18 +82,20 @@ class TestCommandsOnStrings < Test::Unit::TestCase
   end
 
   def test_bitop
-    target_version "2.5.10" do
-      r.set("foo", "a")
-      r.set("bar", "b")
-
-      r.bitop(:and, "foo&bar", "foo", "bar")
-      assert_equal "\x60", r.get("foo&bar")
-      r.bitop(:or, "foo|bar", "foo", "bar")
-      assert_equal "\x63", r.get("foo|bar")
-      r.bitop(:xor, "foo^bar", "foo", "bar")
-      assert_equal "\x03", r.get("foo^bar")
-      r.bitop(:not, "~foo", "foo")
-      assert_equal "\x9E", r.get("~foo")
+    try_encoding("UTF-8") do
+      target_version "2.5.10" do
+        r.set("foo", "a")
+        r.set("bar", "b")
+
+        r.bitop(:and, "foo&bar", "foo", "bar")
+        assert_equal "\x60", r.get("foo&bar")
+        r.bitop(:or, "foo|bar", "foo", "bar")
+        assert_equal "\x63", r.get("foo|bar")
+        r.bitop(:xor, "foo^bar", "foo", "bar")
+        assert_equal "\x03", r.get("foo^bar")
+        r.bitop(:not, "~foo", "foo")
+        assert_equal "\x9E", r.get("~foo")
+      end
     end
   end
 end

data/test/commands_on_value_types_test.rb

@@ -99,7 +99,7 @@ class TestCommandsOnValueTypes < Test::Unit::TestCase
 
   def test_migrate
     redis_mock(:migrate => lambda { |*args| args }) do |redis|
-      options = { :host => "localhost", :port => 1234 }
+      options = { :host => "127.0.0.1", :port => 1234 }
 
       assert_raise(RuntimeError, /host not specified/) do
         redis.migrate("foo", options.reject { |key, _| key == :host })
@@ -114,17 +114,17 @@ class TestCommandsOnValueTypes < Test::Unit::TestCase
 
       # Test defaults
       actual = redis.migrate("foo", options)
-      expected = ["localhost", "1234", "foo", default_db.to_s, default_timeout.to_s]
+      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, default_timeout.to_s]
       assert_equal expected, actual
 
       # Test db override
       actual = redis.migrate("foo", options.merge(:db => default_db + 1))
-      expected = ["localhost", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
+      expected = ["127.0.0.1", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
       assert_equal expected, actual
 
       # Test timeout override
       actual = redis.migrate("foo", options.merge(:timeout => default_timeout + 1))
-      expected = ["localhost", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
+      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
       assert_equal expected, actual
     end
   end

data/test/connection_handling_test.rb

@@ -157,7 +157,7 @@ class TestConnectionHandling < Test::Unit::TestCase
 
   def test_slaveof
     redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis|
-      assert_equal "SLAVEOF localhost 6381", redis.slaveof("localhost", 6381)
+      assert_equal "SLAVEOF somehost 6381", redis.slaveof("somehost", 6381)
     end
   end
 

data/test/distributed_internals_test.rb

@@ -7,35 +7,64 @@ class TestDistributedInternals < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_provides_a_meaningful_inspect
-    nodes = ["redis://localhost:#{PORT}/15", *NODES]
+    nodes = ["redis://127.0.0.1:#{PORT}/15", *NODES]
     redis = Redis::Distributed.new nodes
 
     assert_equal "#<Redis client v#{Redis::VERSION} for #{redis.nodes.map(&:id).join(', ')}>", redis.inspect
   end
 
   def test_default_as_urls
-    nodes = ["redis://localhost:#{PORT}/15", *NODES]
+    nodes = ["redis://127.0.0.1:#{PORT}/15", *NODES]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://localhost:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id}
+    assert_equal ["redis://127.0.0.1:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id}
   end
 
   def test_default_as_config_hashes
-    nodes = [OPTIONS.merge(:host => 'localhost'), OPTIONS.merge(:host => 'localhost', :port => PORT.next)]
+    nodes = [OPTIONS.merge(:host => '127.0.0.1'), OPTIONS.merge(:host => 'somehost', :port => PORT.next)]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://localhost:#{PORT}/15","redis://localhost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
+    assert_equal ["redis://127.0.0.1:#{PORT}/15","redis://somehost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
   end
 
   def test_as_mix_and_match
-    nodes = ["redis://localhost:7389/15", OPTIONS.merge(:host => 'localhost'), OPTIONS.merge(:host => 'localhost', :port => PORT.next)]
+    nodes = ["redis://127.0.0.1:7389/15", OPTIONS.merge(:host => 'somehost'), OPTIONS.merge(:host => 'somehost', :port => PORT.next)]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://localhost:7389/15", "redis://localhost:#{PORT}/15", "redis://localhost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
+    assert_equal ["redis://127.0.0.1:7389/15", "redis://somehost:#{PORT}/15", "redis://somehost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
   end
 
   def test_override_id
-    nodes = [OPTIONS.merge(:host => 'localhost', :id => "test"), OPTIONS.merge( :host => 'localhost', :port => PORT.next, :id => "test1")]
+    nodes = [OPTIONS.merge(:host => '127.0.0.1', :id => "test"), OPTIONS.merge( :host => 'somehost', :port => PORT.next, :id => "test1")]
     redis = Redis::Distributed.new nodes
     assert_equal redis.nodes.first.client.id, "test"
     assert_equal redis.nodes.last.client.id,  "test1"
     assert_equal "#<Redis client v#{Redis::VERSION} for #{redis.nodes.map(&:id).join(', ')}>", redis.inspect
   end
+
+  def test_can_be_duped_to_create_a_new_connection
+    redis = Redis::Distributed.new(NODES)
+
+    clients = redis.info[0]["connected_clients"].to_i
+
+    r2 = redis.dup
+    r2.ping
+
+    assert_equal clients + 1, redis.info[0]["connected_clients"].to_i
+  end
+
+  def test_keeps_options_after_dup
+    r1 = Redis::Distributed.new(NODES, :tag => /^(\w+):/)
+
+    assert_raise(Redis::Distributed::CannotDistribute) do
+      r1.sinter("foo", "bar")
+    end
+
+    assert_equal [], r1.sinter("baz:foo", "baz:bar")
+
+    r2 = r1.dup
+
+    assert_raise(Redis::Distributed::CannotDistribute) do
+      r2.sinter("foo", "bar")
+    end
+
+    assert_equal [], r2.sinter("baz:foo", "baz:bar")
+  end
 end

data/test/distributed_key_tags_test.rb

@@ -8,9 +8,9 @@ class TestDistributedKeyTags < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_hashes_consistently
-    r1 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-    r2 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-    r3 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    r1 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    r2 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    r3 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
 
     assert_equal r1.node_for("foo").id, r2.node_for("foo").id
     assert_equal r1.node_for("foo").id, r3.node_for("foo").id
@@ -18,7 +18,7 @@ class TestDistributedKeyTags < Test::Unit::TestCase
 
   def test_allows_clustering_of_keys
     r = Redis::Distributed.new(NODES)
-    r.add_node("redis://localhost:#{PORT}/14")
+    r.add_node("redis://127.0.0.1:#{PORT}/14")
     r.flushdb
 
     100.times do |i|
@@ -29,7 +29,7 @@ class TestDistributedKeyTags < Test::Unit::TestCase
   end
 
   def test_distributes_keys_if_no_clustering_is_used
-    r.add_node("redis://localhost:#{PORT}/14")
+    r.add_node("redis://127.0.0.1:#{PORT}/14")
     r.flushdb
 
     r.set "users:1", 1
@@ -40,7 +40,7 @@ class TestDistributedKeyTags < Test::Unit::TestCase
 
   def test_allows_passing_a_custom_tag_extractor
     r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
-    r.add_node("redis://localhost:#{PORT}/14")
+    r.add_node("redis://127.0.0.1:#{PORT}/14")
     r.flushdb
 
     100.times do |i|

data/test/distributed_test.rb

@@ -7,7 +7,7 @@ class TestDistributed < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_handle_multiple_servers
-    @r = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    @r = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
 
     100.times do |idx|
       @r.set(idx.to_s, "foo#{idx}")
@@ -32,9 +32,9 @@ class TestDistributed < Test::Unit::TestCase
     assert_equal 10, @r.nodes[0].client.timeout
     assert_equal logger, @r.nodes[0].client.logger
 
-    @r.add_node("redis://localhost:6380/14")
+    @r.add_node("redis://127.0.0.1:6380/14")
 
-    assert_equal "localhost", @r.nodes[1].client.host
+    assert_equal "127.0.0.1", @r.nodes[1].client.host
     assert_equal 6380, @r.nodes[1].client.port
     assert_equal 14, @r.nodes[1].client.db
     assert_equal 10, @r.nodes[1].client.timeout

data/test/helper.rb

@@ -22,7 +22,7 @@ require "support/redis_mock"
 require "support/connection/#{ENV["conn"]}"
 
 PORT    = 6381
-OPTIONS = {:port => PORT, :db => 15, :timeout => 0.1}
+OPTIONS = {:port => PORT, :db => 15, :timeout => Float(ENV["TIMEOUT"] || 0.1)}
 NODES   = ["redis://127.0.0.1:#{PORT}/15"]
 
 def init(redis)
@@ -91,6 +91,14 @@ module Helper
     end
   end
 
+  def try_encoding(encoding, &block)
+    if defined?(Encoding)
+      with_external_encoding(encoding, &block)
+    else
+      yield
+    end
+  end
+
   class Version
 
     include Comparable
@@ -133,6 +141,9 @@ module Helper
     def setup
       @log = StringIO.new
       @redis = init _new_client
+
+      # Run GC to make sure orphaned connections are closed.
+      GC.start
     end
 
     def teardown
@@ -140,13 +151,13 @@ module Helper
     end
 
     def redis_mock(commands, options = {}, &blk)
-      RedisMock.start(commands) do |port|
+      RedisMock.start(commands, options) do |port|
         yield _new_client(options.merge(:port => port))
       end
     end
 
     def redis_mock_with_handler(handler, options = {}, &blk)
-      RedisMock.start_with_handler(handler) do |port|
+      RedisMock.start_with_handler(handler, options) do |port|
         yield _new_client(options.merge(:port => port))
       end
     end

data/test/internals_test.rb

@@ -320,4 +320,91 @@ class TestInternals < Test::Unit::TestCase
       serv.close if serv
     end
   end
+
+  def test_client_options
+    redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo"))
+
+    assert_equal "host", redis.client.options[:host]
+    assert_equal 1234, redis.client.options[:port]
+    assert_equal 1, redis.client.options[:db]
+    assert_equal "foo", redis.client.options[:scheme]
+  end
+
+  def test_does_not_change_self_client_options
+    redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo"))
+    options = redis.client.options
+
+    options[:host] << "new_host"
+    options[:scheme] << "bar"
+    options.merge!(:db => 0)
+
+    assert_equal "host", redis.client.options[:host]
+    assert_equal 1, redis.client.options[:db]
+    assert_equal "foo", redis.client.options[:scheme]
+  end
+
+  def test_resolves_localhost
+    assert_nothing_raised do
+      Redis.new(OPTIONS.merge(:host => 'localhost')).ping
+    end
+  end
+
+  class << self
+    def af_family_supported(af)
+      hosts = {
+        Socket::AF_INET  => "127.0.0.1",
+        Socket::AF_INET6 => "::1",
+      }
+
+      begin
+        s = Socket.new(af, Socket::SOCK_STREAM, 0)
+        begin
+          sa = Socket.pack_sockaddr_in(9999, hosts[af])
+          s.bind(sa)
+          yield
+        rescue Errno::EADDRNOTAVAIL
+        ensure
+          s.close
+        end
+      rescue Errno::ESOCKTNOSUPPORT
+      end
+    end
+  end
+
+  def af_test(host)
+    commands = {
+      :ping => lambda { |*_| "+pong" },
+    }
+
+    redis_mock(commands, :host => host) do |redis|
+      assert_nothing_raised do
+        redis.ping
+      end
+    end
+  end
+
+  driver(:ruby) do
+    af_family_supported(Socket::AF_INET) do
+      def test_connect_ipv4
+        af_test("127.0.0.1")
+      end
+    end
+  end
+
+  driver(:ruby) do
+    af_family_supported(Socket::AF_INET6) do
+      def test_connect_ipv6
+        af_test("::1")
+      end
+    end
+  end
+
+  def test_can_be_duped_to_create_a_new_connection
+    clients = r.info["connected_clients"].to_i
+
+    r2 = r.dup
+    r2.ping
+
+    assert_equal clients + 1, r.info["connected_clients"].to_i
+  end
 end

data/test/pipelining_commands_test.rb

@@ -93,9 +93,7 @@ class TestPipeliningCommands < Test::Unit::TestCase
       r.pipelined do
         r.doesnt_exist
         @first = r.sadd("foo", 1)
-        r.doesnt_exist
         @second = r.sadd("foo", 1)
-        r.doesnt_exist
       end
     end
 

data/test/publish_subscribe_test.rb

@@ -6,6 +6,9 @@ class TestPublishSubscribe < Test::Unit::TestCase
 
   include Helper::Client
 
+  class TestError < StandardError
+  end
+
   def test_subscribe_and_unsubscribe
     @subscribed = false
     @unsubscribed = false
@@ -84,6 +87,62 @@ class TestPublishSubscribe < Test::Unit::TestCase
     assert_equal "s1", @message
   end
 
+  def test_subscribe_connection_usable_after_raise
+    @subscribed = false
+
+    wire = Wire.new do
+      begin
+        r.subscribe("foo") do |on|
+          on.subscribe do |channel, total|
+            @subscribed = true
+          end
+
+          on.message do |channel, message|
+            raise TestError
+          end
+        end
+      rescue TestError
+      end
+    end
+
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
+
+    Redis.new(OPTIONS).publish("foo", "s1")
+
+    wire.join
+
+    assert_equal "PONG", r.ping
+  end
+
+  def test_psubscribe_connection_usable_after_raise
+    @subscribed = false
+
+    wire = Wire.new do
+      begin
+        r.psubscribe("f*") do |on|
+          on.psubscribe do |pattern, total|
+            @subscribed = true
+          end
+
+          on.pmessage do |pattern, channel, message|
+            raise TestError
+          end
+        end
+      rescue TestError
+      end
+    end
+
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
+
+    Redis.new(OPTIONS).publish("foo", "s1")
+
+    wire.join
+
+    assert_equal "PONG", r.ping
+  end
+
   def test_subscribe_within_subscribe
     @channels = []
 
@@ -132,7 +191,7 @@ class TestPublishSubscribe < Test::Unit::TestCase
   def test_subscribe_past_a_timeout
     # For some reason, a thread here doesn't reproduce the issue.
     sleep = %{sleep #{OPTIONS[:timeout] * 2}}
-    publish = %{echo "publish foo bar\r\n" | nc localhost #{OPTIONS[:port]}}
+    publish = %{echo "publish foo bar\r\n" | nc 127.0.0.1 #{OPTIONS[:port]}}
     cmd = [sleep, publish].join("; ")
 
     IO.popen(cmd, "r+") do |pipe|

data/test/support/redis_mock.rb

@@ -4,8 +4,8 @@ module RedisMock
   class Server
     VERBOSE = false
 
-    def initialize(port, &block)
-      @server = TCPServer.new("127.0.0.1", port)
+    def initialize(port, options = {}, &block)
+      @server = TCPServer.new(options[:host] || "127.0.0.1", port)
       @server.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
     end
 
@@ -53,8 +53,8 @@ module RedisMock
   #     # Every connection will be closed immediately
   #   end
   #
-  def self.start_with_handler(blk)
-    server = Server.new(MOCK_PORT)
+  def self.start_with_handler(blk, options = {})
+    server = Server.new(MOCK_PORT, options)
 
     begin
       server.start(&blk)
@@ -75,7 +75,7 @@ module RedisMock
   #     assert_equal "PONG", Redis.new(:port => MOCK_PORT).ping
   #   end
   #
-  def self.start(commands = {}, &blk)
+  def self.start(commands, options = {}, &blk)
     handler = lambda do |session|
       while line = session.gets
         argv = Array.new(line[1..-3].to_i) do
@@ -110,6 +110,6 @@ module RedisMock
       end
     end
 
-    start_with_handler(handler, &blk)
+    start_with_handler(handler, options, &blk)
   end
 end

data/test/transactions_test.rb

@@ -67,9 +67,7 @@ class TestTransactions < Test::Unit::TestCase
       r.multi do |m|
         m.doesnt_exist
         @first = m.sadd("foo", 1)
-        m.doesnt_exist
         @second = m.sadd("foo", 1)
-        m.doesnt_exist
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.0.7
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,25 +16,26 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-07 00:00:00.000000000 Z
+date: 2014-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "    A Ruby client that tries to match Redis' API one-to-one, while
-  still\n    providing an idiomatic interface. It features thread-safety,\n    client-side
-  sharding, pipelining, and an obsession for performance.\n"
+description: |2
+      A Ruby client that tries to match Redis' API one-to-one, while still
+      providing an idiomatic interface. It features thread-safety,
+      client-side sharding, pipelining, and an obsession for performance.
 email:
 - redis-db@googlegroups.com
 executables: []
@@ -138,7 +139,8 @@ files:
 - test/unknown_commands_test.rb
 - test/url_param_test.rb
 homepage: https://github.com/redis/redis-rb
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -146,77 +148,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: A Ruby client library for Redis
-test_files:
-- test/blocking_commands_test.rb
-- test/command_map_test.rb
-- test/commands_on_hashes_test.rb
-- test/commands_on_lists_test.rb
-- test/commands_on_sets_test.rb
-- test/commands_on_sorted_sets_test.rb
-- test/commands_on_strings_test.rb
-- test/commands_on_value_types_test.rb
-- test/connection_handling_test.rb
-- test/db/.gitkeep
-- test/distributed_blocking_commands_test.rb
-- test/distributed_commands_on_hashes_test.rb
-- test/distributed_commands_on_lists_test.rb
-- test/distributed_commands_on_sets_test.rb
-- test/distributed_commands_on_sorted_sets_test.rb
-- test/distributed_commands_on_strings_test.rb
-- test/distributed_commands_on_value_types_test.rb
-- test/distributed_commands_requiring_clustering_test.rb
-- test/distributed_connection_handling_test.rb
-- test/distributed_internals_test.rb
-- test/distributed_key_tags_test.rb
-- test/distributed_persistence_control_commands_test.rb
-- test/distributed_publish_subscribe_test.rb
-- test/distributed_remote_server_control_commands_test.rb
-- test/distributed_scripting_test.rb
-- test/distributed_sorting_test.rb
-- test/distributed_test.rb
-- test/distributed_transactions_test.rb
-- test/encoding_test.rb
-- test/error_replies_test.rb
-- test/helper.rb
-- test/helper_test.rb
-- test/internals_test.rb
-- test/lint/blocking_commands.rb
-- test/lint/hashes.rb
-- test/lint/lists.rb
-- test/lint/sets.rb
-- test/lint/sorted_sets.rb
-- test/lint/strings.rb
-- test/lint/value_types.rb
-- test/persistence_control_commands_test.rb
-- test/pipelining_commands_test.rb
-- test/publish_subscribe_test.rb
-- test/remote_server_control_commands_test.rb
-- test/scanning_test.rb
-- test/scripting_test.rb
-- test/sorting_test.rb
-- test/support/connection/hiredis.rb
-- test/support/connection/ruby.rb
-- test/support/connection/synchrony.rb
-- test/support/redis_mock.rb
-- test/support/wire/synchrony.rb
-- test/support/wire/thread.rb
-- test/synchrony_driver.rb
-- test/test.conf
-- test/thread_safety_test.rb
-- test/transactions_test.rb
-- test/unknown_commands_test.rb
-- test/url_param_test.rb
+test_files: []