redis 3.0.1 → 3.0.2

data/lib/redis/client.rb

@@ -1,9 +1,12 @@
 require "redis/errors"
+require "socket"
+require "cgi"
 
 class Redis
   class Client
 
     DEFAULTS = {
+      :url => lambda { ENV["REDIS_URL"] },
       :scheme => "redis",
       :host => "127.0.0.1",
       :port => 6379,
@@ -11,6 +14,9 @@ class Redis
       :timeout => 5.0,
       :password => nil,
       :db => 0,
+      :driver => nil,
+      :id => nil,
+      :tcp_keepalive => 0
     }
 
     def scheme
@@ -45,9 +51,9 @@ class Redis
       @options[:db] = db.to_i
     end
 
-    attr :logger
-    attr :connection
-    attr :command_map
+    attr_accessor :logger
+    attr_reader :connection
+    attr_reader :command_map
 
     def initialize(options = {})
       @options = _parse_options(options)
@@ -295,8 +301,19 @@ class Redis
 
     def _parse_options(options)
       defaults = DEFAULTS.dup
+      options = options.dup
 
-      url = options[:url] || ENV["REDIS_URL"]
+      defaults.keys.each do |key|
+        # Fill in defaults if needed
+        if defaults[key].respond_to?(:call)
+          defaults[key] = defaults[key].call
+        end
+
+        # Symbolize only keys that are needed
+        options[key] = options[key.to_s] if options.has_key?(key.to_s)
+      end
+
+      url = options[:url] || defaults[:url]
 
       # Override defaults from URL if given
       if url
@@ -313,12 +330,15 @@ class Redis
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host
           defaults[:port]     = uri.port if uri.port
-          defaults[:password] = uri.password if uri.password
+          defaults[:password] = CGI.unescape(uri.password) if uri.password
           defaults[:db]       = uri.path[1..-1].to_i if uri.path
         end
       end
 
-      options = defaults.merge(options)
+      # Use default when option is not specified or nil
+      defaults.keys.each do |key|
+        options[key] ||= defaults[key]
+      end
 
       if options[:path]
         options[:scheme] = "unix"
@@ -333,6 +353,26 @@ class Redis
       options[:db] = options[:db].to_i
       options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
 
+      case options[:tcp_keepalive]
+      when Hash
+        [:time, :intvl, :probes].each do |key|
+          unless options[:tcp_keepalive][key].is_a?(Fixnum)
+            raise "Expected the #{key.inspect} key in :tcp_keepalive to be a Fixnum"
+          end
+        end
+
+      when Fixnum
+        if options[:tcp_keepalive] >= 60
+          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2}
+
+        elsif options[:tcp_keepalive] >= 30
+          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 10, :intvl => 5, :probes => 2}
+
+        elsif options[:tcp_keepalive] >= 5
+          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 2, :intvl => 2, :probes => 1}
+        end
+      end
+
       options
     end
 

data/lib/redis/connection/ruby.rb

@@ -79,22 +79,26 @@ class Redis
         end
       end
 
-      class UNIXSocket < ::UNIXSocket
+      if defined?(::UNIXSocket)
 
-        # This class doesn't include the mixin, because JRuby raises
-        # Errno::EAGAIN on #read_nonblock even when IO.select says it is
-        # readable. This behavior shows in 1.6.6 in both 1.8 and 1.9 mode.
-        # Therefore, fall back on the default Unix socket implementation,
-        # without timeouts.
+        class UNIXSocket < ::UNIXSocket
 
-        def self.connect(path, timeout)
-          Timeout.timeout(timeout) do
-            sock = new(path)
-            sock
+          # This class doesn't include the mixin, because JRuby raises
+          # Errno::EAGAIN on #read_nonblock even when IO.select says it is
+          # readable. This behavior shows in 1.6.6 in both 1.8 and 1.9 mode.
+          # Therefore, fall back on the default Unix socket implementation,
+          # without timeouts.
+
+          def self.connect(path, timeout)
+            Timeout.timeout(timeout) do
+              sock = new(path)
+              sock
+            end
+          rescue Timeout::Error
+            raise TimeoutError
           end
-        rescue Timeout::Error
-          raise TimeoutError
         end
+
       end
 
     else
@@ -172,9 +176,37 @@ class Redis
 
         instance = new(sock)
         instance.timeout = config[:timeout]
+        instance.set_tcp_keepalive config[:tcp_keepalive]
         instance
       end
 
