redis 4.0.0.rc1 → 4.0.0

data/lib/redis/hash_ring.rb

@@ -0,0 +1,88 @@
+require 'zlib'
+
+class Redis
+  class HashRing
+
+    POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+    attr_reader :ring, :sorted_keys, :replicas, :nodes
+
+    # nodes is a list of objects that have a proper to_s representation.
+    # replicas indicates how many virtual points should be used pr. node,
+    # replicas are required to improve the distribution.
+    def initialize(nodes=[], replicas=POINTS_PER_SERVER)
+      @replicas = replicas
+      @ring = {}
+      @nodes = []
+      @sorted_keys = []
+      nodes.each do |node|
+        add_node(node)
+      end
+    end
+
+    # Adds a `node` to the hash ring (including a number of replicas).
+    def add_node(node)
+      @nodes << node
+      @replicas.times do |i|
+        key = Zlib.crc32("#{node.id}:#{i}")
+        @ring[key] = node
+        @sorted_keys << key
+      end
+      @sorted_keys.sort!
+    end
+
+    def remove_node(node)
+      @nodes.reject!{|n| n.id == node.id}
+      @replicas.times do |i|
+        key = Zlib.crc32("#{node.id}:#{i}")
+        @ring.delete(key)
+        @sorted_keys.reject! {|k| k == key}
+      end
+    end
+
+    # get the node in the hash ring for this key
+    def get_node(key)
+      get_node_pos(key)[0]
+    end
+
+    def get_node_pos(key)
+      return [nil,nil] if @ring.size == 0
+      crc = Zlib.crc32(key)
+      idx = HashRing.binary_search(@sorted_keys, crc)
+      return [@ring[@sorted_keys[idx]], idx]
+    end
+
+    def iter_nodes(key)
+      return [nil,nil] if @ring.size == 0
+      _, pos = get_node_pos(key)
+      @ring.size.times do |n|
+        yield @ring[@sorted_keys[(pos+n) % @ring.size]]
+      end
+    end
+
+    # Find the closest index in HashRing with value <= the given value
+    def self.binary_search(ary, value, &block)
+      upper = ary.size - 1
+      lower = 0
+      idx = 0
+
+      while(lower <= upper) do
+        idx = (lower + upper) / 2
+        comp = ary[idx] <=> value
+
+        if comp == 0
+          return idx
+        elsif comp > 0
+          upper = idx - 1
+        else
+          lower = idx + 1
+        end
+      end
+
+      if upper < 0
+        upper = ary.size - 1
+      end
+      return upper
+    end
+  end
+end

data/lib/redis/version.rb

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

data/redis.gemspec

@@ -34,7 +34,9 @@ Gem::Specification.new do |s|
   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.add_development_dependency("test-unit", "3.1.5")
+  s.required_ruby_version = '>= 2.2.2'
+
+  s.add_development_dependency("test-unit", ">= 3.1.5")
   s.add_development_dependency("hiredis")
   s.add_development_dependency("em-synchrony")
 end

data/test/blocking_commands_test.rb

@@ -1,153 +1,10 @@
 require_relative "helper"
+require_relative "lint/blocking_commands"
 
 class TestBlockingCommands < Test::Unit::TestCase
 
   include Helper::Client
