Add the :nearest_slave role for Sentinel mode

This will cause the client to measure roundtrip latency to each slave
and select the slave with the lowest latency. The intent for this is
to enable sentinel-managed clusters of servers for which eventually-consistent
reads are acceptable, but to maintain minimum latencies between any
individual client-slave pair.

The case I did this for is is shared web application caching across multiple
datacenters, where you would not want Redis to connect to a slave in another
datacenter, but you would want all datacenters to share a cache.

Remove trailing comma from client creation options; should fix 1.8 builds

If we can't get the role, use a translated role

Ensure that ping test clients are always disconnected after use. Don't assume that a good slave was found.

Author: cheald

lib/redis/client.rb

@@ -529,6 +529,10 @@ def resolve
       def check(client); end
 
       class Sentinel < Connector
+        EXPECTED_ROLES = {
+          "nearest_slave" => "slave"
+        }
+
         def initialize(options)
           super(options)
 
@@ -547,12 +551,12 @@ def check(client)
             role = client.call([:role])[0]
           rescue Redis::CommandError
             # Assume the test is passed if we can't get a reply from ROLE...
-            role = @role
+            role = EXPECTED_ROLES.fetch(@role, @role)
           end
 
-          if role != @role
+          if role != EXPECTED_ROLES.fetch(@role, @role)
             client.disconnect
-            raise ConnectionError, "Instance role mismatch. Expected #{@role}, got #{role}."
+            raise ConnectionError, "Instance role mismatch. Expected #{EXPECTED_ROLES.fetch(@role, @role)}, got #{role}."
           end
         end
 
@@ -562,6 +566,8 @@ def resolve
             resolve_master
           when "slave"
             resolve_slave
+          when "nearest_slave"
+            resolve_nearest_slave
           else
             raise ArgumentError, "Unknown instance role #{@role}"
           end
@@ -622,6 +628,34 @@ def resolve_slave
             end
           end
         end
+
+        def resolve_nearest_slave
+          sentinel_detect do |client|
+            if reply = client.call(["sentinel", "slaves", @master])
+              ok_slaves = reply.map {|r| Hash[*r] }.select  {|r| r["master-link-status"] == "ok" }
+
+              ok_slaves.each do |slave|
+                client = Client.new @options.merge(
+                  :host => slave["ip"],
+                  :port => slave["port"],
+                  :reconnect_attempts => 0
+                )
+                begin
+                  client.call [:ping]
+                  start = Time.now
+                  client.call [:ping]
+                  slave["response_time"] = (Time.now - start).to_f
+                ensure
+                  client.disconnect
+                end
+              end
+
+              slave = ok_slaves.sort_by {|slave| slave["response_time"] }.first
+              {:host => slave.fetch("ip"), :port => slave.fetch("port")} if slave
+            end
+          end
+        end
+
       end
     end
   end

test/sentinel_test.rb

@@ -377,4 +377,48 @@ def test_sentinel_with_string_option_keys
 
     assert_equal [%w[get-master-addr-by-name master1]], commands
   end
+
+  def test_sentinel_nearest_slave
+    sentinels = [{:host => "127.0.0.1", :port => 26381}]
+
+    master = { :role => lambda { ["master"] } }
+    s1 = { :role => lambda { ["slave"] }, :slave_id => lambda { ["1"] }, :ping => lambda { ["OK"] } }
+    s2 = { :role => lambda { ["slave"] }, :slave_id => lambda { ["2"] }, :ping => lambda { sleep 0.1; ["OK"] } }
+    s3 = { :role => lambda { ["slave"] }, :slave_id => lambda { ["3"] }, :ping => lambda { sleep 0.2; ["OK"] } }
+
+    5.times do
+      RedisMock.start(master) do |master_port|
+        RedisMock.start(s1) do |s1_port|
+          RedisMock.start(s2) do |s2_port|
+            RedisMock.start(s3) do |s3_port|
+
+              sentinel = lambda do |port|
+                {
+                  :sentinel => lambda do |command, *args|
+                    case command
+                    when "slaves"
+                      [
+                        %W[master-link-status down ip 127.0.0.1 port #{s1_port}],
+                        %W[master-link-status ok ip 127.0.0.1 port #{s2_port}],
+                        %W[master-link-status ok ip 127.0.0.1 port #{s3_port}]
+                      ].shuffle
+                    else
+                      ["127.0.0.1", port.to_s]
+                    end
+                  end
+                }
+              end
+
+              RedisMock.start(sentinel.call(master_port)) do |sen_port|
+                sentinels[0][:port] = sen_port
+                redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :nearest_slave)
+                assert_equal redis.slave_id, ["2"]
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
 end