redis 3.0.2 → 3.0.3

data/.order

@@ -22,7 +22,8 @@
     "slaveof",
     "slowlog",
     "sync",
-    "time"
+    "time",
+    "client"
   ],
   "generic": [
     "persist",
@@ -70,7 +71,8 @@
     "append",
     "bitcount",
     "getset",
-    "strlen"
+    "strlen",
+    "bitop"
   ],
   "list": [
     "llen",
@@ -90,8 +92,7 @@
     "lrange",
     "lrem",
     "lset",
-    "ltrim",
-    "bitop"
+    "ltrim"
   ],
   "set": [
     "scard",
@@ -166,4 +167,4 @@
     "eval",
     "evalsha"
   ]
-}
+}

data/.travis.yml

@@ -3,12 +3,12 @@ language: ruby
 branches:
   only:
     - master
-    - test-unit
 
 rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
+  - 2.0.0
   - jruby-18mode
   - jruby-19mode
 

data/CHANGELOG.md

@@ -1,4 +1,23 @@
-# 3.0.2 (unreleased)
+# 3.0.4 (unreleased)
+
+* ...
+
+# 3.0.3
+
+* Blocking list commands (`BLPOP`, `BRPOP`, `BRPOPLPUSH`) use a socket
+  timeout equal to the sum of the command's timeout and the Redis
+  client's timeout, instead of disabling socket timeout altogether.
+
+* Ruby 2.0 compatibility.
+
+* Added support for `DUMP` and `RESTORE` (Redis 2.6).
+
+* Added support for `BITCOUNT` and `BITOP` (Redis 2.6).
+
+* Call `#to_s` on value argument for `SET`, `SETEX`, `PSETEX`, `GETSET`,
+  `SETNX`, and `SETRANGE`.
+
+# 3.0.2
 
 * Unescape CGI escaped password in URL.
 

data/benchmarking/logging.rb

@@ -54,7 +54,16 @@ benchmark "Default options (no logger)" do
 end
 
 logging_redises.each do |redis|
-  benchmark "#{redis.client.logger.class} on #{Logger::SEV_LABEL[redis.client.logger.level]}" do
+  logger = redis.client.logger
+
+  case logger
+  when Logger
+    level = Logger::SEV_LABEL[logger.level]
+  when Log4r::Logger
+    level = logger.levels[logger.level]
+  end
+
+  benchmark "#{logger.class} on #{level}" do
     stress(redis)
   end
 end

data/lib/redis.rb

@@ -181,7 +181,7 @@ class Redis
         if reply.kind_of?(String)
           reply = Hash[reply.split("\r\n").map do |line|
             line.split(":", 2) unless line =~ /^(#|$)/
-          end]
+          end.compact]
 
           if cmd && cmd.to_s == "commandstats"
             # Extract nested hashes for INFO COMMANDSTATS
@@ -359,6 +359,28 @@ class Redis
     end
   end
 
+  # Return a serialized version of the value stored at a key.
+  #
+  # @param [String] key
+  # @return [String] serialized_value
+  def dump(key)
+    synchronize do |client|
+      client.call([:dump, key])
+    end
+  end
+
+  # Create a key using the serialized value, previously obtained using DUMP.
+  #
+  # @param [String] key
+  # @param [String] ttl
+  # @param [String] serialized_value
+  # @return `"OK"`
+  def restore(key, ttl, serialized_value)
+    synchronize do |client|
+      client.call([:restore, key, ttl, serialized_value])
+    end
+  end
+
   # Delete one or more keys.
   #
   # @param [String, Array<String>] keys
@@ -605,7 +627,7 @@ class Redis
   # @return `"OK"`
   def set(key, value)
     synchronize do |client|
-      client.call([:set, key, value])
+      client.call([:set, key, value.to_s])
     end
   end
 
@@ -619,7 +641,7 @@ class Redis
   # @return `"OK"`
   def setex(key, ttl, value)
     synchronize do |client|
-      client.call([:setex, key, ttl, value])
+      client.call([:setex, key, ttl, value.to_s])
     end
   end
 
@@ -631,7 +653,7 @@ class Redis
   # @return `"OK"`
   def psetex(key, ttl, value)
     synchronize do |client|
-      client.call([:psetex, key, ttl, value])
+      client.call([:psetex, key, ttl, value.to_s])
     end
   end
 
@@ -642,7 +664,7 @@ class Redis
   # @return [Boolean] whether the key was set or not
   def setnx(key, value)
     synchronize do |client|