+      if [:SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all?{|c| Socket.const_defined? c}
+        def set_tcp_keepalive(keepalive)
+          return unless keepalive.is_a?(Hash)
+
+          @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE,  true)
+          @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPIDLE,  keepalive[:time])
+          @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPINTVL, keepalive[:intvl])
+          @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPCNT,   keepalive[:probes])
+        end
+
+        def get_tcp_keepalive
+          {
+            :time   => @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE).int,
+            :intvl  => @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL).int,
+            :probes => @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT).int,
+          }
+        end
+      else
+        def set_tcp_keepalive(keepalive)
+        end
+
+        def get_tcp_keepalive
+          {
+          }
+        end
+      end
+
       def initialize(sock)
         @sock = sock
       end

data/lib/redis/connection/synchrony.rb

@@ -27,13 +27,18 @@ class Redis
       def receive_data(data)
         @reader.feed(data)
 
-        begin
-          until (reply = @reader.gets) == false
-            reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
-            @req.succeed [:reply, reply]
+        loop do
+          begin
+            reply = @reader.gets
+          rescue RuntimeError => err
+            @req.fail [:error, ProtocolError.new(err.message)]
+            break
           end
-        rescue RuntimeError => err
-          @req.fail [:error, ProtocolError.new(err.message)]
+
+          break if reply == false
+
+          reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
+          @req.succeed [:reply, reply]
         end
       end
 

data/lib/redis/distributed.rb

@@ -15,10 +15,11 @@ class Redis
 
     attr_reader :ring
 
-    def initialize(urls, options = {})
+    def initialize(node_configs, options = {})
       @tag = options.delete(:tag) || /^\{(.+?)\}/
       @default_options = options
-      @ring = HashRing.new urls.map { |url| Redis.new(options.merge(:url => url)) }
+      @ring = HashRing.new
+      node_configs.each { |node_config| add_node(node_config) }
       @subscribed_node = nil
     end
 
@@ -30,8 +31,10 @@ class Redis
       @ring.nodes
     end
 
-    def add_node(url)
-      @ring.add_node Redis.new(@default_options.merge(:url => url))
+    def add_node(options)
+      options = { :url => options } if options.is_a?(String)
+      options = @default_options.merge(options)
+      @ring.add_node Redis.new( options )
     end
 
     # Change the selected database for the current connection.

data/lib/redis/pipeline.rb

@@ -68,14 +68,19 @@ class Redis
 
     class Multi < self
       def finish(replies)
-        return if replies.last.nil? # The transaction failed because of WATCH.
+        exec = replies.last
 
-        if replies.last.size < futures.size - 2
+        return if exec.nil? # The transaction failed because of WATCH.
+
+        # EXEC command failed.
+        raise exec if exec.is_a?(CommandError)
+
+        if exec.size < futures.size - 2
           # Some command wasn't recognized by Redis.
-          raise replies.detect { |r| r.kind_of?(::RuntimeError) }
+          raise replies.detect { |r| r.is_a?(CommandError) }
         end
 
-        super(replies.last) do |reply|
+        super(exec) do |reply|
           # Because an EXEC returns nested replies, hiredis won't be able to
           # convert an error reply to a CommandError instance itself. This is
           # specific to MULTI/EXEC, so we solve this here.

data/lib/redis/subscribe.rb

@@ -17,11 +17,11 @@ class Redis
     end
 
     def unsubscribe(*channels)
-      call [:unsubscribe, *channels]
+      call([:unsubscribe, *channels])
     end
 
     def punsubscribe(*channels)
-      call [:punsubscribe, *channels]
+      call([:punsubscribe, *channels])
     end
 
   protected

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.0.1"
+  VERSION = "3.0.2"
 end

data/test/distributed_internals_test.rb

@@ -12,4 +12,30 @@ class TestDistributedInternals < Test::Unit::TestCase
 
     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]
