red_cluster 0.0.1

data/lib/red_cluster.rb

@@ -0,0 +1,213 @@
+require 'redis'
+require 'zlib'
+require 'set'
+require 'replica_set'
+
+class RedCluster
+  attr_reader :replica_sets
+
+  def initialize(replica_sets = [])
+    @replica_sets = replica_sets.map { |replica_set| ReplicaSet.new(self, replica_set) }
+  end
+
+  def load_aof_file(file_path)
+    aof_file = File.read file_path
+    commands = aof_file.split /^\*/
+    commands.each do |cmd|
+      split_cmd = cmd.split("\r\n")[1..-1]
+      next unless split_cmd
+      split_cmd.reject! { |cmd| cmd =~ /^\$/ }
+      redis_cmd, redis_key, redis_args = split_cmd[0], split_cmd[1], split_cmd[2..-1]
+      crc32_of_key = Zlib.crc32(redis_key).abs
+      replica_set = @replica_sets[crc32_of_key % @replica_sets.size]
+      replica_set.master.send redis_cmd, redis_key, *redis_args
+    end
+  end
+
+  SINGLE_KEY_KEY_OPS        = %W{del exists expire expireat move persists ttl type}.map(&:to_sym)
+  STRING_OPS                = %W{append decr decrby get getbit getrange getset incr incrby mget mset msetnx set setbit setex setnx setrange strlen}.map(&:to_sym)
+  HASH_OPS                  = %W{hdel hexists hget hgetall hincrby hkeys hlen hmget hmset hset hsetnx hvals}.map(&:to_sym)
+  SINGLE_KEY_LIST_OPS       = %W{blpop brpop lindex linsert llen lpop lpush lpushx lrange lrem lset ltrim rpop rpush rpushx}.map(&:to_sym)
+  SINGLE_KEY_SET_OPS        = %W{sadd scard sismember smembers spop srandmember srem}.map(&:to_sym)
+  SINGLE_KEY_SORTED_SET_OPS = %W{zadd zcard zcount zincrby zrange zrangebyscore zrank zrem zremrangebyrank zremrangebyscore zrevrange zrevrangebyscore zrevrank zscore}.map(&:to_sym)
+  SINGLE_KEY_OPS            = SINGLE_KEY_KEY_OPS + STRING_OPS + HASH_OPS + SINGLE_KEY_LIST_OPS + SINGLE_KEY_SET_OPS + SINGLE_KEY_SORTED_SET_OPS
+
+  # Server Ops
+  def select(db); @replica_sets.each {|srvr| srvr.select(db) }; "OK"; end
+  def echo(msg); @replica_sets.each {|srvr| srvr.echo(msg) }; msg; end
+  def flushdb; @replica_sets.each(&:flushdb); end
+  def shutdown; @replica_sets.each(&:shutdown); end
+  def flushall; @replica_sets.each { |rs| rs.flushall }; "OK"; end
+  def quit; @replica_sets.each(&:quit); "OK"; end
+  def ping; @replica_sets.each(&:ping); "PONG"; end
+  def keys(pattern); @replica_sets.map { |server| server.keys pattern }.flatten; end
+  def bgsave; @replica_sets.each(&:bgsave); "Background saving started"; end
+  def lastsave; @replica_sets.map(&:lastsave).min; end
+
+  def config(cmd, *args)
+    if cmd == :get
+      @replica_sets.inject({}) { |result, replica_set| result.merge(replica_set.config(:get, *args)) }
+    else
+      @replica_sets.each { |replica_set| replica_set.config(cmd, *args) }
+      "OK"
+    end
+  end
+
+  # Transaction Ops
+  def multi; @replica_sets.each(&:multi); end
+
+  def exec
+    @multi_count = nil
+    exec_results = @replica_sets.map(&:exec)
+    #We'll get back a deeply nested array of arrays of the kind
+    #[[3, 30], [10, 1]], [1, "OK"]] - where the first element in each leaf array is the RANK and the second is the result
+    #We need to return back the results sorted by rank. So in the above case it would be
+    #["OK", 30, 1]. Ruby's full-LISP toolbox to the rescue
+    Hash[*exec_results.flatten].sort.map(&:last)
+  end
+
+  # Key Ops
+  def randomkey
+    replica_sets_with_keys_in_them  = @replica_sets.select { |replica_set| replica_set.randomkey != nil }
+    idx = (rand * replica_sets_with_keys_in_them.count).to_i
+    rand_replica_set = replica_sets_with_keys_in_them[idx]
+    rand_replica_set && rand_replica_set.randomkey
+  end
+
+  def rename(key, new_key)
+    raise RuntimeError, "ERR source and destination objects are the same" if key == new_key
+    raise RuntimeError, "ERR no such key" unless exists(key)
+    val = get key
+    del key
+    set new_key, val
+  end
+
+  # List Ops
+  def rpoplpush(src_list, target_list)
+    val = rpop src_list
+    return unless val
+    lpush target_list, val
+    val
+  end
+
+  def brpoplpush(src_list, target_list, timeout)
+    val = brpop src_list, timeout
+    return unless val
+    lpush target_list, val
+    val
+  end
+
+  # Set Ops
+  def smove(src, destination, member)
+    if sismember src, member
+      sadd destination, member
+      srem src, member
+      true
+    else
+      false
+    end
+  end
+
+  def sdiff(*sets)
+    perform_set_strategy :difference, *sets
+  end
+
+  def sinter(*sets)
+    perform_set_strategy :intersection, *sets
+  end
+
+  def sunion(*sets)
+    perform_set_strategy :union, *sets
+  end
+
+  def sinterstore(destination, *sets)
+    perform_store_strategy :sinter, destination, *sets
+  end
+
+  def sunionstore(destination, *sets)
+    perform_store_strategy :sunion, destination, *sets
+  end
+
+  def sdiffstore(destination, *sets)
+    perform_store_strategy :sdiff, destination, *sets
+  end
+
+  # Sorted Set Ops
+  def zinterstore(destination, input_sets, options = {})
+    perform_sorted_set_store_strategy :intersection, destination, input_sets, options
+  end
+
+  def zunionstore(destination, input_sets, options = {})
+    perform_sorted_set_store_strategy :union, destination, input_sets, options
+  end
+
+
+  def method_missing(method, *args)
+    if SINGLE_KEY_OPS.include?(method.to_sym)
+      key = args.first
+      replica_set = replica_set_for_key key
+      replica_set.send method, *args
+    else
+      raise "Unsupported operation: #{method}"
+    end
+  end
+
+  private
+  def replica_set_for_key(key)
+    @replica_sets[Zlib.crc32(key).abs % @replica_sets.size]
+  end
+
+  def multi_count
+    @multi_count ||= -1
+    @multi_count += 1
+  end
+
+  def perform_store_strategy(strategy, destination, *sets)
+    del destination
+    send(strategy, *sets).each do |entry|
+      sadd destination, entry
+    end
+    scard destination
+  end
+
+  def perform_set_strategy(strategy, *sets)
+    first_set = Set.new(smembers(sets.first))
+    sets[1..-1].inject(first_set) do |accum_set, set|
+      accum_set.send(strategy, (Set.new(smembers(set))))
+    end.entries
+  end
+
+  def perform_sorted_set_store_strategy(strategy, destination, input_sets, options)
+    weights = Array(options[:weights])
+
+    first_set = Set.new(zrange(input_sets.first, 0, -1))
+    accum_set = input_sets[0..-1].inject(first_set) do |accmltr, set|
+      accmltr.send(strategy, Set.new(zrange(set, 0, -1)))
+    end
+
+    del destination
+
+    accum_set.entries.each do |entry|
+      score_of_input_sets = input_sets.map do |input_set| 
+        [input_set, zscore(input_set, entry)] 
+      end.reject do |is, zscr|
+        zscr == nil
+      end.map do |is,zscr|
+        zscr.to_i * weights.fetch(input_sets.index(is), 1)
+      end
+      aggregate_function = (options[:aggregate] || :sum)
+      score = if aggregate_function == :sum
+                score_of_input_sets.inject(0) { |sum, e_score| sum += e_score.to_i }
+              elsif [:min, :max].include?(aggregate_function)
+                score_of_input_sets.send aggregate_function
+              else
+                raise "ERR syntax error"
+              end
+
+      zadd destination, score, entry
+    end
+    zcard destination
+  end
+
+end
+

