redis 3.3.5 → 4.0.0.rc1

data/lib/redis/hash_ring.rb

@@ -1,132 +0,0 @@
-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}")
-        raise "Node ID collision" if @ring.has_key?(key)
-        @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
-
-    class << self
-
-      # gem install RubyInline to use this code
-      # Native extension to perform the binary search within the hashring.
-      # There's a pure ruby version below so this is purely optional
-      # for performance.  In testing 20k gets and sets, the native
-      # binary search shaved about 12% off the runtime (9sec -> 8sec).
-      begin
-        require 'inline'
-        inline do |builder|
-          builder.c <<-EOM
-          int binary_search(VALUE ary, unsigned int r) {
-              int upper = RARRAY_LEN(ary) - 1;
-              int lower = 0;
-              int idx = 0;
-
-              while (lower <= upper) {
-                  idx = (lower + upper) / 2;
-
-                  VALUE continuumValue = RARRAY_PTR(ary)[idx];
-                  unsigned int l = NUM2UINT(continuumValue);
-                  if (l == r) {
-                      return idx;
-                  }
-                  else if (l > r) {
-                      upper = idx - 1;
-                  }
-                  else {
-                      lower = idx + 1;
-                  }
-              }
-              if (upper < 0) {
-                upper = RARRAY_LEN(ary) - 1;
-              }
-              return upper;
-          }
-          EOM
-        end
-      rescue Exception
-        # Find the closest index in HashRing with value <= the given value
-        def 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
-
-  end
-end

data/test/connection_test.rb

@@ -1,57 +0,0 @@
-require_relative "helper"
-
-class TestConnection < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_provides_a_meaningful_inspect
-    assert_equal "#<Redis client v#{Redis::VERSION} for redis://127.0.0.1:#{PORT}/15>", r.inspect
-  end
-
-  def test_connection_information
-    assert_equal "127.0.0.1",                 r.connection.fetch(:host)
-    assert_equal 6381,                        r.connection.fetch(:port)
-    assert_equal 15,                          r.connection.fetch(:db)
-    assert_equal "127.0.0.1:6381",            r.connection.fetch(:location)
-    assert_equal "redis://127.0.0.1:6381/15", r.connection.fetch(:id)
-  end
-
-  def test_default_id_with_host_and_port
-    redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0))
-    assert_equal "redis://host:1234/0", redis.connection.fetch(:id)
-  end
-
-  def test_default_id_with_host_and_port_and_explicit_scheme
-    redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0, :scheme => "foo"))
-    assert_equal "redis://host:1234/0", redis.connection.fetch(:id)
-  end
-
-  def test_default_id_with_path
-    redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0))
-    assert_equal "redis:///tmp/redis.sock/0", redis.connection.fetch(:id)
-  end
-
-  def test_default_id_with_path_and_explicit_scheme
-    redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0, :scheme => "foo"))
-    assert_equal "redis:///tmp/redis.sock/0", redis.connection.fetch(:id)
-  end
-
-  def test_override_id
-    redis = Redis.new(OPTIONS.merge(:id => "test"))
-    assert_equal "test", redis.connection.fetch(:id)
-  end
-
-  def test_id_inside_multi
-    redis         = Redis.new(OPTIONS)
-    id            = nil
-    connection_id = nil
-
-    redis.multi do
-      id            = redis.id
-      connection_id = redis.connection.fetch(:id)
-    end
-
-    assert_equal "redis://127.0.0.1:6381/15", id
-    assert_equal "redis://127.0.0.1:6381/15", connection_id
-  end
-end

data/test/distributed_blocking_commands_test.rb

@@ -1,46 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/blocking_commands"
-
-class TestDistributedBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::BlockingCommands
-
-  def test_blpop_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.blpop(["foo", "bar"])
-    end
-  end
-
-  def test_blpop_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.blpop("foo", "bar", 0)
-    end
-  end
-
-  def test_brpop_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpop(["foo", "bar"])
-    end
-  end
-
-  def test_brpop_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpop("foo", "bar", 0)
-    end
-  end
-
-  def test_brpoplpush_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpoplpush("foo", "bar")
-    end
-  end
-
-  def test_brpoplpush_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpoplpush("foo", "bar", 0)
-    end
-  end
-end

data/test/distributed_commands_on_hashes_test.rb

@@ -1,10 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/hashes"
-
-class TestDistributedCommandsOnHashes < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Hashes
-end

data/test/distributed_commands_on_hyper_log_log_test.rb

@@ -1,33 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/hyper_log_log"
-
-class TestDistributedCommandsOnHyperLogLog < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::HyperLogLog
-
-  def test_pfmerge
-    target_version "2.8.9" do
-      assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd "foo", "s1"
-        r.pfadd "bar", "s2"
-
-        assert r.pfmerge("res", "foo", "bar")
-      end
-    end
-  end
-
-  def test_pfcount_multiple_keys_diff_nodes
-    target_version "2.8.9" do
-      assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd "foo", "s1"
-        r.pfadd "bar", "s2"
-
-        assert r.pfcount("res", "foo", "bar")
-      end
-    end
-  end
-
-end

data/test/distributed_commands_on_lists_test.rb

@@ -1,22 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/lists"
-
-class TestDistributedCommandsOnLists < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Lists
-
-  def test_rpoplpush
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.rpoplpush("foo", "bar")
-    end
-  end
-
-  def test_brpoplpush
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.brpoplpush("foo", "bar", :timeout => 1)
-    end
-  end
-end

data/test/distributed_commands_on_sets_test.rb

@@ -1,83 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/sets"
-
-class TestDistributedCommandsOnSets < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Sets
-
-  def test_smove
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "bar", "s2"
-
-      r.smove("foo", "bar", "s1")
-    end
-  end
-
-  def test_sinter
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-
-      r.sinter("foo", "bar")
-    end
-  end
-
-  def test_sinterstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-
-      r.sinterstore("baz", "foo", "bar")
-    end
-  end
-
-  def test_sunion
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sunion("foo", "bar")
-    end
-  end
-
-  def test_sunionstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sunionstore("baz", "foo", "bar")
-    end
-  end
-
-  def test_sdiff
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sdiff("foo", "bar")
-    end
-  end
-
-  def test_sdiffstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sdiffstore("baz", "foo", "bar")
-    end
-  end
-end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -1,18 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/sorted_sets"
-
-class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::SortedSets
-
-  def test_zcount
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
-
-    assert_equal 2, r.zcount("foo", 2, 3)
-  end
-end

data/test/distributed_commands_on_strings_test.rb

@@ -1,59 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/strings"
-
-class TestDistributedCommandsOnStrings < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Strings
-
-  def test_mget
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mget("foo", "bar")
-    end
-  end
-
-  def test_mget_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mapped_mget("foo", "bar")
-    end
-  end
-
-  def test_mset
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mset(:foo, "s1", :bar, "s2")
-    end
-  end
-
-  def test_mset_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mapped_mset(:foo => "s1", :bar => "s2")
-    end
-  end
-
-  def test_msetnx
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.msetnx(:foo, "s2", :bar, "s3")
-    end
-  end
-
-  def test_msetnx_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.mapped_msetnx(:foo => "s2", :bar => "s3")
-    end
-  end
-
-  def test_bitop
-    target_version "2.5.10" do
-      assert_raise Redis::Distributed::CannotDistribute do
-        r.set("foo", "a")
-        r.set("bar", "b")
-
-        r.bitop(:and, "foo&bar", "foo", "bar")
-      end
-    end
-  end
-end