-      client.call([:setnx, key, value], &_boolify)
+      client.call([:setnx, key, value.to_s], &_boolify)
     end
   end
 
@@ -762,7 +784,7 @@ class Redis
   # @return [Fixnum] length of the string after it was modified
   def setrange(key, offset, value)
     synchronize do |client|
-      client.call([:setrange, key, offset, value])
+      client.call([:setrange, key, offset, value.to_s])
     end
   end
 
@@ -813,6 +835,30 @@ class Redis
     end
   end
 
+  # Count the number of set bits in a range of the string value stored at key.
+  #
+  # @param [String] key
+  # @param [Fixnum] start start index
+  # @param [Fixnum] stop stop index
+  # @return [Fixnum] the number of bits set to 1
+  def bitcount(key, start = 0, stop = -1)
+    synchronize do |client|
+      client.call([:bitcount, key, start, stop])
+    end
+  end
+
+  # Perform a bitwise operation between strings and store the resulting string in a key.
+  #
+  # @param [String] operation e.g. `and`, `or`, `xor`, `not`
+  # @param [String] destkey destination key
+  # @param [String, Array<String>] keys one or more source keys to perform `operation`
+  # @return [Fixnum] the length of the string stored in `destkey`
+  def bitop(operation, destkey, *keys)
+    synchronize do |client|
+      client.call([:bitop, operation, destkey] + keys)
+    end
+  end
+
   # Set the string value of a key and return its old value.
   #
   # @param [String] key
@@ -821,7 +867,7 @@ class Redis
   #   did not exist
   def getset(key, value)
     synchronize do |client|
-      client.call([:getset, key, value])
+      client.call([:getset, key, value.to_s])
     end
   end
 
@@ -849,7 +895,7 @@ class Redis
   # Prepend one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
-  # @param [String] value
+  # @param [String, Array] string value, or array of string values to push
   # @return [Fixnum] the length of the list after the push operation
   def lpush(key, value)
     synchronize do |client|
@@ -940,7 +986,9 @@ class Redis
     timeout = options[:timeout] || 0
 
     synchronize do |client|
-      client.call_without_timeout([cmd, keys, timeout])
+      command = [cmd, keys, timeout]
+      timeout += client.timeout if timeout > 0
+      client.call_with_timeout(command, timeout)
     end
   end
 
@@ -1006,7 +1054,9 @@ class Redis
     timeout = options[:timeout] || 0
 
     synchronize do |client|
-      client.call_without_timeout([:brpoplpush, source, destination, timeout])
+      command = [:brpoplpush, source, destination, timeout]
+      timeout += client.timeout if timeout > 0
+      client.call_with_timeout(command, timeout)
     end
   end
 
@@ -1150,13 +1200,18 @@ class Redis
     end
   end
 
-  # Get a random member from a set.
+  # Get one or more random members from a set.
   #
   # @param [String] key
+  # @param [Fixnum] count
   # @return [String]
-  def srandmember(key)
+  def srandmember(key, count = nil)
     synchronize do |client|
-      client.call([:srandmember, key])
+      if count.nil?
+        client.call([:srandmember, key])
+      else
+        client.call([:srandmember, key, count])
+      end
     end
   end
 

data/lib/redis/client.rb

@@ -160,14 +160,18 @@ class Redis
       result
     end
 
-    def call_without_timeout(command, &blk)
-      without_socket_timeout do
+    def call_with_timeout(command, timeout, &blk)
+      with_socket_timeout(timeout) do
         call(command, &blk)
       end
     rescue ConnectionError
       retry
     end
 
+    def call_without_timeout(command, &blk)
+      call_with_timeout(command, 0, &blk)
+    end
+
     def process(commands)
       logging(commands) do
         ensure_connected do
@@ -218,17 +222,21 @@ class Redis
       end
     end
 
-    def without_socket_timeout
+    def with_socket_timeout(timeout)
       connect unless connected?
 
       begin
-        connection.timeout = 0
+        connection.timeout = timeout
         yield
       ensure
-        connection.timeout = timeout if connected?
+        connection.timeout = self.timeout if connected?
       end
     end
 
+    def without_socket_timeout(&blk)
+      with_socket_timeout(0, &blk)
+    end
+
     def with_reconnect(val=true)
       begin
         original, @reconnect = @reconnect, val

data/lib/redis/connection/ruby.rb

@@ -83,11 +83,7 @@ class Redis
 
         class UNIXSocket < ::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.
