redis 2.2.2 → 3.0.0.rc1

data/lib/redis/hash_ring.rb

@@ -54,7 +54,7 @@ class Redis
 
     def iter_nodes(key)
       return [nil,nil] if @ring.size == 0
-      node, pos = get_node_pos(key)
+      _, pos = get_node_pos(key)
       @sorted_keys[pos..-1].each do |k|
         yield @ring[k]
       end
@@ -98,7 +98,7 @@ class Redis
           }
           EOM
         end
-      rescue Exception => e
+      rescue Exception
         # Find the closest index in HashRing with value <= the given value
         def binary_search(ary, value, &block)
           upper = ary.size - 1

data/lib/redis/pipeline.rb

@@ -1,34 +1,106 @@
 class Redis
+  unless defined?(::BasicObject)
+    class BasicObject
+      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
+    end
+  end
+
   class Pipeline
-    attr :commands
+    attr :futures
 
     def initialize
-      @commands = []
+      @without_reconnect = false
+      @shutdown = false
+      @futures = []
     end
 
-    # Starting with 2.2.1, assume that this method is called with a single
-    # array argument. Check its size for backwards compat.
-    def call(*args)
-      if args.first.is_a?(Array) && args.size == 1
-        command = args.first
-      else
-        command = args
-      end
+    def without_reconnect?
+      @without_reconnect
+    end
 
-      @commands << command
-      nil
+    def shutdown?
+      @shutdown
     end
 
-    # Assume that this method is called with a single array argument. No
-    # backwards compat here, since it was introduced in 2.2.2.
-    def call_without_reply(command)
-      @commands.push command
-      nil
+    def call(command, &block)
+      # A pipeline that contains a shutdown should not raise ECONNRESET when
+      # the connection is gone.
+      @shutdown = true if command.first == :shutdown
+      future = Future.new(command, block)
+      @futures << future
+      future
     end
 
-    def call_pipelined(commands, options = {})
-      @commands.concat commands
+    def call_pipeline(pipeline)
+      @shutdown = true if pipeline.shutdown?
+      @futures.concat(pipeline.futures)
       nil
     end
+
+    def commands
+      @futures.map { |f| f._command }
+    end
+
+    def without_reconnect(&block)
+      @without_reconnect = true
+      yield
+    end
+
+    def finish(replies)
+      futures.each_with_index.map do |future, i|
+        future._set(replies[i])
+      end
+    end
+
+    class Multi < self
+      def finish(replies)
+        return if replies.last.nil? # The transaction failed because of WATCH.
+
+        if replies.last.size < futures.size - 2
+          # Some command wasn't recognized by Redis.
+          raise replies.detect { |r| r.kind_of?(::Exception) }
+        end
+
+        super(replies.last)
+      end
+
+      def commands
+        [[:multi]] + super + [[:exec]]
+      end
+    end
+  end
+
+  class FutureNotReady < RuntimeError
+    def initialize
+      super("Value will be available once the pipeline executes.")
+    end
+  end
+
+  class Future < BasicObject
+    FutureNotReady = ::Redis::FutureNotReady.new
+
+    def initialize(command, transformation)
+      @command = command
+      @transformation = transformation
+      @object = FutureNotReady
+    end
+
+    def inspect
+      "<Redis::Future #{@command.inspect}>"
+    end
+
+    def _set(object)
+      @object = @transformation ? @transformation.call(object) : object
+      value
+    end
+
+    def _command
+      @command
+    end
+
+    def value
+      ::Kernel.raise(@object) if @object.kind_of?(::Exception)
+      @object
+    end
   end
 end

data/lib/redis/subscribe.rb

@@ -4,25 +4,10 @@ class Redis
       @client = client
     end
 
-    # Starting with 2.2.1, assume that this method is called with a single
-    # array argument. Check its size for backwards compat.
-    def call(*args)
-      if args.first.is_a?(Array) && args.size == 1
-        command = args.first
-      else
-        command = args
-      end
-
+    def call(command)
       @client.process([command])
     end
 
-    # Assume that this method is called with a single array argument. No
-    # backwards compat here, since it was introduced in 2.2.2.
-    def call_without_reply(command)
-      @commands.push command
-      nil
-    end
-
     def subscribe(*channels, &block)
       subscription("subscribe", "unsubscribe", channels, block)
     end

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "2.2.2"
+  VERSION = "3.0.0.rc1"
 end

data/redis.gemspec

@@ -1,24 +1,43 @@
 # -*- encoding: utf-8 -*-
 
 $:.unshift File.expand_path("../lib", __FILE__)
+
 require "redis/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{redis}
+  s.name = "redis"
+
   s.version = Redis::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ezra Zygmuntowicz", "Taylor Weibley", "Matthew Clark", "Brian McKinney", "Salvatore Sanfilippo", "Luca Guidi", "Michel Martens", "Damian Janowski", "Pieter Noordhuis"]
