redis 3.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e25c90cb532eea0215afe63b0156fa102446c5f2
-  data.tar.gz: b2acddebb3e293807a9b6bb6a6f986432859afb0
+  metadata.gz: 1245d9a408be7cfa9f796b5b02e6f2dcaff10f2a
+  data.tar.gz: 2dce33db07a7a16dcade71b081996f241d2075ab
 SHA512:
-  metadata.gz: f599db91c12cf1a0e6a86c114e6ea687f9027d1a58e982f4f68bded6e38409cf4aab46fb742ec2d9fd80e85214a41a7f341399348645bb8765099c8f059b3efe
-  data.tar.gz: 12fb14500e54c7eeb46a79a9b112eb5b85a457c50ae388f505db18b9a2ab826d3c206bd4d5bc778b487a94f7af48d8b5df79f1f01396087c2b856ea2e0b589d8
+  metadata.gz: ef3734d43bbd4fb5f50fbef3d9b3348d382c9389433a8af91e9d94410b818b3eaa8d306b827e91aafaa26fa28aa461f9c028293280c6df48bf5d28412554140a
+  data.tar.gz: cc7122626f5587a8a750746acfb59d7462fb426cd68234ee141805e77b5bbfb39736543f71fc26575ef5bd1bd6dce3b7eb2b8857408461cf4f9ac2e4f2d05c78

data/.gitignore