+          include SocketMixin
 
           def self.connect(path, timeout)
             Timeout.timeout(timeout) do
@@ -97,6 +93,17 @@ class Redis
           rescue Timeout::Error
             raise TimeoutError
           end
+
+          # JRuby raises Errno::EAGAIN on #read_nonblock even when IO.select
+          # says it is readable (1.6.6, in both 1.8 and 1.9 mode).
+          # Use the blocking #readpartial method instead.
+
+          def _read_from_socket(nbytes)
+            readpartial(nbytes)
+
+          rescue EOFError
+            raise Errno::ECONNRESET
+          end
         end
 
       end
@@ -132,8 +139,7 @@ class Redis
 
       class UNIXSocket < ::Socket
 
-        # This class doesn't include the mixin to keep its behavior in sync
-        # with the JRuby implementation.
+        include SocketMixin
 
         def self.connect(path, timeout)
           sock = new(::Socket::AF_UNIX, Socket::SOCK_STREAM, 0)

data/lib/redis/distributed.rb

@@ -137,6 +137,16 @@ class Redis
       node_for(key).pttl(key)
     end
 
+    # Return a serialized version of the value stored at a key.
+    def dump(key)
+      node_for(key).dump(key)
+    end
+
+    # Create a key using the serialized value, previously obtained using DUMP.
+    def restore(key, ttl, serialized_value)
+      node_for(key).restore(key, ttl, serialized_value)
+    end
+
     # Delete a key.
     def del(*args)
       keys_per_node = args.group_by { |key| node_for(key) }
@@ -295,6 +305,18 @@ class Redis
       node_for(key).append(key, value)
     end
 
+    # Count the number of set bits in a range of the string value stored at key.
+    def bitcount(key, start = 0, stop = -1)
+      node_for(key).bitcount(key, start, stop)
+    end
+
+    # Perform a bitwise operation between strings and store the resulting string in a key.
+    def bitop(operation, destkey, *keys)
+      ensure_same_node(:bitop, [destkey] + keys) do |node|
+        node.bitop(operation, destkey, *keys)
+      end
+    end
+
     # Set the string value of a key and return its old value.
     def getset(key, value)
       node_for(key).getset(key, value)
@@ -455,8 +477,8 @@ class Redis
     end
 
     # Get a random member from a set.
-    def srandmember(key)
-      node_for(key).srandmember(key)
+    def srandmember(key, count = nil)
+      node_for(key).srandmember(key, count)
     end
 
     # Move a member from one set to another.

data/lib/redis/hash_ring.rb

@@ -55,8 +55,8 @@ class Redis
     def iter_nodes(key)
       return [nil,nil] if @ring.size == 0
       _, pos = get_node_pos(key)
-      @sorted_keys[pos..-1].each do |k|
-        yield @ring[k]
+      @ring.size.times do |n|
+        yield @ring[@sorted_keys[(pos+n) % @ring.size]]
       end
     end
 

data/lib/redis/subscribe.rb

@@ -29,14 +29,17 @@ class Redis
     def subscription(start, stop, channels, block)
       sub = Subscription.new(&block)
 
+      unsubscribed = false
+
       begin
         @client.call_loop([start, *channels]) do |line|
           type, *rest = line
           sub.callbacks[type].call(*rest)
-          break if type == stop && rest.last == 0
+          unsubscribed = type == stop && rest.last == 0
+          break if unsubscribed
         end
       ensure
-        send(stop)
+        send(stop) if !unsubscribed
       end
     end
   end

data/lib/redis/version.rb

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

data/test/commands_on_strings_test.rb

@@ -80,4 +80,20 @@ class TestCommandsOnStrings < Test::Unit::TestCase
     assert_equal "s2", r.get("foo")
     assert_equal "s3", r.get("bar")
   end
+
+  def test_bitop
+    return if version < "2.5.10"
+
+    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

data/test/distributed_commands_on_strings_test.rb

@@ -45,4 +45,15 @@ class TestDistributedCommandsOnStrings < Test::Unit::TestCase
       r.mapped_msetnx(:foo => "s2", :bar => "s3")
     end
   end
+
+  def test_bitop
+    return if version < "2.5.10"
+
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "a")
+      r.set("bar", "b")
+
+      r.bitop(:and, "foo&bar", "foo", "bar")
+    end
+  end
 end

data/test/distributed_commands_requiring_clustering_test.rb