data/lib/replica_set.rb

@@ -0,0 +1,82 @@
+class RedCluster
+  class ReplicaSet
+    attr_reader :slaves, :master
+
+    def initialize(cluster, options)
+      @my_cluster = cluster
+      @master = Redis.new options[:master]
+      @slaves = options[:slaves].map { |slave_config| Redis.new slave_config }
+      setup_slaves
+    end
+
+    def multi
+      @in_multi = true
+      @cmd_order_in_multi = []
+      @master.multi
+    end
+
+    def exec
+      @in_multi = nil
+      @master.exec.map { |result| [@cmd_order_in_multi.shift, result] }
+    end
+
+    def method_missing(command, *args)
+      if blocking_command?(command)
+        raise "Blocking Commands Not Permitted"
+      elsif pub_sub_command?(command)
+        raise "Pub Sub Commands Not Permitted"
+      elsif slaveof_command?(command)
+        raise "Slave Commands Not Permitted"
+      elsif command == :shutdown
+        @master.shutdown
+        @slaves.each(&:shutdown)
+      elsif @in_multi
+        @cmd_order_in_multi << @my_cluster.send(:multi_count)
+        @master.send command, *args
+      elsif read_command?(command)
+        next_slave.send command, *args
+      else
+        @master.send command, *args
+      end
+    rescue Errno::ECONNREFUSED
+      new_master = @slaves.shift
+      raise(NoMaster, "No master in replica set") unless new_master
+      @master = new_master
+      setup_slaves
+      retry
+    end
+
+    def next_slave
+      ret = @slaves.shift
+      @slaves.push ret
+      ret
+    end
+
+    private
+
+    def setup_slaves
+      @slaves.each { |slave| slave.slaveof(@master.client.host, @master.client.port) }
+    end
+
+    def slaveof_command?(command)
+      command == :slaveof
+    end
+
+    def read_command?(command)
+      [:dbsize, :exists, :get, :getbit, :getrange, :hexists, :hget, :hgetall, :hkeys, :hlen, :hmget, :hvals, :keys, :lastsave, :lindex, :llen, :mget, :object, :randomkey, :scard, :sismember, :smembers, :srandmember, :strlen, :ttl, :zcard, :zcount, :zrange, :zrangebyscore, :zrank, :zrevrange, :zrevrangebyscore, :zrevrank, :zscore].include?(command)
+    end
+
+    def blocking_command?(command)
+      [:blpop, :brpop, :brpoplpush].include?(command)
+    end
+
+    def pub_sub_command?(command)
+      [:psubscribe, :publish, :punsunscribe, :subscribe, :unsubscribe].include?(command)
+    end
+  end
+end
+
+class RedCluster
+  class NoMaster < ::Exception
+  end
+end

