schoefmax-multi_db 0.1.2 → 0.1.3

data/README.rdoc

@@ -1,6 +1,6 @@
 = multi_db
 
-=====-- This Plugin was inspired by Rick Olson's "masochism"-Plugin
+=====-- This GEM was inspired by Rick Olson's "masochism"-Plugin
 
 multi_db uses a connection proxy, which sends read queries to slave databases,
 and all write queries to the master database (Read/Write Split).
@@ -11,7 +11,7 @@ master database.
 === Caveats
 
 * works with activerecord 2.1 and 2.2, but is not threadsafe (yet)
-* when using Passenger or lightspeed you will probably need to introduce a before_filter which checks if the proxy is setup (see the discussion in the masochism readme: http://github.com/technoweenie/masochism/tree/master)
+* when using Passenger or lightspeed you will probably need to introduce a before_filter which checks if the proxy is setup (see the discussion in the masochism readme: http://github.com/technoweenie/masochism)
 
 === Install
 
@@ -79,7 +79,20 @@ Just add this to your controller:
 
 In your environment.rb or an initializer, add:
 
-  MultiDb::ConnectionProxy.master_models = ['PaymentTransaction', ...]
+  MultiDb::ConnectionProxy.master_models = ['CGI::Session::ActiveRecordStore', 'PaymentTransaction', ...]
+
+=== Making one slave database sticky during a request
+
+This can be useful to leverage database level query caching as all queries will
+be sent to the same slave database during one web request.
+
+To enable, add this to your environment.rb just before <tt>MultiDb::ConnectionProxy.setup!</tt>:
+
+   MultiDb::ConnectionProxy.sticky_slave = true
+
+And add this to your ApplicationController:
+
+   after_filter { ActiveRecord::Base.connection_proxy.next_reader! }
 
 === Usage outside of Rails
 
@@ -142,11 +155,30 @@ Note that the configurations hash should contain strings as keys instead of symb
   <tt>with_master(&block)</tt>
 * All proxied methods are dynamically generated for better performance
 
+=== See also
+
+==== Masochism
+
+The original plugin:
+
+* http://github.com/technoweenie/masochism
+
+==== DataFabric
+
+A solution by FiveRuns, also based on masochism but without the "nested with_master"-issue,
+threadsafe and allows sharding of data.
+
+* http://github.com/fiveruns/data_fabric
+
 === Contributors
 
 * Matt Conway http://github.com/wr0ngway
 * Matthias Marshall http://github.com/webops
 
+=== Ideas
+
+See: http://github.com/schoefmax/multi_db/wikis/home
+
 === Running specs
 
 If you haven't already, install the rspec gem, then create an empty database

data/lib/multi_db/active_record_extensions.rb

@@ -4,24 +4,23 @@ module MultiDb
       base.alias_method_chain :reload, :master
 
       class << base
-        def connection_proxy=(proxy)
-          @@connection_proxy = proxy
-        end
         
+        cattr_accessor :connection_proxy
+
         # hijack the original method
         def connection
           if ConnectionProxy.master_models.include?(self.to_s)
             self.retrieve_connection
           else
-            @@connection_proxy
+            self.connection_proxy
           end
         end
       end
-      
+
     end
     
     def reload_with_master(*args, &block)
-      connection.with_master { reload_without_master }
+      connection_proxy.with_master { reload_without_master }
     end
   end
 end

data/lib/multi_db/connection_proxy.rb

@@ -22,14 +22,21 @@ module MultiDb
       #
       # Example:
       #
-      #  MultiDb::ConnectionProxy.master_models = %w[PaymentTransactions]
+      #  MultiDb::ConnectionProxy.master_models = ['CGI::Session::ActiveRecordStore']
       attr_accessor :master_models
 
+      # decides if we should switch to the next reader automatically.
+      # If set to false, an after|before_filter in the ApplicationController
+      # has to do this.
+      # This will not affect failover if a master is unavailable.
+      attr_accessor :sticky_slave
+
       # Replaces the connection of ActiveRecord::Base with a proxy and
       # establishes the connections to the slaves.
       def setup!
         self.master_models ||= []
         self.environment   ||= (defined?(RAILS_ENV) ? RAILS_ENV : 'development')
+        self.sticky_slave  ||= false
         
         master = ActiveRecord::Base
         slaves = init_slaves
@@ -97,7 +104,17 @@ module MultiDb
         create_delegation_method!(method)
       end
     end
-        
+
+    # Switches to the next slave database for read operations.
+    # Fails over to the master database if all slaves are unavailable.
+    def next_reader!
+      return if @with_master > 0 # don't if in with_master block
+      @current = @slaves.next
+    rescue Scheduler::NoMoreItems
+      logger.warn "[MULTIDB] All slaves are blacklisted. Reading from master"
+      @current = @master
+    end
+
     protected
 
     def get_connection(db_class)
@@ -107,10 +124,10 @@ module MultiDb
     def create_delegation_method!(method)
       self.instance_eval %Q{
         def #{method}(*args, &block)
-          #{'next_reader!' unless unsafe?(method)}
+          #{'next_reader!' unless self.class.sticky_slave || unsafe?(method)}
           #{target_method(method)}(:#{method}, *args, &block)
         end
-      }
+      }, __FILE__, __LINE__
     end
     
     def target_method(method)
@@ -138,14 +155,6 @@ module MultiDb
       retry
     end
     
-    def next_reader!
-      return if @with_master > 0 # don't if in with_master block
-      @current = @slaves.next
-    rescue Scheduler::NoMoreItems
-      logger.warn "[MULTIDB] All slaves are blacklisted. Reading from master"
-      @current = @master
-    end
-    
     def reconnect_master!
       get_connection(@master).reconnect!
       @reconnect = false

data/lib/multi_db/query_cache_compat.rb

@@ -2,7 +2,7 @@ module MultiDb
   # Implements the methods expected by the QueryCache module
   module QueryCacheCompat
     def select_all(*a, &b)
-      next_reader!
+      next_reader! unless ConnectionProxy.sticky_slave
       send_to_current(:select_all, *a, &b)
     end
     def columns(*a, &b)

data/multi_db.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{multi_db}
-  s.version = "0.1.2"
+  s.version = "0.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Maximilian Sch\303\266fmann"]

data/spec/connection_proxy_spec.rb

@@ -18,11 +18,14 @@ describe MultiDb::ConnectionProxy do
   
   before(:each) do
     MultiDb::ConnectionProxy.setup!
-    @proxy = ActiveRecord::Base.connection
+    @proxy = ActiveRecord::Base.connection_proxy
+    @master = @proxy.master.retrieve_connection
+    @slave1 = MultiDb::SlaveDatabase1.retrieve_connection
+    @slave2 = MultiDb::SlaveDatabase2.retrieve_connection
   end
 
   it 'AR::B#connection should return an instance of MultiDb::ConnectionProxy' do
-    ActiveRecord::Base.connection.should be_a(MultiDb::ConnectionProxy)
+    ActiveRecord::Base.connection.should be_kind_of(MultiDb::ConnectionProxy)
   end
 
   it "should generate classes for each entry in the database.yml" do
@@ -47,7 +50,7 @@ describe MultiDb::ConnectionProxy do
   end
   
   it 'should perform transactions on the master' do
-    @proxy.master.retrieve_connection.should_receive(:select_all).exactly(1) # makes sure the first one goes to a slave
+    @master.should_receive(:select_all).exactly(1) # makes sure the first one goes to a slave
     @proxy.select_all(@sql)
     ActiveRecord::Base.transaction do
       @proxy.select_all(@sql)
@@ -55,25 +58,25 @@ describe MultiDb::ConnectionProxy do
   end
   
   it 'should switch to the next reader on selects' do
-    MultiDb::SlaveDatabase1.retrieve_connection.should_receive(:select_one).twice
-    MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_one).twice
+    @slave1.should_receive(:select_one).exactly(2)
+    @slave2.should_receive(:select_one).exactly(2)
     4.times { @proxy.select_one(@sql) }
   end
   
   it 'should not switch to the next reader when whithin a with_master-block' do
-    @proxy.master.retrieve_connection.should_receive(:select_one).twice
-    MultiDb::SlaveDatabase1.retrieve_connection.should_not_receive(:select_one)
-    MultiDb::SlaveDatabase2.retrieve_connection.should_not_receive(:select_one)
+    @master.should_receive(:select_one).twice
+    @slave1.should_not_receive(:select_one)
+    @slave2.should_not_receive(:select_one)
     @proxy.with_master do
       2.times { @proxy.select_one(@sql) }
     end
   end
-  
+
   it 'should send dangerous methods to the master' do
     meths = [:insert, :update, :delete, :execute]
     meths.each do |meth|
-      MultiDb::SlaveDatabase1.retrieve_connection.stub!(meth).and_raise(RuntimeError)
-      @proxy.master.retrieve_connection.should_receive(meth).and_return(true)
+      @slave1.stub!(meth).and_raise(RuntimeError)
+      @master.should_receive(meth).and_return(true)
       @proxy.send(meth, @sql)
     end
   end
@@ -87,9 +90,9 @@ describe MultiDb::ConnectionProxy do
   it 'should cache queries using select_all' do
     ActiveRecord::Base.cache do
       # next_reader will be called and switch to the SlaveDatabase2
-      MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).exactly(1)
-      MultiDb::SlaveDatabase1.retrieve_connection.should_not_receive(:select_all)
-      @proxy.master.retrieve_connection.should_not_receive(:select_all)
+      @slave2.should_receive(:select_all).exactly(1)
+      @slave1.should_not_receive(:select_all)
+      @master.should_not_receive(:select_all)
       3.times { @proxy.select_all(@sql) }
     end
   end
@@ -98,10 +101,10 @@ describe MultiDb::ConnectionProxy do
     ActiveRecord::Base.cache do
       meths = [:insert, :update, :delete]
       meths.each do |meth|
-        @proxy.master.retrieve_connection.should_receive(meth).and_return(true)
+        @master.should_receive(meth).and_return(true)
       end
-      MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).twice
-      MultiDb::SlaveDatabase1.retrieve_connection.should_receive(:select_all).once
+      @slave2.should_receive(:select_all).twice
+      @slave1.should_receive(:select_all).once
       3.times do |i|
         @proxy.select_all(@sql)
         @proxy.send(meths[i])
@@ -110,31 +113,52 @@ describe MultiDb::ConnectionProxy do
   end
   
   it 'should retry the next slave when one fails and finally fall back to the master' do
-    MultiDb::SlaveDatabase1.retrieve_connection.should_receive(:select_all).once.and_raise(RuntimeError)
-    MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).once.and_raise(RuntimeError)
-    @proxy.master.retrieve_connection.should_receive(:select_all).and_return(true)
+    @slave1.should_receive(:select_all).once.and_raise(RuntimeError)
+    @slave2.should_receive(:select_all).once.and_raise(RuntimeError)
+    @master.should_receive(:select_all).and_return(true)
     @proxy.select_all(@sql)
   end
   
   it 'should try to reconnect the master connection after the master has failed' do
-    @proxy.master.retrieve_connection.should_receive(:update).and_raise(RuntimeError)
+    @master.should_receive(:update).and_raise(RuntimeError)
     lambda { @proxy.update(@sql) }.should raise_error
-    @proxy.master.retrieve_connection.should_receive(:reconnect!).and_return(true)
-    @proxy.master.retrieve_connection.should_receive(:insert).and_return(1)
+    @master.should_receive(:reconnect!).and_return(true)
+    @master.should_receive(:insert).and_return(1)
     @proxy.insert(@sql)
   end
 
   it 'should always use the master database for models configured as master models' do
-    MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).once.and_return([])
+    @slave2.should_receive(:select_all).once.and_return([])
     MasterModel.connection.should == @proxy
     MasterModel.first
     
     MultiDb::ConnectionProxy.master_models = ['MasterModel']
-    MasterModel.connection.should == @proxy.master.retrieve_connection
-    MultiDb::SlaveDatabase1.retrieve_connection.should_not_receive(:select_all)
+    MasterModel.connection.should == @master
+    @slave1.should_not_receive(:select_all)
     MasterModel.retrieve_connection.should_receive(:select_all).once.and_return([])
     MasterModel.first
   end
   
+  describe 'with sticky_slave ' do
+
+    before { MultiDb::ConnectionProxy.sticky_slave = true  }
+    after  { MultiDb::ConnectionProxy.sticky_slave = false }
+
+    it 'should not switch to the next reader when #sticky_master is true' do
+      @slave1.should_receive(:select_all).exactly(3)
+      @slave2.should_receive(:select_all).exactly(0)
+      3.times { @proxy.select_all(@sql) }
+    end
+
+    it '#next_reader! should switch to the next slave' do
+      @slave1.should_receive(:select_one).exactly(3)
+      @slave2.should_receive(:select_one).exactly(7)
+      3.times { @proxy.select_one(@sql) }
+      @proxy.next_reader!
+      7.times { @proxy.select_one(@sql) }
+    end
+
+  end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: schoefmax-multi_db
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - "Maximilian Sch\xC3\xB6fmann"