consistent-hashing 0.0.1 → 0.1.0

data/History.txt

@@ -1,3 +1,9 @@
+== 0.1.0 / 2012-04-15
+
+* introduced the VirtualPoint class
+* nodes can now consist of arbitrary data
+* added methods to get all nodes and all virtual points on the hash ring
+
 == 0.0.1 / 2012-04-15
 
 * Birthday!

data/README.md

@@ -7,11 +7,14 @@ Features
 --------
 
 * set number of replicas to create multiple virtual points in the ring for each node
+* nodes can be arbitrary data (e.g. a Memcache client instance)
 
 Examples
 --------
 
 ```ruby
+require 'consistent_hashing'
+
 ring = ConsistentHashing::Ring.new
 ring << "192.168.1.101" << "192.168.1.102"
 
@@ -21,6 +24,9 @@ ring.delete("192.168.1.101")
 # after removing 192.168.1.101, all keys previously mapped to it move clockwise to
 # the next node
 ring.node_for("foobar") # => 192.168.1.102
+
+ring.nodes # => ["192.168.1.101", "192.168.1.102"]
+ring.points # => [#<ConsistentHashing::VirtualPoint>, #<ConsistentHashing::VirtualPoint>, ...]
 ```
 
 Install

data/lib/consistent_hashing.rb

@@ -8,6 +8,7 @@ module ConsistentHashing
   # Internal: loads all necessary lib files
   #
   def self.load_lib
+    require File.join(LIBPATH, 'consistent_hashing', 'virtual_point')
     require File.join(LIBPATH, 'consistent_hashing', 'ring')
   end
 end

data/lib/consistent_hashing/ring.rb

@@ -1,8 +1,11 @@
 require 'digest/md5'
+require 'set'
 
 module ConsistentHashing
+
+  # Public: the hash ring containing all configured nodes
+  #
   class Ring
-    attr_reader :ring
 
     # Public: returns a new ring object
     def initialize(nodes = [], replicas = 3)
@@ -27,7 +30,7 @@ module ConsistentHashing
         # generate the key of this (virtual) point in the hash
         key = hash_key(node, i)
 
-        @ring[key] = node
+        @ring[key] = VirtualPoint.new(node, key)
         @sorted_keys << key
       end
 
@@ -50,19 +53,41 @@ module ConsistentHashing
       self
     end
 
-    # Public: gets the node for an arbitrary key
+    # Public: gets the point for an arbitrary key
     #
     #
-    def node_for(key)
-      return [nil, 0] if @ring.empty?
+    def point_for(key)
+      return nil if @ring.empty?
 
       key = hash_key(key)
 
       @sorted_keys.each do |i|
-        return [@ring[i], i] if key <= i
+        return @ring[i] if key <= i
       end
 
-      [@ring[@sorted_keys[0]], 0]
+      @ring[@sorted_keys[0]]
+    end
+
+    # Public: gets the node where to store the key
+    #
+    # Returns: the node Object
+    def node_for(key)
+      point_for(key).node
+    end
+
+    # Public: get all nodes in the ring
+    #
+    # Returns: an Array of the nodes in the ring
+    def nodes
+      nodes = points.map { |point| point.node }
+      nodes.uniq
+    end
+
+    # Public: gets all points in the ring
+    #
+    # Returns: an Array of the points in the ring
+    def points
+      @ring.map { |point| point[1] }
     end
 
     protected

data/lib/consistent_hashing/virtual_point.rb

@@ -0,0 +1,18 @@
+module ConsistentHashing
+
+  # Public: represents a virtual point on the hash ring
+  #
+  class VirtualPoint
+    attr_reader :node, :index
+
+    def initialize(node, index)
+      @node = node
+      @index = index.to_i
+    end
+
+    # Public: set a new index for the virtual point. Useful if the point gets duplicated
+    def index=(index)
+      @index = index.to_i
+    end
+  end
+end

data/test/consistent_hashing/test_ring.rb

@@ -26,23 +26,59 @@ class TestRing < ConsistentHashing::TestCase
   end
 
   def test_get_node