data/spec/red_cluster_spec.rb

@@ -0,0 +1,432 @@
+require 'spec_helper'
+require 'red_cluster'
+
+describe RedCluster do
+  before do
+    first_replica_set = {
+      :master => {:host => "localhost", :port => 6379}, 
+      :slaves => [{:host => "localhost", :port => 7379},
+        {:host => "localhost", :port => 8379}]
+    }
+    second_replica_set = {
+      :master => {:host => "localhost", :port => 9379}, 
+      :slaves => [{:host => "localhost", :port => 10379},
+        {:host => "localhost", :port => 11379}]
+    }
+    third_replica_set = {
+      :master => {:host => "localhost", :port => 12379}, 
+      :slaves => [{:host => "localhost", :port => 13379},
+        {:host => "localhost", :port => 14379}]
+    }
+    replica_sets = [first_replica_set, second_replica_set, third_replica_set]
+    @rc = RedCluster.new replica_sets
+    @rc.replica_sets.each { |rs| rs.stubs(:read_command?).returns(false) }
+  end
+  let(:rc) { @rc }
+  after { rc.flushall }
+
+  it "gets initialized with a bunch of replica sets" do
+    first_replica_set = {
+      :master => {:host => "localhost", :port => 6379}, 
+      :slaves => [{:host => "localhost", :port => 7379},
+        {:host => "localhost", :port => 8379}]
+    }
+    second_replica_set = {
+      :master => {:host => "localhost", :port => 9379}, 
+      :slaves => [{:host => "localhost", :port => 10379},
+        {:host => "localhost", :port => 11379}]
+    }
+    third_replica_set = {
+      :master => {:host => "localhost", :port => 12379}, 
+      :slaves => [{:host => "localhost", :port => 13379},
+        {:host => "localhost", :port => 14379}]
+    }
+    replica_sets = [first_replica_set, second_replica_set, third_replica_set]
+    RedCluster.new replica_sets
+  end
+
+  context "#randomkey", :fast => true do
+    it "returns a random key across the cluster", :fast => true do
+      rc.set "foo", "bar"
+      rc.randomkey.should == "foo"
+    end
+    it "returns nil for an empty cluster" do
+      rc.randomkey.should_not be
+    end
+  end
+
+  context "#flushdb" do
+    it "works" do
+      (1..10_000).to_a.each { |num| rc.set("number|#{num}", "hello") }
+      #make sure all servers have a key
+      rc.replica_sets.each do |replica_set|
+        replica_set.randomkey.should be
+      end
+      rc.flushdb
+      rc.replica_sets.each do |replica_set|
+        replica_set.randomkey.should_not be
+      end
+    end
+  end
+
+  context "#flushall" do
+    it "flushes keys from all across the cluster" do
+      (1..10).to_a.each { |num| rc.set("number|#{num}", "hello") }
+      [0, 1, 2].each { |num| rc.replica_sets[num].master.randomkey.should be }
+      rc.flushall.should == "OK"
+      rc.randomkey.should_not be
+    end
+  end
+
+  context "#keys" do
+    it 'scans across the cluster' do
+      (1..10).to_a.each { |num| rc.set("number|#{num}", "hello") }
+      rc.keys("*").map(&:to_s).sort.should == rc.replica_sets.inject([]) { |accum, rs| accum << rs.keys("*") }.flatten.map(&:to_s).sort
+    end
+  end
+
+  context "#smove" do
+    it "returns false if the first set does not exist or does not have the member" do
+      rc.smove("non_existent_source", "destination", "foo").should == false
+      rc.sadd "source", "bar"
+      rc.smove("source", "destination", "foo").should == false
+    end
+
+    it "returns true if the first set had the member" do
+      rc.sadd "source", "foo"
+      rc.smove("source", "destination", "foo").should == true
+      rc.sismember("source", "foo").should == false
+      rc.sismember("destination", "foo").should == true
+    end
+  end
+
+  context "#sdiffstore", :fast => true do
+    it "stores the diff in the destination" do
+      (1..10).to_a.each { |num| rc.sadd "set_one", num }
+      (5..10).to_a.each { |num| rc.sadd "set_two", num }
+      rc.sdiffstore("result_set", "set_one", "set_two").should == 4
+      rc.smembers("result_set").sort.should == (1..4).to_a.map(&:to_s)
+    end
+
+    it "doesn't store the destination if the diff yielded no results" do
+      rc.sdiffstore("result_set", "unknown_set", "set_two").should == 0
+      rc.smembers("result_set").should == []
+    end
+  end
+
+  context "#sdiff", :fast => true do
+    it "calculates the diff" do
+      (1..10).to_a.each { |num| rc.sadd "set_one", num }
+      (5..10).to_a.each { |num| rc.sadd "set_two", num }
+      rc.sdiff("set_one", "set_two").sort.should == (1..4).to_a.map(&:to_s)
+    end
+    it "returns an [] when the first set does not exist" do
+      rc.sdiff("unknown_set", "some_set").should == []
+    end
+  end
+
+  context "#sinter", :fast => true do
+    it "calculates the intersection" do
+      (1..10).to_a.each { |num| rc.sadd "set_one", num }
+      (5..10).to_a.each { |num| rc.sadd "set_two", num }
+      rc.sinter("set_one", "set_two").map(&:to_i).sort.should == (5..10).to_a
+    end
+    it "returns an [] when the first set does not exist" do
+      rc.sinter("unknown_set", "some_set").should == []
+    end
+  end
+
+  context "#sinterstore", :fast => true do
+    it "stores the diff in the destination" do
+      (1..10).to_a.each { |num| rc.sadd "set_one", num }
+      (5..10).to_a.each { |num| rc.sadd "set_two", num }
+      rc.sinterstore("result_set", "set_one", "set_two").should == 6
+      rc.smembers("result_set").map(&:to_i).sort.should == (5..10).to_a
+    end
+
+    it "doesn't store the destination if the diff yielded no results" do
+      rc.sadd "result_set", 1
+      rc.sinterstore("result_set", "unknown_set", "set_two").should == 0
+      rc.smembers("result_set").should == []
+      rc.exists("result_set").should_not be
+    end
+  end
+
+  context "#sunion", :fast => true do
+    it "calculates the union" do
+      (1..4).to_a.each { |num| rc.sadd "set_one", num }
+      (5..10).to_a.each { |num| rc.sadd "set_two", num }
+      rc.sunion("set_one", "set_two").map(&:to_i).sort.should == (1..10).to_a
+    end
+    it "returns an [] when the first set does not exist" do
+      rc.sunion("unknown_set", "some_set").should == []
+    end
+  end
+
+  context "#sunionstore", :fast => true do
+    it "stores the union in the destination" do
+      (1..4).to_a.each { |num| rc.sadd "set_one", num }
+      (5..10).to_a.each { |num| rc.sadd "set_two", num }
+      rc.sunionstore("result_set", "set_one", "set_two").should == 10
+      rc.smembers("result_set").map(&:to_i).sort.should == (1..10).to_a
+    end
+
+    it "doesn't store the destination if the diff yielded no results" do
+      rc.sadd "result_set", 1
+      rc.sunionstore("result_set", "unknown_set", "set_two").should == 0
+      rc.smembers("result_set").should == []
+      rc.exists("result_set").should_not be
+    end
+  end
+
+  context "#rename", :fast => true do
+    it "raises an error if the key did not exist" do
+      expect { rc.rename("unknown_key", "key") }.to raise_error(RuntimeError, "ERR no such key")
+    end
+    it "raises an error if the keys are the same" do
+      rc.set "foo", "bar"
+      expect { rc.rename("foo", "foo") }.to raise_error(RuntimeError, "ERR source and destination objects are the same")
+    end
+    it "does a rename" do
+      rc.set "foo", "bar"
+      rc.rename("foo", "foo_new").should == "OK"
+      rc.exists("foo").should_not be
+      rc.get("foo_new").should == "bar"
+    end
+  end
+
+  context "#multi-exec", :fast => true do
+    it "works" do
+      rc.get("foo").should_not be
+      rc.get("baz").should_not be
+      rc.multi
+      100.times do
+        rc.set("foo", "bar").should == "QUEUED"
+        rc.incr("baz").should == "QUEUED"
+      end
+      rc.exec.should == 100.times.map { |i| ["OK", i+1] }.flatten
+      rc.get("foo").should == "bar"
+      rc.get("baz").should == "100"
+    end
+  end
+
+  context "#watch", :fast => true do
+    it "is an unsupported operation" do
+      expect { rc.watch }.to raise_error(RuntimeError, "Unsupported operation: watch")
+    end
+  end
+
+  context "#unwatch", :fast => true do
+    it "is an unsupported operation" do
+      expect { rc.unwatch }.to raise_error(RuntimeError, "Unsupported operation: unwatch")
+    end
+  end
+
+  context "bgsave-lastsave" do
+    it "returns the earliest lastsave time across the cluster" do
+      lastsave = rc.lastsave
+      rc.set "foo", "bar"
+      rc.bgsave.should == "Background saving started"
+      sleep 1 #give it a little time to complete
+      new_last_save = rc.lastsave
+      # No Idea why this fails when running the whole suite
+      # new_last_save.should > lastsave
+      rc.replica_sets.map(&:lastsave).sort.first.should == new_last_save
+    end
+  end
+
+  context "#quit", :fast => true do
+    it "closes all the cnxn's it has" do
+      rc.quit.should == "OK"
+    end
+  end
+
+  context "#ping", :fast => true do
+    it "ping's all replica_sets in the cluster" do
+      rc.replica_sets.each { |rs| rs.should_receive(:ping) }
+      rc.ping.should == "PONG"
+    end
+  end
+
+  context "#echo", :fast => true do
+    it "echo's all replica_sets" do
+      rc.replica_sets.each { |rs| rs.should_receive(:echo).with("hello") }
+      rc.echo("hello").should == "hello"
+    end
+  end
+
+  context "#config", :fast => true do
+    context "#get" do
+      it "returns the config values across all replica_sets" do
+        rc.config(:get, "*").should_not be_empty
+      end
+    end
+
+    context "#set", :fast => true do
+      it "sets values across all replica_sets" do
+        old_timeout = rc.config(:get, "timeout")["timeout"].to_i
+        old_timeout.should > 0
+        rc.config(:set, "timeout", 100).should == "OK"
+        rc.replica_sets.each { |rs| rs.config(:get, "timeout")["timeout"].to_i.should == 100 }
+        rc.config(:set, "timeout", old_timeout).should == "OK"
+        rc.replica_sets.each { |rs| rs.config(:get, "timeout")["timeout"].to_i.should == old_timeout }
+      end
+    end
+
+    context "#resetstat", :fast => true do
+      it "resets stats across all replica_sets" do
+        rc.flushall
+        rc.replica_sets.each { |rs| rs.info["total_commands_processed"].to_i.should > 1 }
+        rc.config(:resetstat).should == "OK"
+        rc.replica_sets.each { |rs| rs.info["total_commands_processed"].to_i.should == 1 }
+      end
+    end
+
+    context "#bad_command", :fast => true do
+      it "raises an error" do
+        expect { rc.config(:bad_command) }.to raise_error(RuntimeError, "ERR CONFIG subcommand must be one of GET, SET, RESETSTAT")
+      end
+    end
+  end
+
+  context "#auth", :fast => true do
+    it "is not supported" do
+      expect { rc.auth "foobar" }.to raise_error(RuntimeError, "Unsupported operation: auth")
+    end
+  end
+
+  context "#discard", :fast => true do
+    it "is not supported" do
+      expect { rc.discard }.to raise_error(RuntimeError, "Unsupported operation: discard")
+    end
+  end
+
+  context "#watch", :fast => true do
+    it "is not supported" do
+      expect { rc.watch }.to raise_error(RuntimeError, "Unsupported operation: watch")
+    end
+  end
+
+  context "#object", :fast => true do
+    it "is not supported" do
+      expect { rc.object }.to raise_error(RuntimeError, "Unsupported operation: object")
+    end
+  end
+
+  context "#sort", :fast => true do
+    it "is not supported" do
+      expect { rc.sort }.to raise_error(RuntimeError, "Unsupported operation: sort")
+    end
+  end
+
+  context "#zinterstore", :fast => true do
+    before do
+      rc.zadd "my_zset_one", 1, "key_one"
+      rc.zadd "my_zset_two", 10, "key_one"
+      rc.zadd "my_zset_one", 2, "key_two"
+      rc.zadd "my_zset_two", 20, "key_two"
+      rc.zadd "my_zset_two", 30, "key_three"
+    end
+
+    it "without weights and no aggregate function" do
+      rc.zinterstore("result", ["my_zset_one", "my_zset_two"]).should == 2
+      rc.zscore("result", "key_one").to_i.should == 11
+      rc.zscore("result", "key_two").to_i.should == 22
+      rc.zscore("result", "key_three").should_not be
+    end
+
+    it "with weights" do
+      rc.zinterstore("result", ["my_zset_one", "my_zset_two"], :weights => [10, 1]).should == 2
+      rc.zscore("result", "key_one").to_i.should == (10*1 + 10)
+      rc.zscore("result", "key_two").to_i.should == (10*2 + 20)
+    end
+
+    context "with AGGREGATE" do
+      it "sums" do
+        rc.zinterstore("result", ["my_zset_one", "my_zset_two"], :weights => [10, 1], :aggregate => :sum).should == 2
+        rc.zscore("result", "key_one").to_i.should == (10*1 + 10)
+        rc.zscore("result", "key_two").to_i.should == (10*2 + 20)
+      end
+
+      it "mins" do
+        rc.zinterstore("result", ["my_zset_one", "my_zset_two"], :weights => [5, 1], :aggregate => :min).should == 2
+        rc.zscore("result", "key_one").to_i.should == 5
+        rc.zscore("result", "key_two").to_i.should == 10
+      end
+
+      it "max'es" do
+        rc.zinterstore("result", ["my_zset_one", "my_zset_two"], :aggregate => :max).should == 2
+        rc.zscore("result", "key_one").to_i.should == 10
+        rc.zscore("result", "key_two").to_i.should == 20
+      end
+
+      it "raise an Error with an invalid aggregate function" do
+        rc.zadd "my_zset_one", 1, "key_one"
+        rc.zadd "my_zset_two", 10, "key_one"
+        expect { rc.zinterstore("result", ["my_zset_one", "my_zset_two"], :aggregate => :blahdiblah) }.to raise_error
+      end
+    end
+  end
+
+  context "#zunionstore", :fast => true do
+    before do
+      rc.zadd "my_zset_one", 1, "key_one"
+      rc.zadd "my_zset_two", 10, "key_one"
+      rc.zadd "my_zset_one", 2, "key_two"
+      rc.zadd "my_zset_two", 20, "key_two"
+      rc.zadd "my_zset_two", 30, "key_three"
+    end
+
+    it "without weights and no aggregate function" do
+      rc.zunionstore("result", ["my_zset_one", "my_zset_two"]).should == 3
+      rc.zscore("result", "key_one").to_i.should == 11
+      rc.zscore("result", "key_two").to_i.should == 22
+      rc.zscore("result", "key_three").to_i.should == 30
+    end
+
+    it "with weights" do
+      rc.zunionstore("result", ["my_zset_one", "my_zset_two"], :weights => [10, 1]).should == 3
+      rc.zscore("result", "key_one").to_i.should == (10*1 + 10)
+      rc.zscore("result", "key_two").to_i.should == (10*2 + 20)
+      rc.zscore("result", "key_three").to_i.should == (10*0 + 30)
+    end
+
+    context "ZUNIONSTORE with AGGREGATE" do
+      it "sums" do
+        rc.zunionstore("result", ["my_zset_one", "my_zset_two"], :weights => [10, 1], :aggregate => :sum).should == 3
+        rc.zscore("result", "key_one").to_i.should == (10*1 + 10)
+        rc.zscore("result", "key_two").to_i.should == (10*2 + 20)
+        rc.zscore("result", "key_three").to_i.should == (10*0 + 30)
+      end
+
+      it "mins" do
+        rc.zunionstore("result", ["my_zset_one", "my_zset_two"], :weights => [5, 1], :aggregate => :min).should == 3
+        rc.zscore("result", "key_one").to_i.should == 5
+        rc.zscore("result", "key_two").to_i.should == 10
+        rc.zscore("result", "key_three").to_i.should == 30
+      end
+
+      it "max'es" do
+        rc.zunionstore("result", ["my_zset_one", "my_zset_two"], :aggregate => :max).should == 3
+        rc.zscore("result", "key_one").to_i.should == 10
+        rc.zscore("result", "key_two").to_i.should == 20
+        rc.zscore("result", "key_three").to_i.should == 30
+      end
+
+      it "raise an Error with an invalid aggregate function" do
+        rc.zadd "my_zset_one", 1, "key_one"
+        rc.zadd "my_zset_two", 10, "key_one"
+        expect { rc.zunionstore("result", ["my_zset_one", "my_zset_two"], :aggregate => :blahdiblah) }.to raise_error
+      end
+    end
+  end
+
+  context "#shutdown", :fast => true do
+    it "shutdowns all servers" do
+      rc.replica_sets.each { |replica_set| replica_set.should_receive(:shutdown) }
+      rc.shutdown
+    end
+  end
+
+end
+