@@ -145,4 +145,20 @@ class TestDistributedCommandsRequiringClustering < Test::Unit::TestCase
     r.sort("{qux}bar", :get => "{qux}foo:*", :store => "{qux}baz")
     assert_equal ["s1", "s2"], r.lrange("{qux}baz", 0, -1)
   end
+
+  def test_bitop
+    return if version < "2.5.10"
+
+    r.set("{qux}foo", "a")
+    r.set("{qux}bar", "b")
+
+    r.bitop(:and, "{qux}foo&bar", "{qux}foo", "{qux}bar")
+    assert_equal "\x60", r.get("{qux}foo&bar")
+    r.bitop(:or, "{qux}foo|bar", "{qux}foo", "{qux}bar")
+    assert_equal "\x63", r.get("{qux}foo|bar")
+    r.bitop(:xor, "{qux}foo^bar", "{qux}foo", "{qux}bar")
+    assert_equal "\x03", r.get("{qux}foo^bar")
+    r.bitop(:not, "{qux}~foo", "{qux}foo")
+    assert_equal "\x9E", r.get("{qux}~foo")
+  end
 end

data/test/distributed_remote_server_control_commands_test.rb

@@ -17,9 +17,9 @@ class TestDistributedRemoteServerControlCommands < Test::Unit::TestCase
      "total_commands_processed",
     ]
 
-    info = r.info
+    infos = r.info
 
-    info.each do |info|
+    infos.each do |info|
       keys.each do |k|
         msg = "expected #info to include #{k}"
         assert info.keys.include?(k), msg

data/test/helper.rb

@@ -113,7 +113,7 @@ module Helper
 
         return -1 if a.nil?
         return +1 if b.nil?
-        return a <=> b if a != b
+        return a.to_i <=> b.to_i if a != b
       end
 
       0

data/test/helper_test.rb

@@ -7,16 +7,18 @@ class TestHelper < Test::Unit::TestCase
   include Helper
 
   def test_version_comparison
-    v = Version.new("2.0.0")
+    v = Version.new("2.0.1")
 
-    assert v < "3"
     assert v > "1"
     assert v > "2"
+    assert v < "3"
+    assert v < "10"
 
     assert v < "2.1"
-    assert v < "2.0.1"
-    assert v < "2.0.0.1"
+    assert v < "2.0.2"
+    assert v < "2.0.1.1"
+    assert v < "2.0.10"
 
-    assert v == "2.0.0"
+    assert v == "2.0.1"
   end
 end

data/test/internals_test.rb

@@ -280,7 +280,7 @@ class TestInternals < Test::Unit::TestCase
 
   def test_connecting_to_unix_domain_socket
     assert_nothing_raised do
-      Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock")).ping
+      Redis.new(OPTIONS.merge(:path => "./test/db/redis.sock")).ping
     end
   end
 

data/test/lint/blocking_commands.rb

@@ -120,5 +120,31 @@ module Lint
         assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1)
       end
     end
+
+    driver(:ruby, :hiredis) do
+      def test_blpop_socket_timeout
+        mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+          assert_raises(Redis::TimeoutError) do
+            r.blpop("{zap}foo", :timeout => 1)
+          end
+        end
+      end
+
+      def test_brpop_socket_timeout
+        mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+          assert_raises(Redis::TimeoutError) do
+            r.brpop("{zap}foo", :timeout => 1)
+          end
+        end
+      end
+
+      def test_brpoplpush_socket_timeout
+        mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+          assert_raises(Redis::TimeoutError) do
+            r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
+          end
+        end
+      end
+    end
   end
 end

data/test/lint/sets.rb

@@ -92,5 +92,34 @@ module Lint
 
       assert_equal 2, r.scard("foo")
     end
+
+    def test_srandmember_with_positive_count
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "foo", "s3"
+      r.sadd "foo", "s4"
+
+      4.times do
+        assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", 3)).empty?
+
+        assert_equal 3, r.srandmember("foo", 3).size
+      end
+
+      assert_equal 4, r.scard("foo")
+    end
+
+    def test_srandmember_with_negative_count
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "foo", "s3"
+      r.sadd "foo", "s4"
+
+      4.times do
+        assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", -6)).empty?
+        assert_equal 6, r.srandmember("foo", -6).size
+      end
+
+      assert_equal 4, r.scard("foo")
+    end
   end
 end

data/test/lint/strings.rb

@@ -26,6 +26,14 @@ module Lint
       assert_equal "1\n", r.get("foo")
     end
 