-    assert_equal "A", @ring.node_for(@examples["A"])[0]
-    assert_equal "B", @ring.node_for(@examples["B"])[0]
-    assert_equal "C", @ring.node_for(@examples["C"])[0]
+    assert_equal "A", @ring.point_for(@examples["A"]).node
+    assert_equal "B", @ring.point_for(@examples["B"]).node
+    assert_equal "C", @ring.point_for(@examples["C"]).node
   end
 
   # should fall back to the first node, if key > last node
   def test_get_node_fallback_to_first
     ring = ConsistentHashing::Ring.new ["A"], 1
 
-    assert_equal "A", ring.node_for(@examples["not_found"])[0]
-    assert_equal 0, ring.node_for(@examples["not_found"])[1]
+    point = ring.point_for(@examples["not_found"])
+
+    assert_equal "A", point.node
+    assert_not_equal 0, point.index
   end
 
   # if I remove node C, all keys previously mapped to C should be moved clockwise to
   # the next node. That's a virtual point of B here
   def test_remove_node
     @ring.delete("C")
-    assert_equal "B", @ring.node_for(@examples["C"])[0]
+    assert_equal "B", @ring.point_for(@examples["C"]).node
+  end
+
+  def test_point_for
+    assert_equal "C", @ring.node_for(@examples["C"])
+  end
+
+  def test_arbitrary_node_data
+    nodes = [
+      {"host" => "192.168.1.101"},
+      {"host" => "192.168.1.102"},
+      {"host" => "192.168.1.103"}
+    ]
+
+    ring = ConsistentHashing::Ring.new(nodes)
+    assert_equal 9, ring.length
+
+    ring_nodes = ring.nodes
+    assert_equal 3, ring_nodes.length
+    assert_equal "192.168.1.102", ring_nodes[1]['host']
+  end
+
+  def test_points
+    nodes = [
+      {"host" => "192.168.1.101"},
+      {"host" => "192.168.1.102"},
+      {"host" => "192.168.1.103"}
+    ]
+
+    ring = ConsistentHashing::Ring.new(nodes)
+    points = ring.points
+
+    assert_equal 9, points.length
+    assert_not_equal 0, points[0].index
+    assert_equal "192.168.1.101", points[0].node['host']
   end
 end

data/test/consistent_hashing/test_virtual_point.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), %w{ .. test_consistent_hashing})
+
+class TestVirtualPoint < ConsistentHashing::TestCase
+  def setup
+    @node = {'host' => '192.168.1.101'}
+    @point = ConsistentHashing::VirtualPoint.new(@node, "1")
+  end
+
+  def test_init
+    assert_equal @node, @point.node
+    assert_equal 1, @point.index
+  end
+
+  def test_set_index
+    @point.index = "2"
+    assert_equal 2, @point.index
+  end
+end

data/version.txt

@@ -1 +1 @@
-0.0.1
+0.1.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: consistent-hashing
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones
-  requirement: &70330988436160 !ruby/object:Gem::Requirement
+  requirement: &70147185310840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: 3.8.0
   type: :development
   prerelease: false
-  version_requirements: *70330988436160
+  version_requirements: *70147185310840
 description: A generic implementation of the Consistent Hashing algorithm.
 email: liebler.dominik@googlemail.com
 executables: []
@@ -35,7 +35,9 @@ files:
 - Rakefile
 - lib/consistent_hashing.rb
 - lib/consistent_hashing/ring.rb
+- lib/consistent_hashing/virtual_point.rb
 - test/consistent_hashing/test_ring.rb
+- test/consistent_hashing/test_virtual_point.rb
 - test/test_consistent_hashing.rb
 - version.txt
 homepage: https://github.com/domnikl/consistent-hashing
@@ -66,4 +68,5 @@ specification_version: 3
 summary: A generic implementation of the Consistent Hashing algorithm.
 test_files:
 - test/consistent_hashing/test_ring.rb
+- test/consistent_hashing/test_virtual_point.rb
 - test/test_consistent_hashing.rb