-
-  def setup
-    super
-
-    r.rpush("{zap}foo", "s1")
-    r.rpush("{zap}foo", "s2")
-    r.rpush("{zap}bar", "s1")
-    r.rpush("{zap}bar", "s2")
-  end
-
-  def to_protocol(obj)
-    case obj
-    when String
-      "$#{obj.length}\r\n#{obj}\r\n"
-    when Array
-      "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
-    else
-      fail
-    end
-  end
-
-  def mock(options = {}, &blk)
-    commands = {
-      :blpop => lambda do |*args|
-        sleep options[:delay] if options.has_key?(:delay)
-        to_protocol([args.first, args.last])
-      end,
-      :brpop => lambda do |*args|
-        sleep options[:delay] if options.has_key?(:delay)
-        to_protocol([args.first, args.last])
-      end,
-      :brpoplpush => lambda do |*args|
-        sleep options[:delay] if options.has_key?(:delay)
-        to_protocol(args.last)
-      end
-    }
-
-    redis_mock(commands, &blk)
-  end
-
-  def test_blpop
-    assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo")
-    assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"])
-    assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"])
-    assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"])
-  end
-
-  def test_blpop_timeout
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo")
-      assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1)
-    end
-  end
-
-  def test_blpop_with_old_prototype
-    assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0)
-    assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0)
-    assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0)
-    assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0)
-  end
-
-  def test_blpop_timeout_with_old_prototype
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0)
-      assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1)
-    end
-  end
-
-  def test_brpop
-    assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo")
-    assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"])
-    assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"])
-    assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"])
-  end
-
-  def test_brpop_timeout
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo")
-      assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1)
-    end
-  end
-
-  def test_brpop_with_old_prototype
-    assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0)
-    assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0)
-    assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0)
-    assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0)
-  end
-
-  def test_brpop_timeout_with_old_prototype
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0)
-      assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1)
-    end
-  end
-
-  def test_brpoplpush
-    assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux")
-    assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
-  end
-
-  def test_brpoplpush_timeout
-    mock do |r|
-      assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar")
-      assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
-    end
-  end
-
-  def test_brpoplpush_with_old_prototype
-    assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0)
-    assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
-  end
-
-  def test_brpoplpush_timeout_with_old_prototype
-    mock do |r|
-      assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0)
-      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
+  include Lint::BlockingCommands
 
   def assert_takes_longer_than_client_timeout
     timeout = OPTIONS[:timeout]

data/test/commands_on_hashes_test.rb

@@ -1,165 +1,10 @@
 require_relative "helper"
+require_relative "lint/hashes"
 
 class TestCommandsOnHashes < Test::Unit::TestCase
 
   include Helper::Client
-
-  def test_hset_and_hget
-    r.hset("foo", "f1", "s1")
-
-    assert_equal "s1", r.hget("foo", "f1")
-  end
-
-  def test_hsetnx
-    r.hset("foo", "f1", "s1")
-    r.hsetnx("foo", "f1", "s2")
-
-    assert_equal "s1", r.hget("foo", "f1")
-
-    r.del("foo")
-    r.hsetnx("foo", "f1", "s2")
-
-    assert_equal "s2", r.hget("foo", "f1")
-  end
-
-  def test_hdel
-    r.hset("foo", "f1", "s1")
-
-    assert_equal "s1", r.hget("foo", "f1")
-
-    assert_equal 1, r.hdel("foo", "f1")
-
-    assert_equal nil, r.hget("foo", "f1")
-  end
-
-  def test_variadic_hdel
-    target_version "2.3.9" do
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-
-      assert_equal "s1", r.hget("foo", "f1")
-      assert_equal "s2", r.hget("foo", "f2")
-
-      assert_equal 2, r.hdel("foo", ["f1", "f2"])
-
-      assert_equal nil, r.hget("foo", "f1")
-      assert_equal nil, r.hget("foo", "f2")
-    end
-  end
-
-  def test_hexists
-    assert_equal false, r.hexists("foo", "f1")
-
-    r.hset("foo", "f1", "s1")
-
-    assert r.hexists("foo", "f1")
-  end
-
-  def test_hlen
-    assert_equal 0, r.hlen("foo")
-
-    r.hset("foo", "f1", "s1")
-
-    assert_equal 1, r.hlen("foo")
-
-    r.hset("foo", "f2", "s2")
-
-    assert_equal 2, r.hlen("foo")
-  end
-
-  def test_hkeys
-    assert_equal [], r.hkeys("foo")
-
-    r.hset("foo", "f1", "s1")
-    r.hset("foo", "f2", "s2")
-
-    assert_equal ["f1", "f2"], r.hkeys("foo")
-  end
-
-  def test_hvals
-    assert_equal [], r.hvals("foo")
-
-    r.hset("foo", "f1", "s1")
-    r.hset("foo", "f2", "s2")
-
-    assert_equal ["s1", "s2"], r.hvals("foo")
-  end
-
-  def test_hgetall
-    assert({} == r.hgetall("foo"))
-
-    r.hset("foo", "f1", "s1")
-    r.hset("foo", "f2", "s2")
-
-    assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
-  end
-
-  def test_hmset
-    r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
-
-    assert_equal "bar1", r.hget("hash", "foo1")
-    assert_equal "bar2", r.hget("hash", "foo2")
-  end
-
-  def test_hmset_with_invalid_arguments
-    assert_raise(Redis::CommandError) do
-      r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
-    end
-  end
-
-  def test_mapped_hmset
-    r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
-
-    assert_equal "s1", r.hget("foo", "f1")
-    assert_equal "s2", r.hget("foo", "f2")
-  end
-
-  def test_hmget
-    r.hset("foo", "f1", "s1")
-    r.hset("foo", "f2", "s2")
-    r.hset("foo", "f3", "s3")
-
-    assert_equal ["s2", "s3"], r.hmget("foo", "f2", "f3")
-  end
-
-  def test_hmget_mapped
-    r.hset("foo", "f1", "s1")
-    r.hset("foo", "f2", "s2")
-    r.hset("foo", "f3", "s3")
-
-    assert({"f1" => "s1"} == r.mapped_hmget("foo", "f1"))
-    assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2"))
-  end
-
-  def test_hincrby
-    r.hincrby("foo", "f1", 1)
-
-    assert_equal "1", r.hget("foo", "f1")
-
-    r.hincrby("foo", "f1", 2)
-
-    assert_equal "3", r.hget("foo", "f1")
-
-    r.hincrby("foo", "f1", -1)
-
-    assert_equal "2", r.hget("foo", "f1")
-  end
-
-  def test_hincrbyfloat
-    target_version "2.5.4" do
-      r.hincrbyfloat("foo", "f1", 1.23)
-
-      assert_equal "1.23", r.hget("foo", "f1")
-
-      r.hincrbyfloat("foo", "f1", 0.77)
-
-      assert_equal "2", r.hget("foo", "f1")
-
-      r.hincrbyfloat("foo", "f1", -0.1)
-
-      assert_equal "1.9", r.hget("foo", "f1")
-    end
-  end
+  include Lint::Hashes
 
   def test_mapped_hmget_in_a_pipeline_returns_hash
     r.hset("foo", "f1", "s1")