+    def test_set_and_get_with_non_string_value
+      value = ["a", "b"]
+
+      r.set("foo", value)
+
+      assert_equal value.to_s, r.get("foo")
+    end
+
     def test_set_and_get_with_ascii_characters
       if defined?(Encoding)
         with_external_encoding("ASCII-8BIT") do
@@ -45,6 +53,14 @@ module Lint
       assert [0, 1].include? r.ttl("foo")
     end
 
+    def test_setex_with_non_string_value
+      value = ["b", "a", "r"]
+
+      assert r.setex("foo", 1, value)
+      assert_equal value.to_s, r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
     def test_psetex
       return if version < "2.5.4"
 
@@ -53,6 +69,16 @@ module Lint
       assert [0, 1].include? r.ttl("foo")
     end
 
+    def test_psetex_with_non_string_value
+      return if version < "2.5.4"
+
+      value = ["b", "a", "r"]
+
+      assert r.psetex("foo", 1000, value)
+      assert_equal value.to_s, r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
     def test_getset
       r.set("foo", "bar")
 
@@ -60,14 +86,35 @@ module Lint
       assert_equal "baz", r.get("foo")
     end
 
+    def test_getset_with_non_string_value
+      r.set("foo", "zap")
+
+      value = ["b", "a", "r"]
+
+      assert_equal "zap", r.getset("foo", value)
+      assert_equal value.to_s, r.get("foo")
+    end
+
     def test_setnx
-      r.set("foo", "s1")
+      r.set("foo", "qux")
+      assert !r.setnx("foo", "bar")
+      assert_equal "qux", r.get("foo")
 
-      assert_equal "s1", r.get("foo")
+      r.del("foo")
+      assert r.setnx("foo", "bar")
+      assert_equal "bar", r.get("foo")
+    end
 
-      r.setnx("foo", "s2")
+    def test_setnx_with_non_string_value
+      value = ["b", "a", "r"]
 
-      assert_equal "s1", r.get("foo")
+      r.set("foo", "qux")
+      assert !r.setnx("foo", value)
+      assert_equal "qux", r.get("foo")
+
+      r.del("foo")
+      assert r.setnx("foo", value)
+      assert_equal value.to_s, r.get("foo")
     end
 
     def test_incr
@@ -133,6 +180,15 @@ module Lint
       assert_equal "c", r.get("foo")
     end
 
+    def test_bitcount
+      return if version < "2.5.10"
+
+      r.set("foo", "abcde")
+
+      assert_equal 10, r.bitcount("foo", 1, 3)
+      assert_equal 17, r.bitcount("foo", 0, -1)
+    end
+
     def test_getrange
       r.set("foo", "abcde")
 
@@ -148,6 +204,16 @@ module Lint
       assert_equal "abare", r.get("foo")
     end
 
+    def test_setrange_with_non_string_value
+      r.set("foo", "abcde")
+
+      value = ["b", "a", "r"]
+
+      r.setrange("foo", 2, value)
+
+      assert_equal "ab#{value.to_s}", r.get("foo")
+    end
+
     def test_strlen
       r.set "foo", "lorem"
 

data/test/lint/value_types.rb

@@ -80,6 +80,26 @@ module Lint
       assert_in_range 1..2000, r.pttl("foo")
     end
 
+    def test_dump_and_restore
+      return if version < "2.5.7"
+
+      r.set("foo", "a")
+      v = r.dump("foo")
+      r.del("foo")
+
+      assert r.restore("foo", 1000, v)
+      assert_equal "a", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+
+      r.rpush("bar", ["b", "c", "d"])
+      w = r.dump("bar")
+      r.del("bar")
+
+      assert r.restore("bar", 1000, w)
+      assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
+      assert [0, 1].include? r.ttl("bar")
+    end
+
     def test_move
       r.select 14
       r.flushdb

data/test/publish_subscribe_test.rb

@@ -67,8 +67,6 @@ class TestPublishSubscribe < Test::Unit::TestCase
           @unsubscribed = true
           @t2 = total
         end
-
-        listening = true
       end
     end
 

data/test/test.conf

@@ -1,7 +1,7 @@
 dir ./test/db
 pidfile ./redis.pid
 port 6381
-unixsocket /tmp/redis.sock
+unixsocket ./redis.sock
 timeout 300
 loglevel debug
 logfile stdout

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -17,7 +17,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-05 00:00:00.000000000 Z
+date: 2013-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake