red_cluster 0.0.1 → 0.0.2

data/lib/red_cluster.rb

@@ -10,20 +10,6 @@ class RedCluster
     @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)
@@ -33,15 +19,19 @@ class RedCluster
   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 select(db); @replica_sets.each {|replica_set| replica_set.select(db) }; "OK"; end
+
+  [:flushdb, :shutdown, :flushall, :quit, :multi].each do |method|
+    define_method method do
+      perform_across_all_replica_sets method
+    end
+  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 echo(msg); @replica_sets.each {|replica_set| replica_set.echo(msg) }; msg; end
+
+  def keys(pattern); @replica_sets.map { |replica_set| replica_set.keys pattern }.flatten; end
   def lastsave; @replica_sets.map(&:lastsave).min; end
 
   def config(cmd, *args)
@@ -54,8 +44,6 @@ class RedCluster
   end
 
   # Transaction Ops
-  def multi; @replica_sets.each(&:multi); end
-
   def exec
     @multi_count = nil
     exec_results = @replica_sets.map(&:exec)
@@ -152,7 +140,27 @@ class RedCluster
     end
   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
+
   private
+
+  def perform_across_all_replica_sets(op, return_msg = 'OK')
+    @replica_sets.each { |replica_set| replica_set.send op }
+    return_msg
+  end
+
   def replica_set_for_key(key)
     @replica_sets[Zlib.crc32(key).abs % @replica_sets.size]
   end

data/spec/red_cluster_spec.rb

@@ -25,26 +25,6 @@ describe RedCluster do
   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"
@@ -250,8 +230,8 @@ describe RedCluster do
 
   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"
+      rc.echo('hello').should == 'hello'
+      # rc.replica_sets.each { |rs| rs.should_receive(:echo).with("hello") }
     end
   end
 

data/spec/replica_sets_spec.rb

@@ -2,117 +2,105 @@ 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
+  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 "#other characteristics" do
+  context "master dying" 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
+      master.stubs(:set).raises Errno::ECONNREFUSED
     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
+    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 "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
+    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
-
-      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
+      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
-      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 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
-      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
+    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"
+  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
+      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
+  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
+  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
+  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
+  context "#pub sub operations" do
+    it "raise an error" do
+      expect { rs.blpop("publish", 0) }.to raise_error
     end
-
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red_cluster
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-10-25 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70203057663840 !ruby/object:Gem::Requirement
+  requirement: &70306677369620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70203057663840
+  version_requirements: *70306677369620
 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