data/test/commands_on_hyper_log_log_test.rb

@@ -1,61 +1,10 @@
 require_relative "helper"
+require_relative "lint/hyper_log_log"
 
 class TestCommandsOnHyperLogLog < Test::Unit::TestCase
 
   include Helper::Client
-
-  def test_pfadd
-    target_version "2.8.9" do
-      assert_equal true, r.pfadd("foo", "s1")
-      assert_equal true, r.pfadd("foo", "s2")
-      assert_equal false, r.pfadd("foo", "s1")
-
-      assert_equal 2, r.pfcount("foo")
-    end
-  end
-
-  def test_variadic_pfadd
-    target_version "2.8.9" do
-      assert_equal true, r.pfadd("foo", ["s1", "s2"])
-      assert_equal true, r.pfadd("foo", ["s1", "s2", "s3"])
-
-      assert_equal 3, r.pfcount("foo")
-    end
-  end
-
-  def test_pfcount
-    target_version "2.8.9" do
-      assert_equal 0, r.pfcount("foo")
-
-      assert_equal true, r.pfadd("foo", "s1")
-
-      assert_equal 1, r.pfcount("foo")
-    end
-  end
-
-  def test_variadic_pfcount
-    target_version "2.8.9" do
-      assert_equal 0, r.pfcount(["{1}foo", "{1}bar"])
-
-      assert_equal true, r.pfadd("{1}foo", "s1")
-      assert_equal true, r.pfadd("{1}bar", "s1")
-      assert_equal true, r.pfadd("{1}bar", "s2")
-
-      assert_equal 2, r.pfcount("{1}foo", "{1}bar")
-    end
-  end
-
-  def test_variadic_pfcount_expanded
-    target_version "2.8.9" do
-      assert_equal 0, r.pfcount("{1}foo", "{1}bar")
-
-      assert_equal true, r.pfadd("{1}foo", "s1")
-      assert_equal true, r.pfadd("{1}bar", "s1")
-      assert_equal true, r.pfadd("{1}bar", "s2")
-
-      assert_equal 2, r.pfcount("{1}foo", "{1}bar")
-    end
-  end
+  include Lint::HyperLogLog
 
   def test_pfmerge
     target_version "2.8.9" do