consistent-hashing 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+# RubyMine
+.idea
+*.gemspec
+
+# gem/bones
+announcement.txt
+coverage
+doc
+pkg

data/History.txt

@@ -0,0 +1,3 @@
+== 0.0.1 / 2012-04-15
+
+* Birthday!

data/README.md

@@ -0,0 +1,60 @@
+consistent-hashing
+==================
+
+A generic implementation of the Consistent Hashing algorithm.
+
+Features
+--------
+
+* set number of replicas to create multiple virtual points in the ring for each node
+
+Examples
+--------
+
+```ruby
+ring = ConsistentHashing::Ring.new
+ring << "192.168.1.101" << "192.168.1.102"
+
+ring.node_for("foobar") # => 192.168.1.101
+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
+```
+
+Install
+-------
+
+* `[sudo] gem install consistent-hashing`
+
+Author
+------
+
+Original author: Dominik Liebler <liebler.dominik@googlemail.com>
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2012 Dominik Liebler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+Bones {
+  name     'consistent-hashing'
+  authors  'Dominik Liebler'
+  email    'liebler.dominik@googlemail.com'
+  url      'https://github.com/domnikl/consistent-hashing'
+  ignore_file  '.gitignore'
+}

data/lib/consistent_hashing.rb

@@ -0,0 +1,15 @@
+# Main module
+#
+module ConsistentHashing
+  LIBPATH = ::File.expand_path('..', __FILE__) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  VERSION = ::File.read(PATH + 'version.txt').strip
+
+  # Internal: loads all necessary lib files
+  #
+  def self.load_lib
+    require File.join(LIBPATH, 'consistent_hashing', 'ring')
+  end
+end
+
+ConsistentHashing.load_lib

data/lib/consistent_hashing/ring.rb

@@ -0,0 +1,78 @@
+require 'digest/md5'
+
+module ConsistentHashing
+  class Ring
+    attr_reader :ring
+
+    # Public: returns a new ring object
+    def initialize(nodes = [], replicas = 3)
+      @replicas = replicas
+      @sorted_keys = []
+      @ring = Hash.new
+
+      nodes.each { |node| add(node) }
+    end
+
+    # Public: returns the (virtual) points in the hash ring
+    #
+    # Returns: a Fixnum
+    def length
+      @ring.length
+    end
+
+    # Public: adds a new node into the hash ring
+    #
+    def add(node)
+      @replicas.times do |i|
+        # generate the key of this (virtual) point in the hash
+        key = hash_key(node, i)
+
+        @ring[key] = node
+        @sorted_keys << key
+      end
+
+      @sorted_keys.sort!
+
+      self
+    end
+    alias :<< :add
+
+    # Public: removes a node from the hash ring
+    #
+    def delete(node)
+      @replicas.times do |i|
+        key = hash_key(node, i)
+
+        @ring.delete key
+        @sorted_keys.delete key
+      end
+
+      self
+    end
+
+    # Public: gets the node for an arbitrary key
+    #
+    #
+    def node_for(key)
+      return [nil, 0] if @ring.empty?
+
+      key = hash_key(key)
+
+      @sorted_keys.each do |i|
+        return [@ring[i], i] if key <= i
+      end
+
+      [@ring[@sorted_keys[0]], 0]
+    end
+
+    protected
+
+    # Internal: hashes the key
+    #
+    # Returns: a String
+    def hash_key(key, index = nil)
+      key = "#{key}:#{index}" if index
+      Digest::MD5.hexdigest(key.to_s)[0..16].hex
+    end
+  end
+end

data/test/consistent_hashing/test_ring.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), %w{ .. test_consistent_hashing})
+
+class TestRing < ConsistentHashing::TestCase
+  def setup
+    @ring = ConsistentHashing::Ring.new %w{A B C}
+
+    @examples = {
+      "A" => "foobar",
+      "B" => "123",
+      "C" => "baz",
+      "not_found" => 0
+    }
+  end
+
+  def test_init
+    ring = ConsistentHashing::Ring.new
+    assert_equal 0, ring.length
+  end
+
+  def test_length
+    ring = ConsistentHashing::Ring.new([], 3)
+    assert_equal 0, ring.length
+
+    ring << "A" << "B"
+    assert_equal 6, ring.length
+  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]
+  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]
+  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]
+  end
+end

data/test/test_consistent_hashing.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.join(File.dirname(__FILE__), %w{.. lib}))
+
+require 'simplecov'
+SimpleCov.start
+
+require 'consistent_hashing'
+require 'test/unit'
+
+module ConsistentHashing
+  class TestCase < Test::Unit::TestCase
+    def test_module
+      assert_not_nil ConsistentHashing::VERSION
+    end
+  end
+end

data/version.txt

@@ -0,0 +1 @@
+0.0.1

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: consistent-hashing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dominik Liebler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bones
+  requirement: &70330988436160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70330988436160
+description: A generic implementation of the Consistent Hashing algorithm.
+email: liebler.dominik@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- History.txt
+files:
+- .gitignore
+- History.txt
+- README.md
+- Rakefile
+- lib/consistent_hashing.rb
+- lib/consistent_hashing/ring.rb
+- test/consistent_hashing/test_ring.rb
+- test/test_consistent_hashing.rb
+- version.txt
+homepage: https://github.com/domnikl/consistent-hashing
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: consistent-hashing
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: A generic implementation of the Consistent Hashing algorithm.
+test_files:
+- test/consistent_hashing/test_ring.rb
+- test/test_consistent_hashing.rb