-  s.autorequire = %q{redis}
-  s.description = %q{Ruby client library for Redis, the key value storage server}
-  s.summary = %q{Ruby client library for Redis, the key value storage server}
-  s.email = %q{ez@engineyard.com}
-  s.homepage = %q{http://github.com/ezmobius/redis-rb}
-  s.rubyforge_project = "redis-rb"
+  s.homepage = "https://github.com/ezmobius/redis-rb"
+
+  s.summary = "A Ruby client library for the Redis key-value store."
+
+  s.description = <<-EOS
+    A simple Ruby client trying to match Redis' API one-to-one while still providing a Rubystic interface.
+    It features thread safety, client-side sharding, and an obsession for performance.
+  EOS
+
+  s.authors = [
+    "Ezra Zygmuntowicz",
+    "Taylor Weibley",
+    "Matthew Clark",
+    "Brian McKinney",
+    "Salvatore Sanfilippo",
+    "Luca Guidi",
+    "Michel Martens",
+    "Damian Janowski",
+    "Pieter Noordhuis"
+  ]
+
+  s.email = ["redis-db@googlegroups.com"]
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
+
+  s.add_development_dependency("rake")
+  s.add_development_dependency("cutest")
+  s.add_development_dependency("hiredis")
+  s.add_development_dependency("em-synchrony")
 end

data/test/command_map_test.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "Override existing commands" do |r|
+  r.set("counter", 1)
+
+  assert 2 == r.incr("counter")
+
+  r.client.command_map[:incr] = :decr
+
+  assert 1 == r.incr("counter")
+end
+
+test "Override non-existing commands" do |r|
+  r.set("key", "value")
+
+  assert_raise Redis::CommandError do
+    r.idontexist("key")
+  end
+
+  r.client.command_map[:idontexist] = :get
+
+  assert "value" == r.idontexist("key")
+end

data/test/commands_on_hashes_test.rb

@@ -8,13 +8,13 @@ end
 
 load './test/lint/hashes.rb'
 
-test "Mapped HMGET in a pipeline returns plain array" do |r|
+test "Mapped HMGET in a pipeline returns hash" do |r|
   r.hset("foo", "f1", "s1")
   r.hset("foo", "f2", "s2")
 
   result = r.pipelined do
-    assert nil == r.mapped_hmget("foo", "f1", "f2")
+    r.mapped_hmget("foo", "f1", "f2")
   end
 
-  assert result[0] == ["s1", "s2"]
+  assert result[0] == { "f1" => "s1", "f2" => "s2" }
 end

data/test/commands_on_lists_test.rb

@@ -33,7 +33,7 @@ test "LINSERT" do |r|
 
   assert ["s1", "s2", "s3"] == r.lrange("foo", 0, -1)
 
-  assert_raise(RuntimeError) do
+  assert_raise(Redis::CommandError) do
     r.linsert "foo", :anywhere, "s3", "s2"
   end
 end

data/test/commands_on_sets_test.rb

@@ -74,5 +74,3 @@ test "SDIFFSTORE" do |r|
 
   assert ["s1"] == r.smembers("baz")
 end
-
-

data/test/commands_on_sorted_sets_test.rb

@@ -79,8 +79,8 @@ test "ZINTERSTORE with WEIGHTS" do |r|
   assert 2 == r.zinterstore("foobar", ["foo", "bar"], :weights => [10, 1])
   assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
 
-  assert "40" == r.zscore("foobar", "s2")
-  assert "60" == r.zscore("foobar", "s3")
+  assert 40.0 == r.zscore("foobar", "s2")
+  assert 60.0 == r.zscore("foobar", "s3")
 end
 
 test "ZINTERSTORE with AGGREGATE" do |r|
@@ -93,17 +93,16 @@ test "ZINTERSTORE with AGGREGATE" do |r|
 
   assert 2 == r.zinterstore("foobar", ["foo", "bar"])
   assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-  assert "22" == r.zscore("foobar", "s2")
-  assert "33" == r.zscore("foobar", "s3")
+  assert 22.0 == r.zscore("foobar", "s2")
+  assert 33.0 == r.zscore("foobar", "s3")
 
   assert 2 == r.zinterstore("foobar", ["foo", "bar"], :aggregate => :min)
   assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-  assert "2" == r.zscore("foobar", "s2")
-  assert "3" == r.zscore("foobar", "s3")
+  assert 2.0 == r.zscore("foobar", "s2")
+  assert 3.0 == r.zscore("foobar", "s3")
 
   assert 2 == r.zinterstore("foobar", ["foo", "bar"], :aggregate => :max)
   assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-  assert "20" == r.zscore("foobar", "s2")
-  assert "30" == r.zscore("foobar", "s3")
+  assert 20.0 == r.zscore("foobar", "s2")
+  assert 30.0 == r.zscore("foobar", "s3")
 end
-

data/test/commands_on_strings_test.rb

@@ -32,15 +32,15 @@ test "MGET mapped" do |r|
   assert nil  == response["baz"]
 end
 
-test "Mapped MGET in a pipeline returns plain array" do |r|
+test "Mapped MGET in a pipeline returns hash" do |r|
   r.set("foo", "s1")
   r.set("bar", "s2")
 
   result = r.pipelined do
-    assert nil == r.mapped_mget("foo", "bar")
+    r.mapped_mget("foo", "bar")
   end
 
-  assert result[0] == ["s1", "s2"]
+  assert result[0] == { "foo" => "s1", "bar" => "s2" }
 end
 
 test "MSET" do |r|

data/test/commands_on_value_types_test.rb

@@ -85,4 +85,3 @@ test "FLUSHALL" do
     assert "FLUSHALL" == redis.flushall
   end
 end
-

data/test/connection_handling_test.rb

@@ -44,7 +44,11 @@ test "QUIT" do |r|
 end
 
 test "SHUTDOWN" do
-  redis_mock(:shutdown => lambda { "+SHUTDOWN" }) do
+  commands = {
+    :shutdown => lambda { :exit }
+  }
+
+  redis_mock(commands) do
     redis = Redis.new(OPTIONS.merge(:port => 6380))
 
     # SHUTDOWN does not reply: test that it does not raise here.
@@ -52,6 +56,117 @@ test "SHUTDOWN" do
   end
 end
 
+test "SHUTDOWN with error" do
+  connections = 0
+  commands = {
+    :select => lambda { |*_| connections += 1; "+OK\r\n" },
+    :connections => lambda { ":#{connections}\r\n" },
+    :shutdown => lambda { "-ERR could not shutdown\r\n" }
+  }
+
+  redis_mock(commands) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    connections = redis.connections
+
+    # SHUTDOWN replies with an error: test that it gets raised
+    assert_raise Redis::CommandError do
+      redis.shutdown
+    end
+
+    # The connection should remain in tact
+    assert connections == redis.connections
+  end
+end
+
+test "SHUTDOWN from pipeline" do
+  commands = {
+    :shutdown => lambda { :exit }
+  }
+
+  redis_mock(commands) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    result = redis.pipelined do
+      redis.shutdown
+    end
+
+    assert nil == result
+    assert !redis.client.connected?
+  end
+end
+
+test "SHUTDOWN with error from pipeline" do
+  connections = 0
+  commands = {
+    :select => lambda { |*_| connections += 1; "+OK\r\n" },
+    :connections => lambda { ":#{connections}\r\n" },
+    :shutdown => lambda { "-ERR could not shutdown\r\n" }
+  }
+
+  redis_mock(commands) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    connections = redis.connections
+
+    # SHUTDOWN replies with an error: test that it gets raised
+    assert_raise Redis::CommandError do
+      redis.pipelined do
+        redis.shutdown
+      end
+    end
+
+    # The connection should remain in tact
+    assert connections == redis.connections
+  end
+end
+
+test "SHUTDOWN from MULTI/EXEC" do
+  commands = {
+    :multi => lambda { "+OK\r\n" },
+    :shutdown => lambda { "+QUEUED\r\n" },
+    :exec => lambda { :exit }
+  }
+
+  redis_mock(commands) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    result = redis.multi do
+      redis.shutdown
+    end
+
+    assert nil == result
+    assert !redis.client.connected?
+  end
+end
+
+test "SHUTDOWN with error from MULTI/EXEC" do
+  connections = 0
+  commands = {
+    :select => lambda { |*_| connections += 1; "+OK\r\n" },
+    :connections => lambda { ":#{connections}\r\n" },
+    :multi => lambda { "+OK\r\n" },
+    :shutdown => lambda { "+QUEUED\r\n" },
+    :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" }
+  }
+
+  redis_mock(commands) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    connections = redis.connections
+
+    # SHUTDOWN replies with an error: test that it gets returned
+    # We should test for Redis::CommandError here, but hiredis doesn't yet do
+    # custom error classes.
+    assert_raise(StandardError) do
+      redis.multi { redis.shutdown }
+    end
+
+    # The connection should remain intact
+    assert connections == redis.connections
+  end
+end
+
 test "SLAVEOF" do
   redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do
     redis = Redis.new(OPTIONS.merge(:port => 6380))
@@ -69,9 +184,11 @@ test "BGREWRITEAOF" do
 end
 
 test "CONFIG GET" do |r|
-  assert "300" == r.config(:get, "*")["timeout"]
+  assert r.config(:get, "*")["timeout"] != nil
 
-  assert r.config(:get, "timeout") == { "timeout" => "300" }
+  config = r.config(:get, "timeout")
+  assert ["timeout"] == config.keys
+  assert config.values.compact.size > 0
 end
 
 test "CONFIG SET" do |r|
@@ -85,4 +202,3 @@ test "CONFIG SET" do |r|
     r.config :set, "timeout", 300
   end
 end
-