redis_ring_client 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+.rvmrc
+tags

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in redis_ring_client.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    redis_ring_client (0.0.1)
+      json
+      redis
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    json (1.5.1)
+    mocha (0.9.12)
+    redis (2.1.1)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  redis_ring_client!
+  rspec

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Adam Pohorecki, http://adam.pohorecki.pl/
+
+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,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  t.rspec_opts = ["--profile --color"]
+end

data/lib/redis_ring/client/operation_definitions.rb

@@ -0,0 +1,147 @@
+module RedisRing
+  module Client
+
+    class UnsupportedOperationError < StandardError; end
+    class MultiShardOperationError < UnsupportedOperationError; end
+
+    module OperationDefinitions
+
+      def self.included(klass)
+        klass.send(:include, InstanceMethods)
+        klass.send(:include, GatherOperations)
+        klass.extend(ClassMethods)
+      end
+
+      module GatherOperations
+
+        def last_result(array)
+          return array.last
+        end
+
+        def sum(array)
+          return array.reduce(:+)
+        end
+
+      end
+
+      module InstanceMethods
+
+        def single_key_operation(name, first_arg, *rest)
+          connection = connection_for_key(first_arg)
+          return connection.send(name, first_arg, *rest)
+        end
+
+        def scather_gather_operation(name, gather, *args, &block)
+          results = []
+          each_connection do |conn|
+            results << conn.send(name, *args, &block)
+          end
+          return send(gather, results)
+        end
+
+        def unsupported_operation(name)
+          raise UnsupportedOperationError.new("Operation #{name} is not supported by RedisRing!")
+        end
+
+        def random_shard_operation(name, *args, &block)
+          shard_no = rand(ring_meta_data.ring_size)
+          return connection_pool.connection(shard_no).send(name, *args, &block)
+        end
+
+        def single_connection_operation(name, keys, *args, &block)
+          shard_numbers = keys.map { |key| sharder.shard_for_key(key) }
+          unless shard_numbers.uniq.size == 1
+            raise MultiShardOperationError.new("Multi-shard atomic operations are not allowed. Try using {shard_secifier} suffix if you really need them. Operation: #{name}, Keys: #{keys.join(', ')}")
+          end
+          return connection_for_key(keys.first).send(name, *args, &block)
+        end
+
+      end
+
+      module ClassMethods
+
+        def single_key_operation(name)
+          self.class_eval <<-RUBY
+
+          def #{name}(key, *args)
+            return single_key_operation(:#{name}, key, *args)
+          end
+
+          RUBY
+        end
+
+        def scather_gather_operation(name, gather_function)
+          self.class_eval <<-RUBY
+
+          def #{name}(*args, &block)
+            return scather_gather_operation(:#{name}, :#{gather_function}, *args, &block)
+          end
+
+          RUBY
+        end
+
+        def unsupported_operation(name)
+          self.class_eval <<-RUBY
+
+            def #{name}(*args)
+              unsupported_operation(:#{name})
+            end
+
+          RUBY
+        end
+
+        def random_shard_operation(name)
+          self.class_eval <<-RUBY
+
+            def #{name}(*args, &block)
+              random_shard_operation(:#{name}, *args, &block)
+            end
+
+          RUBY
+        end
+
+        def multi_key_operation(name)
+          self.class_eval <<-RUBY
+
+            def #{name}(*keys, &block)
+              return single_connection_operation(:#{name}, keys, *keys, &block)
+            end
+
+          RUBY
+        end
+
+        def mapped_set_operation(name)
+          self.class_eval <<-RUBY
+
+            def #{name}(hash, &block)
+              return single_connection_operation(:#{name}, hash.keys, hash, &block)
+            end
+
+          RUBY
+        end
+
+        def regular_set_operation(name)
+          self.class_eval <<-RUBY
+
+            def #{name}(*keys_and_values, &block)
+              return single_connection_operation(:#{name}, Hash[*keys_and_values].keys, *keys_and_values, &block)
+            end
+
+          RUBY
+        end
+
+        def multi_zstore_operation(name)
+          self.class_eval <<-RUBY
+
+            def #{name}(destination, keys, options = {})
+              return single_connection_operation(:#{name}, [destination] + keys, destination, keys, options)
+            end
+
+          RUBY
+        end
+
+      end
+
+    end
+  end
+end

data/lib/redis_ring/client/ring_meta_data.rb

@@ -0,0 +1,72 @@
+module RedisRing
+  module Client
+
+    class UnknownShardError < StandardError; end
+
+    class RingMetaData
+
+      attr_reader :host, :port
+
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @loaded = false
+      end
+
+      def reload!
+        json = get_shards_json_string
+        hash = JSON.parse(json)
+
+        @ring_size = hash['count']
+        @shards = (0...@ring_size).map{|n| ShardMetaData.from_json(hash['shards'][n.to_s])}
+
+        @loaded = true
+      end
+
+      def ring_size
+        reload! if should_reload?
+
+        return @ring_size
+      end
+
+      def shard(shard_number)
+        reload! if should_reload?
+
+        unless shard_number >= 0 && shard_number < ring_size
+          raise UnknownShardError.new("Shard number invalid: #{shard_number}. Ring size: #{ring_size}")
+        end
+
+        return @shards[shard_number]
+      end
+
+      protected
+
+      def should_reload?
+        !@loaded
+      end
+
+      def get_shards_json_string
+        Net::HTTP.get(host, '/shards', port)
+      end
+
+    end
+
+    class ShardMetaData
+
+      attr_reader :host, :port, :status
+
+      def initialize(host, port, status)
+        @host = host
+        @port = port
+        @status = status
+      end
+
+      def self.from_json(hash)
+        new(hash['host'], hash['port'].to_i, hash['status'].to_sym)
+      end
+
+    end
+
+  end
+end
+

data/lib/redis_ring/client/ring_proxy.rb

@@ -0,0 +1,188 @@
+module RedisRing
+  module Client
+
+    class RingProxy
+
+      include OperationDefinitions
+
+      single_key_operation :[]
+      single_key_operation :[]=
+      single_key_operation :append
+      single_key_operation :decr
+      single_key_operation :decrby
+      single_key_operation :exists
+      single_key_operation :expire
+      single_key_operation :expireat
+      single_key_operation :get
+      single_key_operation :getset
+      single_key_operation :hdel
+      single_key_operation :hexists
+      single_key_operation :hget
+      single_key_operation :hgetall
+      single_key_operation :hincrby
+      single_key_operation :hkeys
+      single_key_operation :hlen
+      single_key_operation :hmget
+      single_key_operation :hmset
+      single_key_operation :hset
+      single_key_operation :hsetnx
+      single_key_operation :hvals
+      single_key_operation :incr
+      single_key_operation :incrby
+      single_key_operation :lindex
+      single_key_operation :linsert
+      single_key_operation :llen
+      single_key_operation :lpop
+      single_key_operation :lpush
+      single_key_operation :lpushx
+      single_key_operation :lrange
+      single_key_operation :lrem
+      single_key_operation :lset
+      single_key_operation :ltrim
+      single_key_operation :mapped_hmget
+      single_key_operation :mapped_hmset
+      single_key_operation :move
+      single_key_operation :persist
+      single_key_operation :publish
+      single_key_operation :rpop
+      single_key_operation :rpush
+      single_key_operation :rpushx
+      single_key_operation :sadd
+      single_key_operation :scard
+      single_key_operation :set
+      single_key_operation :setex
+      single_key_operation :setnx
+      single_key_operation :sismember
+      single_key_operation :smembers
+      single_key_operation :sort
+      single_key_operation :spop
+      single_key_operation :srandmember
+      single_key_operation :srem
+      single_key_operation :strlen
+      single_key_operation :substr
+      single_key_operation :ttl
+      single_key_operation :type
+      single_key_operation :zadd
+      single_key_operation :zcard
+      single_key_operation :zcount
+      single_key_operation :zincrby
+      single_key_operation :zrange
+      single_key_operation :zrangebyscore
+      single_key_operation :zrank
+      single_key_operation :zrem
+      single_key_operation :zremrangebyrank
+      single_key_operation :zremrangebyscore
+      single_key_operation :zrevrange
+      single_key_operation :zrevrank
+      single_key_operation :zscore
+
+      scather_gather_operation :auth, :last_result
+      scather_gather_operation :bgrewriteaof, :last_result
+      scather_gather_operation :bgsave, :last_result
+      scather_gather_operation :config, :last_result
+      scather_gather_operation :dbsize, :sum
+      scather_gather_operation :flushall, :last_result
+      scather_gather_operation :flushdb, :last_result
+      scather_gather_operation :keys, :sum
+      scather_gather_operation :quit, :last_result
+      scather_gather_operation :save, :last_result
+      scather_gather_operation :select, :last_result
+      scather_gather_operation :shutdown, :last_result
+
+      # it might be useful to combine those, but it would break the interface
+      unsupported_operation :info
+
+      # could be used in a single server, but it's complicated
+      # maybe a TODO for the future
+      unsupported_operation :multi
+      unsupported_operation :watch
+      unsupported_operation :unwatch
+      unsupported_operation :discard
+      unsupported_operation :exec
+      unsupported_operation :pipelined
+
+      # there's no good way to scather_gather this
+      unsupported_operation :monitor
+
+      # maybe max or min from the shards?
+      unsupported_operation :lastsave
+
+      unsupported_operation :debug
+
+      # no way to determine which shards they fall into
+      unsupported_operation :psubscribe
+      unsupported_operation :punsubscribe
+      unsupported_operation :subscribed?
+
+      unsupported_operation :sync
+      unsupported_operation :slaveof
+
+      random_shard_operation :echo
+      random_shard_operation :ping
+      random_shard_operation :randomkey
+
+      multi_key_operation :blpop
+      multi_key_operation :brpop
+      multi_key_operation :del
+      multi_key_operation :mapped_mget
+      multi_key_operation :mget
+      multi_key_operation :rename
+      multi_key_operation :renamenx
+      multi_key_operation :rpoplpush
+      multi_key_operation :sdiff
+      multi_key_operation :sdiffstore
+      multi_key_operation :sinter
+      multi_key_operation :sinterstore
+      multi_key_operation :subscribe
+      multi_key_operation :sunion
+      multi_key_operation :sunionstore
+      multi_key_operation :unsubscribe
+
+      mapped_set_operation :mapped_mset
+      mapped_set_operation :mapped_msetnx
+      regular_set_operation :mset
+      regular_set_operation :msetnx
+
+      multi_zstore_operation :zinterstore
+      multi_zstore_operation :zunionstore
+
+      def smove(source, destination, member)
+        return single_connection_operation(:smove, [source, destination], source, destination, member)
+      end
+
+      def initialize(opts = {})
+        @host = opts[:host] || 'localhost'
+        @port = opts[:port] || 6400
+        @db = opts[:db] || 0
+        @password = opts[:password]
+      end
+
+      def connection_for_key(key)
+        shard = sharder.shard_for_key(key)
+        return connection_pool.connection(shard)
+      end
+
+      def each_connection(&block)
+        ring_meta_data.ring_size.times do |shard_no|
+          block.call(connection_pool.connection(shard_no))
+        end
+      end
+
+      protected
+
+      def ring_meta_data
+        @ring_meta_data ||= RingMetaData.new(@host, @port)
+      end
+
+      def sharder
+        @sharder ||= Sharder.new(ring_meta_data)
+      end
+
+      def connection_pool
+        @connection_pool = ShardConnectionPool.new(ring_meta_data, @password, @db)
+      end
+
+    end
+
+  end
+end

data/lib/redis_ring/client/shard_connection_pool.rb

@@ -0,0 +1,33 @@
+module RedisRing
+  module Client
+
+    class ShardConnectionPool
+
+      attr_reader :metadata, :password, :db
+
+      def initialize(metadata, password, db)
+        @metadata = metadata
+        @password = password
+        @db = db
+        @connections = {}
+      end
+
+      def connection(shard_number)
+        @connections[shard_number] ||= new_connection_to_shard(shard_number)
+      end
+
+      protected
+
+      def new_connection_to_shard(shard_number)
+        shard_metadata = metadata.shard(shard_number)
+        new_connection(shard_metadata.host, shard_metadata.port, db, password)
+      end
+
+      def new_connection(host, port, db, password)
+        Redis.new(:host => host, :port => port, :db => db, :password => password)
+      end
+
+    end
+
+  end
+end

data/lib/redis_ring/client/sharder.rb

@@ -0,0 +1,30 @@
+module RedisRing
+  module Client
+
+    class Sharder
+
+      attr_reader :metadata
+
+      def initialize(metadata)
+        @metadata = metadata
+      end
+
+      def shard_for_key(key)
+        crc = Zlib.crc32(hashable_part(key.to_s))
+        return crc % metadata.ring_size
+      end
+
+      private
+
+      def hashable_part(key)
+        if key =~ /{([^}]*)}$/
+          return Regexp.last_match(1)
+        else
+          return key
+        end
+      end
+
+    end
+
+  end
+end

data/lib/redis_ring/client/version.rb

@@ -0,0 +1,5 @@
+module RedisRing
+  module Client
+    VERSION = "0.0.1"
+  end
+end

data/lib/redis_ring/client.rb

@@ -0,0 +1,10 @@
+require 'zlib'
+
+require 'redis'
+require 'json'
+
+require 'redis_ring/client/operation_definitions'
+require 'redis_ring/client/ring_proxy'
+require 'redis_ring/client/sharder'
+require 'redis_ring/client/ring_meta_data'
+require 'redis_ring/client/shard_connection_pool'

data/redis_ring_client.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis_ring/client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis_ring_client"
+  s.version     = RedisRing::Client::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Adam Pohorecki"]
+  s.email       = ["adam@pohorecki.pl"]
+  s.homepage    = "http://github.com/psyho/redis_ring_client"
+  s.summary     = %q{Client for RedisRing}
+  s.description = %q{The client counterpart to the RedisRing gem.}
+
+  s.rubyforge_project = "redis_ring_client"
+
+  s.add_dependency 'redis'
+  s.add_dependency 'json'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'mocha'
+
+  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"]
+end

data/spec/fakes/fake_ring_meta_data.rb

@@ -0,0 +1,15 @@
+class FakeRingMetaData
+
+  attr_accessor :ring_size
+  attr_accessor :shards
+
+  def initialize(ring_size)
+    @ring_size = ring_size
+    @shards = {}
+  end
+
+  def shard(shard_no)
+    return @shards[shard_no]
+  end
+
+end

data/spec/redis_ring/client/ring_meta_data_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe RedisRing::Client::RingMetaData do
+
+  def sample_shards_hash
+    {
+      :count => 10,
+      :shards => {
+        0 => {:host => '192.168.1.1', :port => 6401, :status => :running},
+        1 => {:host => '192.168.1.1', :port => 6402, :status => :running},
+        2 => {:host => '192.168.1.1', :port => 6403, :status => :running},
+        3 => {:host => '192.168.1.1', :port => 6404, :status => :running},
+        4 => {:host => '192.168.1.1', :port => 6405, :status => :running},
+        5 => {:host => '192.168.1.1', :port => 6406, :status => :running},
+        6 => {:host => '192.168.1.1', :port => 6407, :status => :running},
+        7 => {:host => '192.168.1.1', :port => 6408, :status => :running},
+        8 => {:host => '192.168.1.1', :port => 6409, :status => :running},
+        9 => {:host => '192.168.1.1', :port => 6410, :status => :running}
+      }
+    }
+  end
+
+  def sample_shard_json
+    sample_shards_hash.to_json
+  end
+
+  it "should download json lazily" do
+    @metadata = RedisRing::Client::RingMetaData.new('host', 666)
+
+    Net::HTTP.expects(:get).with('host', '/shards', 666).returns(sample_shard_json)
+
+    @metadata.ring_size.should == 10
+  end
+
+  context "with sample shards json" do
+    before(:each) do
+      Net::HTTP.stubs(:get => sample_shard_json)
+
+      @metadata = RedisRing::Client::RingMetaData.new('host', 666)
+    end
+
+    it "should have ring_size of 10" do
+      @metadata.ring_size.should == 10
+    end
+
+    it "should have 10 shards" do
+      10.times do |n|
+        @metadata.shard(n).host.should == '192.168.1.1'
+        @metadata.shard(n).port.should == 6401 + n
+        @metadata.shard(n).status.should == :running
+      end
+    end
+
+    it "should raise an exception when trying to acces unexisting shard metadata" do
+      lambda {
+        @metadata.shard(10)
+      }.should raise_exception(RedisRing::Client::UnknownShardError)
+    end
+  end
+end

data/spec/redis_ring/client/ring_proxy_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe RedisRing::Client::RingProxy do
+
+  def readable_params(params)
+    translated = params.map do |type, name|
+      case type
+      when :req then name.to_s
+      when :rest then "*#{name}"
+      when :block then "&#{name}"
+      when :opt then "#{name} = some_value"
+      else
+        raise "Unknown parameter type #{type}"
+      end
+    end
+
+    return translated.join(", ")
+  end
+
+  it "should have the same public interface as Redis" do
+    difference = Redis.public_instance_methods - RedisRing::Client::RingProxy.public_instance_methods
+
+    ignored = [:client, :id, :method_missing]
+
+    difference -= ignored
+
+    unless difference == []
+      puts "#{difference.size} missing methods:"
+
+      difference.sort.each do |method_name|
+        puts "#{method_name}(#{readable_params(Redis.instance_method(method_name).parameters)})"
+      end
+
+      fail("Not all methods implemented")
+    end
+  end
+
+  context "with real RedisRing" do
+    before(:each) do
+      @proxy = RedisRing::Client::RingProxy.new
+      @proxy.flushdb
+    end
+
+    describe "single key operations" do
+      it "should have simple key operations implemented" do
+        @proxy.set('foo', 1)
+
+        @proxy.get('foo').should == '1'
+      end
+
+      it "should have string operations implemented" do
+        3.times { @proxy.append('foo', 'bar') }
+        @proxy.incr('bar')
+        @proxy.incrby('bar', 10)
+        @proxy.decrby('bar', 3)
+
+        @proxy.strlen('foo').should == 9
+        @proxy.get('bar').should == '8'
+      end
+
+      it "should have list operations implemented" do
+        3.times { |n| @proxy.lpush('foo', "bar#{n}") }
+
+        @proxy.llen('foo').should == 3
+        @proxy.lpop('foo').should == 'bar2'
+        @proxy.rpop('foo').should == 'bar0'
+      end
+
+      it "should have set operations implemented" do
+        3.times { |n| @proxy.sadd('foo', "bar#{n}") }
+
+        @proxy.scard('foo').should == 3
+        @proxy.smembers('foo').sort.should == ['bar0', 'bar1', 'bar2']
+      end
+
+      it "should have zset operations implemented" do
+        @proxy.zadd 'foo', 1, 'bar'
+        @proxy.zadd 'foo', 3, 'baz'
+        @proxy.zadd 'foo', 2, 'bam'
+
+        @proxy.zcard('foo').should == 3
+        @proxy.zcount('foo', 1, 2).should == 2
+        @proxy.zrange('foo', 0, -1).should == ['bar', 'bam', 'baz']
+        @proxy.zrange('foo', 0, -1, :with_scores => true).should == ['bar', '1', 'bam', '2', 'baz', '3']
+      end
+
+      it "should have hash operations implemented" do
+        @proxy.hset 'foo', 'bar', 'hello'
+        3.times { @proxy.hincrby 'foo', 'baz', 2 }
+
+        @proxy.hkeys('foo').should == ['bar', 'baz']
+        @proxy.hgetall('foo').should == {'bar' => 'hello', 'baz' => '6'}
+      end
+    end
+
+    describe "multi key operations" do
+      it "should allow multi key operations as long as they operate on the same shard" do
+        @proxy.mset 'foo{one}', 1, 'bar{one}', 2
+
+        @proxy.mget('foo{one}', 'bar{one}').should == ['1', '2']
+      end
+
+      it "should raise an exception if running an operation on multiple shards" do
+        lambda{
+          @proxy.mapped_mset 'foo{one}' => 1, 'bar{two}' => 2
+        }.should raise_exception(RedisRing::Client::MultiShardOperationError)
+      end
+
+      it "should work with multi key zset operations" do
+        @proxy.zadd 'foo{one}', 1, 1
+        @proxy.zadd 'foo{one}', 1, 2
+        @proxy.zadd 'foo{one}', 1, 3
+
+        @proxy.zadd 'bar{one}', 1, 2
+        @proxy.zadd 'bar{one}', 1, 3
+        @proxy.zadd 'bar{one}', 1, 4
+
+        @proxy.zinterstore 'baz{one}', ['foo{one}', 'bar{one}']
+
+        @proxy.zrange('baz{one}', 0, -1).should == ['2', '3']
+      end
+    end
+
+    describe "scather-gather operations" do
+      it "should sum dbsize and similar operations" do
+        keys = %w{ala ma kota kot ali nazywa sie as}
+        keys.each_with_index { |key, idx| @proxy.set(key, idx) }
+
+        @proxy.keys('*').sort.should == keys.sort
+        @proxy.dbsize.should == keys.size
+      end
+
+      it "should return last_result for operations where result is not important" do
+        @proxy.bgsave.should == "Background saving started"
+        @proxy.flushdb.should == "OK"
+      end
+    end
+
+    describe "unsupported operations" do
+      it "should raise an exception when using an operation with undefined behavior in RedisRing" do
+        lambda {
+          @proxy.multi do
+            @proxy.set 'foo{one}', 1
+            @proxy.set 'foo{two}', 2
+          end
+        }.should raise_exception(RedisRing::Client::UnsupportedOperationError)
+      end
+    end
+
+    describe "random shard operations" do
+      it "should execute the operation on a random shard" do
+        @proxy.ping.should == "PONG"
+      end
+    end
+
+  end
+
+end

data/spec/redis_ring/client/shard_connection_pool_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe RedisRing::Client::ShardConnectionPool do
+
+  before(:each) do
+    @metadata = FakeRingMetaData.new(5)
+    5.times do |n|
+      @metadata.shards[n] = RedisRing::Client::ShardMetaData.new("host#{n}", 666 + n, :running)
+    end
+
+    @connection_pool = RedisRing::Client::ShardConnectionPool.new(@metadata, @password = nil, @db = 10)
+  end
+
+  it "should create a new connection when there was no shard connection before" do
+    @connection_pool.expects(:new_connection).with("host1", 667, @db, @password).returns(:foo).once
+
+    @connection_pool.connection(1).should == :foo
+  end
+
+  it "should cache connections" do
+    @connection_pool.expects(:new_connection).with("host1", 667, @db, @password).returns(:foo).once
+
+    @connection_pool.connection(1).should == :foo
+    @connection_pool.connection(1).should == :foo
+  end
+
+end

data/spec/redis_ring/client/sharder_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe RedisRing::Client::Sharder do
+
+  before(:each) do
+    @sharder = RedisRing::Client::Sharder.new(@meta_data = FakeRingMetaData.new(1024))
+  end
+
+  it "should hash the same value always to the same shard" do
+    shards = (0..9).map{|n| @sharder.shard_for_key("some_key")}
+
+    shards.uniq.size.should == 1
+  end
+
+  it "should never return less than 0 or more than ring_size - 1" do
+    ['foo', 'bar', 'baz'].product(['0', '1', '2']).product(['a', 'b', 'c']).each do |arr|
+      str = arr.flatten.join('_')
+      shard = @sharder.shard_for_key(str)
+
+      shard.should >= 0
+      shard.should < 1024
+    end
+  end
+
+  it "should be sensitive to ring_size change" do
+    old_val = @sharder.shard_for_key('foo')
+    @meta_data.ring_size = 100
+    @sharder.shard_for_key('foo').should_not == old_val
+  end
+
+  it "should return different shards for slightly different values" do
+    @sharder.shard_for_key('foo1').should_not == @sharder.shard_for_key('foo2')
+  end
+
+  it "should take advantage of the {shard} specifier" do
+    @sharder.shard_for_key('foo1{one}').should == @sharder.shard_for_key('foo2{one}')
+    @sharder.shard_for_key('foo1{one}').should == @sharder.shard_for_key('one')
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'redis_ring/client'
+
+require File.expand_path('../fakes/fake_ring_meta_data', __FILE__)
+
+RSpec.configure do |c|
+  c.color_enabled = true
+  c.mock_with :mocha
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: redis_ring_client
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Adam Pohorecki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: The client counterpart to the RedisRing gem.
+email: 
+- adam@pohorecki.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE.txt
+- Rakefile
+- lib/redis_ring/client.rb
+- lib/redis_ring/client/operation_definitions.rb
+- lib/redis_ring/client/ring_meta_data.rb
+- lib/redis_ring/client/ring_proxy.rb
+- lib/redis_ring/client/shard_connection_pool.rb
+- lib/redis_ring/client/sharder.rb
+- lib/redis_ring/client/version.rb
+- redis_ring_client.gemspec
+- spec/fakes/fake_ring_meta_data.rb
+- spec/redis_ring/client/ring_meta_data_spec.rb
+- spec/redis_ring/client/ring_proxy_spec.rb
+- spec/redis_ring/client/shard_connection_pool_spec.rb
+- spec/redis_ring/client/sharder_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/psyho/redis_ring_client
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: redis_ring_client
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Client for RedisRing
+test_files: []
+