@@ -13,3 +13,4 @@ Gemfile.lock
 /rdsrv
 /redis/*
 /test/db
+/test/test.conf

data/CHANGELOG.md

@@ -12,13 +12,31 @@
   security updates in June of 2013; continuing to support it would prevent
   the use of newer features of Ruby.
 
-# 3.2.0
+# 3.2.1
 
-* Redis Sentinel support.
+* Added support for `PUBSUB` command.
+
+* More low-level socket errors are now raised as `CannotConnectError`.
+
+* Added `:connect_timeout` option.
+
+* Added support for `:limit` option for `ZREVRANGEBYLEX`.
+
+* Fixed an issue where connections become inconsistent when using Ruby's
+  Timeout module outside of the client (see #501, #502).
 
-# 3.1.1 (unreleased)
+* Added `Redis#disconnect!` as a public-API way of disconnecting the client
+  (without needing to use `QUIT`). See #506.
 
-* Added support for variadic `PFCOUNT`.
+* Fixed Sentinel support with Hiredis.
+
+* Fixed Sentinel support when using authentication and databases.
+
+* Improved resilience when trying to contact sentinels.
+
+# 3.2.0
+
+* Redis Sentinel support.
 
 # 3.1.0
 

data/README.md

@@ -3,8 +3,8 @@
 [travis-image]: https://secure.travis-ci.org/redis/redis-rb.png?branch=master
 [travis-link]: http://travis-ci.org/redis/redis-rb
 [travis-home]: http://travis-ci.org/
-[inchpages-image]: http://inch-pages.github.io/github/redis/redis-rb.png
-[inchpages-link]: http://inch-pages.github.io/github/redis/redis-rb
+[inchpages-image]: http://inch-ci.org/github/redis/redis-rb.png
+[inchpages-link]: http://inch-ci.org/github/redis/redis-rb
 
 A Ruby client library for [Redis][redis-home].
 
@@ -105,7 +105,8 @@ and one or more slaves (`mymaster` in the example).
 
 * It is possible to optionally provide a role. The allowed roles are `master`
 and `slave`. When the role is `slave`, the client will try to connect to a
-random slave of the specified master.
+random slave of the specified master. If a role is not specified, the client
+will connect to the master.
 
 * When using the Sentinel support you need to specify a list of sentinels to
 connect to. The list does not need to enumerate all your Sentinel instances,
@@ -170,7 +171,7 @@ end
 Replies to commands in a pipeline can be accessed via the *futures* they
 emit (since redis-rb 3.0). All calls inside a pipeline block return a
 `Future` object, which responds to the `#value` method. When the
-pipeline has succesfully executed, all futures are assigned their
+pipeline has successfully executed, all futures are assigned their
 respective replies and can be used.
 
 ```ruby
@@ -186,6 +187,26 @@ end
 # => 1
 ```
 
+## Error Handling
+
+In general, if something goes wrong you'll get an exception. For example, if
+it can't connect to the server a `Redis::CannotConnectError` error will be raised.
+
+```ruby
+begin
+  redis.ping
+rescue Exception => e
+  e.inspect
+# => #<Redis::CannotConnectError: Timed out connecting to Redis on 10.0.1.1:6380>
+
+  e.message
+# => Timed out connecting to Redis on 10.0.1.1:6380
+end
+```
+
+See lib/redis/errors.rb for information about what exceptions are possible.
+
+
 ## Expert-Mode Options
 
  - `inherit_socket: true`: disable safety check that prevents a forked child

data/Rakefile

@@ -4,7 +4,10 @@ ENV["REDIS_BRANCH"] ||= "unstable"
 
 REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__)
 REDIS_CNF = File.join(REDIS_DIR, "test.conf")
+REDIS_CNF_TEMPLATE = File.join(REDIS_DIR, "test.conf.erb")
 REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")
+REDIS_LOG = File.join(REDIS_DIR, "db", "redis.log")
+REDIS_SOCKET = File.join(REDIS_DIR, "db", "redis.sock")
 BINARY = "tmp/redis-#{ENV["REDIS_BRANCH"]}/src/redis-server"
 
 task :default => :run
@@ -13,7 +16,7 @@ desc "Run tests and manage server start/stop"
 task :run => [:start, :test, :stop]
 
 desc "Start the Redis server"
-task :start => BINARY do
+task :start => [BINARY, REDIS_CNF] do
   sh "#{BINARY} --version"
 
   redis_running = \
@@ -46,6 +49,7 @@ end
 desc "Clean up testing artifacts"
 task :clean do
   FileUtils.rm_f(BINARY)
+  FileUtils.rm_f(REDIS_CNF)
 end
 
 file BINARY do
@@ -62,6 +66,21 @@ file BINARY do
   SH
 end
 
+file REDIS_CNF => [REDIS_CNF_TEMPLATE, __FILE__] do |t|
+  require 'erb'
+
+  erb = t.prerequisites[0]
+  template = File.read(erb)
+
+  File.open(REDIS_CNF, 'w') do |file|
+    file.puts "\# This file was auto-generated at #{Time.now}",
+              "\# from (#{erb})",
+              "\#"
+    conf = ERB.new(template).result
+    file << conf
+  end
+end
+
 Rake::TestTask.new do |t|
   t.options = "-v" if $VERBOSE
   t.test_files = FileList["test/*_test.rb"]

data/lib/redis.rb

@@ -54,6 +54,11 @@ class Redis
     @original_client.connected?
   end
 
+  # Disconnect the client as quickly and silently as possible.
+  def disconnect!
+    @original_client.disconnect
+  end
+
   # Authenticate to the server.
   #
   # @param [String] password must match the password specified in the
@@ -764,7 +769,7 @@ class Redis
   # Set one or more values, only if none of the keys exist.
   #
   # @example
-  #   redis.msetnx({ "key1" => "v1", "key2" => "v2" })
+  #   redis.mapped_msetnx({ "key1" => "v1", "key2" => "v2" })
   #     # => true
   #
   # @param [Hash] hash keys mapping to values
@@ -1620,6 +1625,28 @@ class Redis
     end
   end
 
+  # Return a range of members with the same score in a sorted set, by reversed lexicographical ordering.
+  # Apart from the reversed ordering, #zrevrangebylex is similar to #zrangebylex.
+  #
+  # @example Retrieve members matching a
+  #   redis.zrevrangebylex("zset", "[a", "[a\xff")
+  #     # => ["abbygail", "abby", "abagael", "aaren"]
+  # @example Retrieve the last 2 members matching a
+  #   redis.zrevrangebylex("zset", "[a", "[a\xff", :limit => [0, 2])
+  #     # => ["abbygail", "abby"]
+  #
+  # @see #zrangebylex
+  def zrevrangebylex(key, max, min, options = {})
+    args = []
+
+    limit = options[:limit]
+    args.concat(["LIMIT"] + limit) if limit
+
+    synchronize do |client|
+      client.call([:zrevrangebylex, key, max, min] + args)
+    end
+  end
+
   # Return a range of members in a sorted set, by score.
   #
   # @example Retrieve members with score `>= 5` and `< 100`
@@ -1856,7 +1883,7 @@ class Redis
   #     # => "OK"
   #
   # @param [String] key
-  # @param [Hash] hash fields mapping to values
+  # @param [Hash] a non-empty hash with fields mapping to values
   # @return `"OK"`
   #
   # @see #hmset
@@ -1895,7 +1922,7 @@ class Redis
   # Get the values of all the given hash fields.
   #
   # @example
-  #   redis.hmget("hash", "f1", "f2")
+  #   redis.mapped_hmget("hash", "f1", "f2")
   #     # => { "f1" => "v1", "f2" => "v2" }
   #
   # @param [String] key
@@ -2032,6 +2059,14 @@ class Redis
     end
   end
 
+  # Inspect the state of the Pub/Sub subsystem.
+  # Possible subcommands: channels, numsub, numpat.
+  def pubsub(subcommand, *args)
+    synchronize do |client|
+      client.call([:pubsub, subcommand] + args)
+    end
+  end
+
   # Watch the given keys to determine execution of the MULTI/EXEC block.
   #
   # Using a block is optional, but is necessary for thread-safety.
@@ -2450,7 +2485,7 @@ class Redis
   # Scan a set
   #
   # @example Retrieve all of the keys in a set
-  #   redis.sscan("set").to_a
+  #   redis.sscan_each("set").to_a
   #   # => ["key1", "key2", "key3"]
   #
   # @param [Hash] options

data/lib/redis/client.rb

@@ -12,6 +12,7 @@ class Redis
       :port => 6379,
       :path => nil,
       :timeout => 5.0,
+      :connect_timeout => 5.0,
       :password => nil,
       :db => 0,
       :driver => nil,
@@ -76,6 +77,8 @@ class Redis
       @connection = nil
       @command_map = {}
 
+      @pending_reads = 0
+
       if options.include?(:sentinels)
         @connector = Connector::Sentinel.new(@options)
       else
@@ -242,12 +245,15 @@ class Redis
 
     def read
       io do
-        connection.read
+        value = connection.read
+        @pending_reads -= 1
+        value
       end
     end
 
     def write(command)
       io do
+        @pending_reads += 1
         connection.write(command)
       end
     end
@@ -311,16 +317,23 @@ class Redis
       server = @connector.resolve.dup
 
       @options[:host] = server[:host]
-      @options[:port] = server[:port]
+      @options[:port] = Integer(server[:port]) if server.include?(:port)
+
+      @connection = @options[:driver].connect(@options)
+      @pending_reads = 0
+    rescue TimeoutError,
+           Errno::ECONNREFUSED,
+           Errno::EHOSTDOWN,
+           Errno::EHOSTUNREACH,
+           Errno::ENETUNREACH,
+           Errno::ETIMEDOUT
 
-      @connection = @options[:driver].connect(server)
-    rescue TimeoutError
-      raise CannotConnectError, "Timed out connecting to Redis on #{location}"
-    rescue Errno::ECONNREFUSED
-      raise CannotConnectError, "Error connecting to Redis on #{location} (ECONNREFUSED)"
+      raise CannotConnectError, "Error connecting to Redis on #{location} (#{$!.class})"
     end
 
     def ensure_connected
+      disconnect if @pending_reads > 0
+
       attempts = 0
 
       begin
@@ -338,7 +351,7 @@ class Redis
         end
 
         yield
-      rescue ConnectionError, InheritedError
+      rescue BaseConnectionError
         disconnect
 
         if attempts <= @options[:reconnect_attempts] && @reconnect
@@ -353,6 +366,8 @@ class Redis
     end
 
     def _parse_options(options)
+      return options if options[:_parsed]
+
       defaults = DEFAULTS.dup
       options = options.dup
 
@@ -378,7 +393,7 @@ class Redis
           defaults[:path]   = uri.path
         elsif uri.scheme == "redis"
           # Require the URL to have at least a host
-          raise ArgumentError, "invalid url" unless uri.host
+          raise ArgumentError, "invalid url: #{uri}" unless uri.host
 
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host
@@ -408,6 +423,12 @@ class Redis
       end
 
       options[:timeout] = options[:timeout].to_f
+      options[:connect_timeout] = if options[:connect_timeout]
+        options[:connect_timeout].to_f
+      else
+        options[:timeout]
+      end
+
       options[:db] = options[:db].to_i
       options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
 
@@ -431,6 +452,8 @@ class Redis
         end
       end
 
+      options[:_parsed] = true
+
       options
     end
 
@@ -451,7 +474,7 @@ class Redis
 
     class Connector
       def initialize(options)
-        @options = options
+        @options = options.dup
       end
 
       def resolve
@@ -465,9 +488,12 @@ class Redis
         def initialize(options)
           super(options)
 
-          @sentinels = options.fetch(:sentinels).dup
-          @role = options[:role].to_s
-          @master = options[:host]
+          @options[:password] = DEFAULTS.fetch(:password)
+          @options[:db] = DEFAULTS.fetch(:db)
+
+          @sentinels = @options.delete(:sentinels).dup
+          @role = @options.fetch(:role, "master").to_s
+          @master = @options[:host]
         end
 
         def check(client)
@@ -482,7 +508,7 @@ class Redis
           end
 
           if role != @role
-            disconnect
+            client.disconnect
             raise ConnectionError, "Instance role mismatch. Expected #{@role}, got #{role}."
           end
         end
@@ -502,7 +528,11 @@ class Redis
 
         def sentinel_detect
           @sentinels.each do |sentinel|
-            client = Client.new(:host => sentinel[:host], :port => sentinel[:port], :timeout => 0.3)
+            client = Client.new(@options.merge({
+              :host => sentinel[:host],
+              :port => sentinel[:port],
+              :reconnect_attempts => 0,
+            }))
 
             begin
               if result = yield(client)
@@ -512,12 +542,13 @@ class Redis
 
                 return result
               end
+            rescue BaseConnectionError
             ensure
               client.disconnect
             end
           end
 
-          return nil
+          raise CannotConnectError, "No sentinels available."
         end
 
         def resolve_master

data/lib/redis/connection/hiredis.rb

@@ -9,11 +9,12 @@ class Redis
 
       def self.connect(config)
         connection = ::Hiredis::Connection.new
+        connect_timeout = (config.fetch(:connect_timeout, 0) * 1_000_000).to_i
 
         if config[:scheme] == "unix"
-          connection.connect_unix(config[:path], Integer(config[:timeout] * 1_000_000))
+          connection.connect_unix(config[:path], connect_timeout)
         else
-          connection.connect(config[:host], config[:port], Integer(config[:timeout] * 1_000_000))
+          connection.connect(config[:host], config[:port], connect_timeout)
         end
 
         instance = new(connection)

data/lib/redis/connection/ruby.rb

@@ -206,9 +206,9 @@ class Redis
 
       def self.connect(config)
         if config[:scheme] == "unix"
-          sock = UNIXSocket.connect(config[:path], config[:timeout])
+          sock = UNIXSocket.connect(config[:path], config[:connect_timeout])
         else
-          sock = TCPSocket.connect(config[:host], config[:port], config[:timeout])
+          sock = TCPSocket.connect(config[:host], config[:port], config[:connect_timeout])
         end
 
         instance = new(sock)

data/lib/redis/connection/synchrony.rb

@@ -70,7 +70,7 @@ class Redis
           conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
         else
           conn = EventMachine.connect(config[:host], config[:port], RedisClient) do |c|
-            c.pending_connect_timeout = [config[:timeout], 0.1].max
+            c.pending_connect_timeout = [config[:connect_timeout], 0.1].max
           end
         end
 

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.2.0"
+  VERSION = "3.2.1"
 end

data/test/commands_on_sorted_sets_test.rb

@@ -22,6 +22,20 @@ class TestCommandsOnSortedSets < Test::Unit::TestCase
     end
   end
 
+  def test_zrevrangebylex
+    target_version "2.9.9" do
+      r.zadd "foo", 0, "aaren"
+      r.zadd "foo", 0, "abagael"
+      r.zadd "foo", 0, "abby"
+      r.zadd "foo", 0, "abbygail"
+
+      assert_equal ["abbygail", "abby", "abagael", "aaren"], r.zrevrangebylex("foo", "[a\xff", "[a")
+      assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "[a\xff", "[a", :limit => [0, 2])
+      assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "(abb\xff", "(abb")
+      assert_equal ["abbygail"], r.zrevrangebylex("foo", "(abby\xff", "(abby")
+    end
+  end
+
   def test_zcount
     r.zadd "foo", 1, "s1"
     r.zadd "foo", 2, "s2"

data/test/commands_on_value_types_test.rb

@@ -101,13 +101,15 @@ class TestCommandsOnValueTypes < Test::Unit::TestCase
     redis_mock(:migrate => lambda { |*args| args }) do |redis|
       options = { :host => "127.0.0.1", :port => 1234 }
 
-      assert_raise(RuntimeError, /host not specified/) do
+      ex = assert_raise(RuntimeError) do
         redis.migrate("foo", options.reject { |key, _| key == :host })
       end
+      assert ex.message =~ /host not specified/
 
-      assert_raise(RuntimeError, /port not specified/) do
+      ex = assert_raise(RuntimeError) do
         redis.migrate("foo", options.reject { |key, _| key == :port })
       end
+      assert ex.message =~ /port not specified/
 
       default_db = redis.client.db.to_i
       default_timeout = redis.client.timeout.to_i

data/test/connection_handling_test.rb

@@ -38,6 +38,33 @@ class TestConnectionHandling < Test::Unit::TestCase
     assert !r.client.connected?
   end
 
+  def test_disconnect
+    quit = 0
+
+    commands = {
+      :quit => lambda do
+        quit += 1
+        "+OK"
+      end
+    }
+
+    redis_mock(commands) do |redis|
+      assert_equal 0, quit
+
+      redis.quit
+
+      assert_equal 1, quit
+
+      redis.ping
+
+      redis.disconnect!
+
+      assert_equal 1, quit
+
+      assert !redis.connected?
+    end
+  end
+
   def test_shutdown
     commands = {
       :shutdown => lambda { :exit }
@@ -186,4 +213,25 @@ class TestConnectionHandling < Test::Unit::TestCase
       r.config :set, "timeout", 300
     end
   end
+
+  driver(:ruby, :hiredis) do
+    def test_consistency_on_multithreaded_env
+      t = nil
+
+      commands = {
+        :set => lambda { |key, value| t.kill; "+OK\r\n" },
+        :incr => lambda { |key| ":1\r\n" },
+      }
+
+      redis_mock(commands) do |redis|
+        t = Thread.new do
+          redis.set("foo", "bar")
+        end
+
+        t.join
+
+        assert_equal 1, redis.incr("baz")
+      end
+    end
+  end
 end

data/test/internals_test.rb

@@ -152,9 +152,12 @@ class TestInternals < Test::Unit::TestCase
   end
 
   def test_connection_timeout
+    opts = OPTIONS.merge(:host => "10.255.255.254", :connect_timeout => 0.1, :timeout => 5.0)
+    start_time = Time.now
     assert_raise Redis::CannotConnectError do
-      Redis.new(OPTIONS.merge(:host => "10.255.255.254", :timeout => 0.1)).ping
+      Redis.new(opts).ping
     end
+    assert (Time.now - start_time) <= opts[:timeout]
   end
 
   def close_on_ping(seq, options = {})

data/test/publish_subscribe_test.rb

@@ -87,6 +87,50 @@ class TestPublishSubscribe < Test::Unit::TestCase
     assert_equal "s1", @message
   end
 
+  def test_pubsub_with_numpat_subcommand
+    target_version("2.8.0") do
+      @subscribed = false
+      wire = Wire.new do
+        r.psubscribe("f*") do |on|
+          on.psubscribe { |channel, total| @subscribed = true }
+          on.pmessage   { |pattern, channel, message| r.punsubscribe }
+        end
+      end
+      Wire.pass while !@subscribed
+      redis = Redis.new(OPTIONS)
+      numpat_result = redis.pubsub(:numpat)
+
+      redis.publish("foo", "s1")
+      wire.join
+
+      assert_equal redis.pubsub(:numpat), 0
+      assert_equal numpat_result, 1
+    end
+  end
+
+
+  def test_pubsub_with_channels_and_numsub_subcommnads
+    target_version("2.8.0") do
+      @subscribed = false
+      wire = Wire.new do
+        r.subscribe("foo") do |on|
+          on.subscribe { |channel, total| @subscribed = true }
+          on.message   { |channel, message| r.unsubscribe }
+        end
+      end
+      Wire.pass while !@subscribed
+      redis = Redis.new(OPTIONS)
+      channels_result = redis.pubsub(:channels)
+      numsub_result   = redis.pubsub(:numsub, 'foo', 'boo')
+
+      redis.publish("foo", "s1")
+      wire.join
+
+      assert_equal channels_result, ['foo']
+      assert_equal numsub_result, ['foo', 1, 'boo', 0]
+    end
+  end
+
   def test_subscribe_connection_usable_after_raise
     @subscribed = false
 

data/test/remote_server_control_commands_test.rb

@@ -82,7 +82,7 @@ class TestRemoteServerControlCommands < Test::Unit::TestCase
       break line
     end
 
-    assert_equal result, "OK"
+    assert_equal "OK", result
   end
 
   def test_echo
@@ -98,8 +98,9 @@ class TestRemoteServerControlCommands < Test::Unit::TestCase
   def test_object
     r.lpush "list", "value"
 
-    assert_equal r.object(:refcount, "list"), 1
-    assert_equal r.object(:encoding, "list"), "ziplist"
+    assert_equal 1, r.object(:refcount, "list")
+    encoding = r.object(:encoding, "list")
+    assert "ziplist" == encoding || "quicklist" == encoding, "Wrong encoding for list"
     assert r.object(:idletime, "list").kind_of?(Fixnum)
   end
 
@@ -112,6 +113,6 @@ class TestRemoteServerControlCommands < Test::Unit::TestCase
   def test_slowlog
     r.slowlog(:reset)
     result = r.slowlog(:len)
-    assert_equal result, 0
+    assert_equal 0, result
   end
 end

data/test/sentinel_test.rb

@@ -0,0 +1,241 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class SentinalTest < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_sentinel_connection
+    sentinels = [{:host => "127.0.0.1", :port => 26381},
+                 {:host => "127.0.0.1", :port => 26382}]
+
+    commands = {
+      :s1 => [],
+      :s2 => [],
+    }
+
+    handler = lambda do |id|
+      {
+        :sentinel => lambda do |command, *args|
+          commands[id] << [command, *args]
+          ["127.0.0.1", "6381"]
+        end
+      }
+    end
+
+    RedisMock.start(handler.call(:s1), {}, 26381) do
+      RedisMock.start(handler.call(:s2), {}, 26382) do
+        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
+
+        assert redis.ping
+      end
+    end
+
+    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
+    assert_equal commands[:s2], []
+  end
+
+  def test_sentinel_failover
+    sentinels = [{:host => "127.0.0.1", :port => 26381},
+                 {:host => "127.0.0.1", :port => 26382}]
+
+    commands = {
+      :s1 => [],
+      :s2 => [],
+    }
+
+    s1 = {
+      :sentinel => lambda do |command, *args|
+        commands[:s1] << [command, *args]
+        "$-1" # Nil
+      end
+    }
+
+    s2 = {
+      :sentinel => lambda do |command, *args|
+        commands[:s2] << [command, *args]
+        ["127.0.0.1", "6381"]
+      end
+    }
+
+    RedisMock.start(s1, {}, 26381) do
+      RedisMock.start(s2, {}, 26382) do
+        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
+
+        assert redis.ping
+      end
+    end
+
+    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
+    assert_equal commands[:s2], [%w[get-master-addr-by-name master1]]
+  end
+
+  def test_sentinel_failover_prioritize_healthy_sentinel
+    sentinels = [{:host => "127.0.0.1", :port => 26381},
+                 {:host => "127.0.0.1", :port => 26382}]
+
+    commands = {
+      :s1 => [],
+      :s2 => [],
+    }
+
+    s1 = {
+      :sentinel => lambda do |command, *args|
+        commands[:s1] << [command, *args]
+        "$-1" # Nil
+      end
+    }
+
+    s2 = {
+      :sentinel => lambda do |command, *args|
+        commands[:s2] << [command, *args]
+        ["127.0.0.1", "6381"]
+      end
+    }
+
+    RedisMock.start(s1, {}, 26381) do
+      RedisMock.start(s2, {}, 26382) do
+        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
+
+        assert redis.ping
+
+        redis.quit
+
+        assert redis.ping
+      end
+    end
+
+    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
+    assert_equal commands[:s2], [%w[get-master-addr-by-name master1], %w[get-master-addr-by-name master1]]
+  end
+
+  def test_sentinel_with_non_sentinel_options
+    sentinels = [{:host => "127.0.0.1", :port => 26381}]
+
+    commands = {
+      :s1 => [],
+      :m1 => []
+    }
+
+    sentinel = {
+      :auth => lambda do |pass|
+        commands[:s1] << ["auth", pass]
+        "-ERR unknown command 'auth'"
+      end,
+      :select => lambda do |db|
+        commands[:s1] << ["select", db]
+        "-ERR unknown command 'select'"
+      end,
+      :sentinel => lambda do |command, *args|
+        commands[:s1] << [command, *args]
+        ["127.0.0.1", "6382"]
+      end
+    }
+
+    master = {
+      :auth => lambda do |pass|
+        commands[:m1] << ["auth", pass]
+        "+OK"
+      end,
+      :role => lambda do
+        commands[:m1] << ["role"]
+        ["master"]
+      end
+    }
+
+    RedisMock.start(master, {}, 6382) do
+      RedisMock.start(sentinel, {}, 26381) do
+        redis = Redis.new(:url => "redis://:foo@master1/15", :sentinels => sentinels, :role => :master)
+
+        assert redis.ping
+      end
+    end
+
+    assert_equal [%w[get-master-addr-by-name master1]], commands[:s1]
+    assert_equal [%w[auth foo], %w[role]], commands[:m1]
+  end
+
+  def test_sentinel_role_mismatch
+    sentinels = [{:host => "127.0.0.1", :port => 26381}]
+
+    sentinel = {
+      :sentinel => lambda do |command, *args|
+        ["127.0.0.1", "6382"]
+      end
+    }
+
+    master = {
+      :role => lambda do
+        ["slave"]
+      end
+    }
+
+    ex = assert_raise(Redis::ConnectionError) do
+      RedisMock.start(master, {}, 6382) do
+        RedisMock.start(sentinel, {}, 26381) do
+          redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
+
+          assert redis.ping
+        end
+      end
+    end
+
+    assert_match(/Instance role mismatch/, ex.message)
+  end
+
+  def test_sentinel_retries
+    sentinels = [{:host => "127.0.0.1", :port => 26381},
+                 {:host => "127.0.0.1", :port => 26382}]
+
+    connections = []
+
+    handler = lambda do |id|
+      {
+        :sentinel => lambda do |command, *args|
+          connections << id
+
+          if connections.count(id) < 2
+            :close
+          else
+            ["127.0.0.1", "6382"]
+          end
+        end
+      }
+    end
+
+    master = {
+      :role => lambda do
+        ["master"]
+      end
+    }
+
+    RedisMock.start(master, {}, 6382) do
+      RedisMock.start(handler.call(:s1), {}, 26381) do
+        RedisMock.start(handler.call(:s2), {}, 26382) do
+          redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 1)
+
+          assert redis.ping
+        end
+      end
+    end
+
+    assert_equal [:s1, :s2, :s1], connections
+
+    connections.clear
+
+    ex = assert_raise(Redis::CannotConnectError) do
+      RedisMock.start(master, {}, 6382) do
+        RedisMock.start(handler.call(:s1), {}, 26381) do
+          RedisMock.start(handler.call(:s2), {}, 26382) do
+            redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 0)
+
+            assert redis.ping
+          end
+        end
+      end
+    end
+
+    assert_match(/No sentinels available/, ex.message)
+  end
+end

data/test/support/redis_mock.rb

@@ -24,20 +24,26 @@ module RedisMock
     end
 
     def run
-      loop do
-        session = @server.accept
-
+      begin
+        loop do
+          session = @server.accept
+
+          begin
+            return if yield(session) == :exit
+          ensure
+            session.close
+          end
+        end
+      rescue => ex
+        $stderr.puts "Error running mock server: #{ex.message}" if VERBOSE
+        $stderr.puts ex.backtrace if VERBOSE
+        retry
+      ensure
         begin
-          return if yield(session) == :exit
-        ensure
-          session.close
+          @server.close
+        rescue IOError
         end
       end
-    rescue => ex
-      $stderr.puts "Error running mock server: #{ex.message}" if VERBOSE
-      $stderr.puts ex.backtrace if VERBOSE
-    ensure
-      @server.close
     end
   end
 
@@ -53,13 +59,13 @@ module RedisMock
   #     # Every connection will be closed immediately
   #   end
   #
-  def self.start_with_handler(blk, options = {})
-    server = Server.new(MOCK_PORT, options)
+  def self.start_with_handler(blk, options = {}, port = MOCK_PORT)
+    server = Server.new(port, options)
 
     begin
       server.start(&blk)
 
-      yield(MOCK_PORT)
+      yield(port)
 
     ensure
       server.shutdown
@@ -75,7 +81,7 @@ module RedisMock
   #     assert_equal "PONG", Redis.new(:port => MOCK_PORT).ping
   #   end
   #
-  def self.start(commands, options = {}, &blk)
+  def self.start(commands, options = {}, port = MOCK_PORT, &blk)
     handler = lambda do |session|
       while line = session.gets
         argv = Array.new(line[1..-3].to_i) do
@@ -110,6 +116,6 @@ module RedisMock
       end
     end
 
-    start_with_handler(handler, options, &blk)
+    start_with_handler(handler, options, port, &blk)
   end
 end

data/test/test.conf.erb

@@ -0,0 +1,9 @@
+dir <%=        REDIS_DIR %>
+pidfile <%=    REDIS_PID %>
+port 6381
+unixsocket <%= REDIS_SOCKET %>
+timeout 300
+loglevel debug
+logfile <%=    REDIS_LOG %>
+databases 16
+daemonize yes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-11 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -134,6 +134,7 @@ files:
 - test/remote_server_control_commands_test.rb
 - test/scanning_test.rb
 - test/scripting_test.rb
+- test/sentinel_test.rb
 - test/sorting_test.rb
 - test/support/connection/hiredis.rb
 - test/support/connection/ruby.rb
@@ -142,7 +143,7 @@ files:
 - test/support/wire/synchrony.rb
 - test/support/wire/thread.rb
 - test/synchrony_driver.rb
-- test/test.conf
+- test/test.conf.erb
 - test/thread_safety_test.rb
 - test/transactions_test.rb
 - test/unknown_commands_test.rb
@@ -223,6 +224,7 @@ test_files:
 - test/remote_server_control_commands_test.rb
 - test/scanning_test.rb
 - test/scripting_test.rb
+- test/sentinel_test.rb
 - test/sorting_test.rb
 - test/support/connection/hiredis.rb
 - test/support/connection/ruby.rb
@@ -231,7 +233,7 @@ test_files:
 - test/support/wire/synchrony.rb
 - test/support/wire/thread.rb
 - test/synchrony_driver.rb
-- test/test.conf
+- test/test.conf.erb
 - test/thread_safety_test.rb
 - test/transactions_test.rb
 - test/unknown_commands_test.rb

data/test/test.conf

@@ -1,9 +0,0 @@
-dir ./test/db
-pidfile ./redis.pid
-port 6381
-unixsocket ./redis.sock
-timeout 300
-loglevel debug
-logfile stdout
-databases 16
-daemonize yes