+    redis = Redis::Distributed.new nodes
+    assert_equal ["redis://localhost:#{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)]
+    redis = Redis::Distributed.new nodes
+    assert_equal ["redis://localhost:#{PORT}/15","redis://localhost:#{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)]
+    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 }
+  end
+
+  def test_override_id
+    nodes = [OPTIONS.merge(:host => 'localhost', :id => "test"), OPTIONS.merge( :host => 'localhost', :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
 end

data/test/distributed_remote_server_control_commands_test.rb

@@ -28,7 +28,7 @@ class TestDistributedRemoteServerControlCommands < Test::Unit::TestCase
   end
 
   def test_info_commandstats
-    return if version < "2.9.0"
+    return if version < "2.5.7"
 
     r.nodes.each { |n| n.config(:resetstat) }
     r.ping # Executed on every node

data/test/internals_test.rb

@@ -98,6 +98,24 @@ class TestInternals < Test::Unit::TestCase
     end
   end
 
+  driver(:ruby) do
+    def test_tcp_keepalive
+      keepalive = {:time => 20, :intvl => 10, :probes => 5}
+
+      redis = Redis.new(OPTIONS.merge(:tcp_keepalive => keepalive))
+      redis.ping
+
+      connection = redis.client.connection
+      actual_keepalive = connection.get_tcp_keepalive
+
+      [:time, :intvl, :probes].each do |key|
+        if actual_keepalive.has_key?(key)
+          assert_equal actual_keepalive[key], keepalive[key]
+        end
+      end
+    end
+  end
+
   def test_time
     return if version < "2.5.4"
 

data/test/lint/sorted_sets.rb

@@ -2,6 +2,8 @@ module Lint
 
   module SortedSets
 
+    Infinity = 1.0/0.0
+
     def test_zadd
       assert_equal 0, r.zcard("foo")
       assert_equal true, r.zadd("foo", 1, "s1")
@@ -61,6 +63,12 @@ module Lint
 
       rv = r.zincrby "foo", 10, "s1"
       assert_equal 11.0, rv
+
+      rv = r.zincrby "bar", "-inf", "s1"
+      assert_equal(-Infinity, rv)
+
+      rv = r.zincrby "bar", "+inf", "s2"
+      assert_equal(+Infinity, rv)
     end
 
     def test_zrank
@@ -87,6 +95,11 @@ module Lint
       assert_equal ["s1", "s2"], r.zrange("foo", 0, 1)
       assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :with_scores => true)
       assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :with_scores => true)
+      assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :withscores => true)
     end
 
     def test_zrevrange
@@ -97,6 +110,11 @@ module Lint
       assert_equal ["s3", "s2"], r.zrevrange("foo", 0, 1)
       assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :with_scores => true)
       assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :with_scores => true)
+      assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :withscores => true)
     end
 
     def test_zrangebyscore
@@ -147,6 +165,13 @@ module Lint
       assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :with_scores => true)
       assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :withscores => true)
       assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :withscores => true)
+      assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :withscores => true)
     end
 
     def test_zrevrangebyscore_with_withscores
@@ -159,6 +184,13 @@ module Lint
       assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :with_scores => true)
       assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :withscores => true)
       assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :withscores => true)
+      assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :withscores => true)
     end
 
     def test_zcard
@@ -176,6 +208,11 @@ module Lint
 
       assert_equal nil, r.zscore("foo", "s2")
       assert_equal nil, r.zscore("bar", "s1")
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal(-Infinity, r.zscore("bar", "s1"))
+      assert_equal(+Infinity, r.zscore("bar", "s2"))
     end
 
     def test_zremrangebyrank

data/test/lint/value_types.rb

@@ -32,30 +32,30 @@ module Lint
 
     def test_expire
       r.set("foo", "s1")
-      assert r.expire("foo", 1)
-      assert_in_range 0..1, r.ttl("foo")
+      assert r.expire("foo", 2)
+      assert_in_range 0..2, r.ttl("foo")
     end
 
     def test_pexpire
       return if version < "2.5.4"
 
       r.set("foo", "s1")
-      assert r.pexpire("foo", 1000)
-      assert_in_range 0..1, r.ttl("foo")
+      assert r.pexpire("foo", 2000)
+      assert_in_range 0..2, r.ttl("foo")
     end
 
     def test_expireat
       r.set("foo", "s1")
-      assert r.expireat("foo", (Time.now + 1).to_i)
-      assert_in_range 0..1, r.ttl("foo")
+      assert r.expireat("foo", (Time.now + 2).to_i)
+      assert_in_range 0..2, r.ttl("foo")
     end
 
     def test_pexpireat
       return if version < "2.5.4"
 
       r.set("foo", "s1")
-      assert r.pexpireat("foo", (Time.now + 1).to_i * 1_000)
-      assert_in_range 0..1, r.ttl("foo")
+      assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
+      assert_in_range 0..2, r.ttl("foo")
     end
 
     def test_persist
@@ -68,16 +68,16 @@ module Lint
 
     def test_ttl
       r.set("foo", "s1")
-      r.expire("foo", 1)
-      assert_in_range 0..1, r.ttl("foo")
+      r.expire("foo", 2)
+      assert_in_range 0..2, r.ttl("foo")
     end
 
     def test_pttl
       return if version < "2.5.4"
 
       r.set("foo", "s1")
-      r.expire("foo", 1)
-      assert_in_range 1..1000, r.pttl("foo")
+      r.expire("foo", 2)
+      assert_in_range 1..2000, r.pttl("foo")
     end
 
     def test_move