data/spec/replica_sets_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'replica_set'
+
+describe RedCluster::ReplicaSet do
+  context "#initializtion" do
+    it "gets initialized with one master & one or more slaves" do
+      master = {:host => "localhost", :port => 6379}
+      slaves = [{:host => "localhost", :port => 7379},
+        {:host => "localhost", :port => 8379}]
+      RedCluster::ReplicaSet.new nil, :master => master, :slaves => slaves
+    end
+  end
+
+  context "#other characteristics" do
+    before(:each) do
+      master = {:host => "localhost", :port => 6379}
+      slaves = [{:host => "localhost", :port => 7379},
+        {:host => "localhost", :port => 8379}]
+      @rs = RedCluster::ReplicaSet.new nil, :master => master, :slaves => slaves
+    end
+    let(:rs) { @rs }
+    let(:master) { @rs.master }
+    let(:slaves) { @rs.slaves }
+    after { master.flushall }
+
+    context "#replication" do
+      it "the slaves are slaveof's master" do
+        slaves.each do |slave|
+          slave.info["role"].should == "slave"
+          slave.info["master_host"].should == master.client.host
+          slave.info["master_port"].should == master.client.port.to_s
+        end
+      end
+    end
+
+    context "master dying" do
+      before(:each) do
+        master.stubs(:set).raises Errno::ECONNREFUSED
+      end
+      context "when it's a read op" do
+        it "things work as though nothing happened" do
+          expect { rs.get("foo") }.to_not raise_error
+        end
+      end
+
+      context "when there are more than one slave" do
+        it "one of them gets promoted to the new master" do
+          old_slaves = slaves.dup
+          old_master = master
+          rs.set("foo", "bar")
+          old_master.should_not == rs.master
+          old_slaves.should include(rs.master)
+        end
+        it "the other's become slaves of the new master" do
+          rs.set("foo", "bar")
+          new_master = rs.master
+          rs.slaves.each do |slave| 
+            slave.info["master_host"].should == new_master.client.host
+            slave.info["master_port"].should == new_master.client.port.to_s
+          end
+        end
+      end
+      context "when there is just one slave" do
+        it "becomes the new master" do
+          slaves.shift while slaves.count > 1
+          slaves.count.should == 1
+          old_slave = slaves[0]
+          rs.set('foo', 'bar')
+          old_slave.should == rs.master
+        end
+      end
+      context "when there are no slaves" do
+        it "a RedCluster::NoMaster exception get's thrown" do
+          slaves.shift while slaves.count > 0
+          expect { rs.set('foo', 'bar') }.to raise_error(RedCluster::NoMaster, "No master in replica set")
+        end
+      end
+    end
+
+    context "#read operations" do
+      it "get forwarded to the slaves on a round-robin basis" do
+        master.expects(:get).never
+        slaves[0].expects(:get).with("some_key").returns "some_val"
+        slaves[1].expects(:get).with("some_key").returns "some_new_val"
+
+        rs.get("some_key").should == "some_val"
+        rs.get("some_key").should == "some_new_val"
+      end
+    end
+
+    context "#write operations" do
+      it "get forwarded to the master" do
+        master.expects(:set)
+        rs.set("foo", "bar")
+      end
+    end
+
+    context "#blocking operations" do
+      it "raise an error" do
+        expect { rs.blpop("some_list", 0) }.to raise_error
+      end
+    end
+
+    context "#slaveof operations" do
+      it "raise an error" do
+        expect { rs.slaveof("localhost", 6379) }.to raise_error
+      end
+    end
+
+    context "#pub sub operations" do
+      it "raise an error" do
+        expect { rs.blpop("publish", 0) }.to raise_error
+      end
+    end
+
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :test
+Bundler.require :default, :test
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: red_cluster
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Santosh Kumar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70203057663840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70203057663840
+description: ! "    Red Cluster brings together a set of redis servers and allows
+  you to read and write to them\n    as though you were writing to just one. A few
+  of the reasons you might want to consider\n    clustering could be:\n\n    * Robustness
+  - Having a write master and read slaves\n    * Harnessing the multiple cores you
+  have running while not compromising on the speed of redis\n    * Fault tolerance
+  - When one of the masters goes down a slave in the replica sets gets promoted\n
+  \                       automatically, with no down-time\n"
+email: santosh79@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/red_cluster.rb
+- lib/replica_set.rb
+- spec/red_cluster_spec.rb
+- spec/replica_sets_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/santosh79/red_cluster
+licenses: []
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Red Cluster clusters togethers a set of redis servers.
+test_files: []