master_slave_adapter 0.2.0 → 1.0.0.beta1

data/master_slave_adapter.gemspec

@@ -1,21 +1,23 @@
 $:.push File.expand_path("../lib", __FILE__)
 
+require 'active_record/connection_adapters/master_slave_adapter/version'
+
 Gem::Specification.new do |s|
   s.name        = 'master_slave_adapter'
-  s.version     = File.read('VERSION').to_s
+  s.version     = ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = [ 'Mauricio Linhares', 'Torsten Curdt', 'Kim Altintop', 'Omid Aladini', 'SoundCloud' ]
-  s.email       = %q{kim@soundcloud.com tcurdt@soundcloud.com omid@soundcloud.com}
+  s.authors     = [ 'Mauricio Linhares', 'Torsten Curdt', 'Kim Altintop', 'Omid Aladini', 'Tiago Loureiro', 'Tobias Schmidt', 'SoundCloud' ]
+  s.email       = %q{kim@soundcloud.com tcurdt@soundcloud.com ts@soundcloud}
   s.homepage    = 'http://github.com/soundcloud/master_slave_adapter'
-  s.summary     = %q{Replication Aware Master/Slave Database Adapter for Rails/ActiveRecord}
-  s.description = %q{(MySQL) Replication Aware Master/Slave Database Adapter for Rails/ActiveRecord}
+  s.summary     = %q{Replication Aware Master/Slave Database Adapter for ActiveRecord}
+  s.description = %q{(MySQL) Replication Aware Master/Slave Database Adapter for ActiveRecord}
 
   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_path = 'lib'
 
-  s.required_ruby_version     = '>= 1.9.2'
+  s.required_ruby_version     = '>= 1.8.7'
   s.required_rubygems_version = '>= 1.3.7'
 
   s.add_development_dependency 'rspec'

data/spec/circuit_breaker_spec.rb

@@ -0,0 +1,52 @@
+$: << File.expand_path(File.join(File.dirname( __FILE__ ), '..', 'lib'))
+
+require 'rspec'
+require 'active_record/connection_adapters/master_slave_adapter/circuit_breaker'
+
+describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::CircuitBreaker do
+  let(:logger) { nil }
+  let(:failure_threshold) { 5 }
+  let(:timeout) { 10 }
+
+  subject { described_class.new(logger, failure_threshold, timeout) }
+
+  it 'should not be tripped by default' do
+    should_not be_tripped
+  end
+
+  context "after single failure" do
+    before { subject.fail! }
+
+    it 'should remain untripped' do
+      should_not be_tripped
+    end
+  end
+
+  context "after failure threshold is reached" do
+    before { failure_threshold.times { subject.fail! } }
+
+    it { should be_tripped }
+
+    context "and timeout exceeded" do
+      before do
+        now = Time.now
+        Time.stub(:now).and_return(now + timeout)
+        subject.tripped? # side effect :/
+      end
+
+      it { should_not be_tripped }
+
+      context "after single failure" do
+        before { subject.fail! }
+
+        it { should be_tripped }
+      end
+
+      context "after single success" do
+        before { subject.success! }
+
+        it { should_not be_tripped }
+      end
+    end
+  end
+end

data/spec/master_slave_adapter_spec.rb

@@ -1,18 +1,35 @@
-require 'rubygems'
-require 'active_record'
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
 require 'rspec'
+require 'active_record/connection_adapters/master_slave_adapter'
 
 ActiveRecord::Base.logger =
-  Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+  Logger.new($stdout).tap { |l| l.level = Logger::DEBUG }
 
-$LOAD_PATH << File.expand_path(File.join( File.dirname( __FILE__ ), '..', 'lib' ))
+module ActiveRecord
+  class Base
+    cattr_accessor :master_mock, :slave_mock
+    def self.test_connection(config)
+      config[:database] == 'slave' ? slave_mock : master_mock
+    end
 
-require 'active_record/connection_adapters/master_slave_adapter'
+    def self.test_master_slave_connection(config)
+      TestMasterSlaveAdapter.new(config, logger)
+    end
+  end
+
+  module ConnectionAdapters
+    class TestMasterSlaveAdapter < MasterSlaveAdapter::Base
+      def master_clock
+      end
+
+      def slave_clock(connection)
+      end
 
-class ActiveRecord::Base
-  cattr_accessor :master_mock, :slave_mock
-  def self.test_connection(config)
-    config[:database] == 'slave' ? slave_mock : master_mock
+      def connection_error?(exception)
+        true
+      end
+    end
   end
 end
 
@@ -34,6 +51,7 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
     {
       :reconnect! => true,
       :disconnect! => true,
+      :active? => true,
     }
   end
 
@@ -58,16 +76,10 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
     ActiveRecord::Base.connection
   end
 
-  SchemaStatements = ActiveRecord::ConnectionAdapters::SchemaStatements.instance_methods.map(&:to_sym)
+  SchemaStatements = ActiveRecord::ConnectionAdapters::SchemaStatements.public_instance_methods.map(&:to_sym)
   SelectMethods = [ :select_all, :select_one, :select_rows, :select_value, :select_values ]
-  Clock = ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::Clock
 
   before do
-    unless database_setup[:disable_connection_test] == 'true'
-      [ master_connection, slave_connection ].each do |c|
-        c.should_receive(:active?).exactly(2).times.and_return(true)
-      end
-    end
     ActiveRecord::Base.establish_connection(database_setup)
   end
 
@@ -76,12 +88,6 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
   end
 
   describe 'common configuration' do
-    before do
-      [ master_connection, slave_connection ].each do |c|
-        c.stub!( :select_value ).with( "SELECT 1", "test select" ).and_return( true )
-      end
-    end
-
     it "should call 'columns' on master" do
       master_connection.should_receive(:columns)
       adapter_connection.columns
@@ -145,7 +151,7 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
     end
 
     it 'should be a master slave connection' do
-      adapter_connection.class.should == ActiveRecord::ConnectionAdapters::MasterSlaveAdapter
+      adapter_connection.class.should == ActiveRecord::ConnectionAdapters::TestMasterSlaveAdapter
     end
 
     it 'should have a master connection' do
@@ -153,39 +159,36 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
     end
 
     it 'should have a slave connection' do
-      master_connection.stub!( :open_transactions ).and_return( 0 )
       adapter_connection.slave_connection!.should == slave_connection
     end
   end
 
   describe "connection testing" do
+    before do
+      master_connection.unstub(:active?)
+      slave_connection.unstub(:active?)
+    end
+
     context "disabled" do
       let(:database_setup) do
         default_database_setup.merge(:disable_connection_test => 'true')
       end
 
-      context "on master" do
-        SchemaStatements.each do |method|
-          it "should not perform the testing when #{method} is called" do
-            master_connection.tap do |c|
-              c.should_not_receive(:active?)
-              c.should_receive(method).with('testing').and_return(true)
-            end
-            adapter_connection.send(method, 'testing')
-          end
-        end
+      it "should not perform the testing" do
+        master_connection.should_not_receive(:active?)
+        slave_connection.should_not_receive(:active?)
+
+        adapter_connection.active?.should == true
       end
+    end
 
-      context "on slave" do
-        SelectMethods.each do |method|
-          it "should not perform the testing when #{method} is called" do
-            slave_connection.tap do |c|
-              c.should_not_receive(:active?)
-              c.should_receive(method).with('testing').and_return(true)
-            end
-            adapter_connection.send(method, 'testing')
-          end
-        end
+    context "enabled" do
+      it "should perform the testing" do
+        # twice == one during connection + one on explicit #active? call
+        master_connection.should_receive(:active?).twice.and_return(true)
+        slave_connection.should_receive(:active?).twice.and_return(true)
+
+        adapter_connection.active?.should == true
       end
     end
   end
@@ -196,259 +199,11 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
     end
   end
 
-  describe 'consistency' do
-    before do
-      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
-
-      [ master_connection, slave_connection ].each do |c|
-        c.stub!(:select_value).with("SELECT 1", "test select").and_return(true)
-      end
-    end
-
-    def zero
-      Clock.zero
-    end
-
-    def master_position(pos)
-      Clock.new('', pos)
-    end
-
-    def slave_should_report_clock(pos)
-      pos = Array(pos)
-      values = pos.map { |p| { 'Relay_Master_Log_File' => '', 'Exec_Master_Log_Pos' => p } }
-      slave_connection.
-        should_receive('select_one').exactly(pos.length).with('SHOW SLAVE STATUS').
-        and_return(*values)
-    end
-
-    def master_should_report_clock(pos)
-      pos = Array(pos)
-      values = pos.map { |p| { 'File' => '', 'Position' => p } }
-      master_connection.
-        should_receive('select_one').exactly(pos.length).with('SHOW MASTER STATUS').
-        and_return(*values)
-    end
-
-    SelectMethods.each do |method|
-      it "should raise an exception if consistency is nil" do
-        lambda do
-          ActiveRecord::Base.with_consistency(nil) do
-          end
-        end.should raise_error(ArgumentError)
-      end
-
-      it "should send the method '#{method}' to the slave if clock.zero is given" do
-        slave_should_report_clock(0)
-        slave_connection.should_receive(method).with('testing').and_return(true)
-        old_clock = zero
-        new_clock = ActiveRecord::Base.with_consistency(old_clock) do
-          adapter_connection.send(method, 'testing')
-        end
-        new_clock.should be_a(zero.class)
-        new_clock.should equal(zero)
-      end
-
-      it "should send the method '#{method}' to the master if slave hasn't cought up to required clock yet" do
-        slave_should_report_clock(0)
-        master_connection.should_receive(method).with('testing').and_return(true)
-        old_clock = master_position(1)
-        new_clock = ActiveRecord::Base.with_consistency(old_clock) do
-          adapter_connection.send(method, 'testing' )
-        end
-        new_clock.should be_a(zero.class)
-        new_clock.should equal(old_clock)
-      end
-
-      it "should send the method '#{method}' to the master connection if there are open transactions" do
-        master_connection.stub!(:open_transactions).and_return(1)
-        master_connection.should_receive(method).with('testing').and_return(true)
-        old_clock = zero
-        new_clock = ActiveRecord::Base.with_consistency(old_clock) do
-          adapter_connection.send(method, 'testing')
-        end
-        new_clock.should be_a(zero.class)
-        new_clock.should equal(zero)
-      end
-
-      it "should send the method '#{method}' to the master after a write operation" do
-        slave_should_report_clock(0)
-        master_should_report_clock(2)
-        slave_connection.should_receive(method).with('testing').and_return(true)
-        master_connection.should_receive('update').with('testing').and_return(true)
-        master_connection.should_receive(method).with('testing').and_return(true)
-        old_clock = zero
-        new_clock = ActiveRecord::Base.with_consistency(old_clock) do
-          adapter_connection.send(method, 'testing')   # slave
-          adapter_connection.send('update', 'testing') # master
-          adapter_connection.send(method, 'testing')   # master
-        end
-        new_clock.should be_a(zero.class)
-        new_clock.should > old_clock
-      end
-    end
-
-    it "should update the clock after a transaction" do
-      slave_should_report_clock(0)
-      master_should_report_clock([0, 1, 1])
-
-      slave_connection.
-        should_receive('select_all').exactly(1).times.with('testing').
-        and_return(true)
-
-      master_connection.
-        should_receive('update').exactly(3).times.with('testing').
-        and_return(true)
-      master_connection.
-        should_receive('select_all').exactly(5).times.with('testing').
-        and_return(true)
-      %w(begin_db_transaction
-         commit_db_transaction
-         increment_open_transactions
-         decrement_open_transactions
-         outside_transaction?).each do |txstmt|
-        master_connection.should_receive(txstmt).exactly(1).times
-      end
-
-      master_connection.
-        should_receive('open_transactions').exactly(13).times.
-        and_return(
-          # adapter: with_consistency, select_all, update, select_all
-          0, 0, 0, 0,
-          # connection: transaction
-          0,
-          # adapter: select_all, update, select_all, commit_db_transaction
-          1, 1, 1, 0,
-          # connection: transaction (ensure)
-          0,
-          # adapter: select_all, update, select_all
-          0, 0, 0
-         )
-
-      old_clock = zero
-      new_clock = ActiveRecord::Base.with_consistency(old_clock) do
-        adapter_connection.send('select_all', 'testing') # slave  s=0 m=0
-        adapter_connection.send('update', 'testing')     # master s=0 m=1
-        adapter_connection.send('select_all', 'testing') # master s=0 m=1
-
-        ActiveRecord::Base.transaction do
-          adapter_connection.send('select_all', 'testing') # master s=0 m=1
-          adapter_connection.send('update', 'testing')     # master s=0 m=1
-          adapter_connection.send('select_all', 'testing') # master s=0 m=1
-        end
-
-        adapter_connection.send('select_all', 'testing') # master s=0 m=2
-        adapter_connection.send('update', 'testing')     # master s=0 m=3
-        adapter_connection.send('select_all', 'testing') # master s=0 m=3
-      end
-
-      new_clock.should > old_clock
-    end
-
-    context "with nested with_consistency" do
-      it "should return the same clock if not writing and no lag" do
-        slave_should_report_clock(0) # note: tests memoizing slave clock
-        slave_connection.
-          should_receive('select_one').exactly(3).times.with('testing').
-          and_return(true)
-
-        old_clock = zero
-        new_clock = ActiveRecord::Base.with_consistency(old_clock) do
-          adapter_connection.send('select_one', 'testing')
-          ActiveRecord::Base.with_consistency(old_clock) do
-            adapter_connection.send('select_one', 'testing')
-          end
-          adapter_connection.send('select_one', 'testing')
-        end
-        new_clock.should equal(old_clock)
-      end
-
-      it "requesting a newer clock should return a new clock" do
-        adapter_connection.
-          should_receive('slave_consistent?').exactly(2).times.
-          and_return(true, false)
-        slave_connection.
-          should_receive('select_all').exactly(2).times.with('testing').
-          and_return(true)
-        master_connection.
-          should_receive('select_all').exactly(1).times.with('testing').
-          and_return(true)
-
-        start_clock = zero
-        inner_clock = zero
-        outer_clock = ActiveRecord::Base.with_consistency(start_clock) do
-          adapter_connection.send('select_all', 'testing') # slave
-          inner_clock = ActiveRecord::Base.with_consistency(master_position(1)) do
-            adapter_connection.send('select_all', 'testing') # master
-          end
-          adapter_connection.send('select_all', 'testing') # slave
-        end
-
-        start_clock.should equal(outer_clock)
-        inner_clock.should > start_clock
-      end
-    end
-
-    it "should do the right thing when nested inside with_master" do
-      slave_should_report_clock(0)
-      slave_connection.should_receive('select_all').exactly(1).times.with('testing').and_return(true)
-      master_connection.should_receive('select_all').exactly(2).times.with('testing').and_return(true)
-      ActiveRecord::Base.with_master do
-        adapter_connection.send('select_all', 'testing') # master
-        ActiveRecord::Base.with_consistency(zero) do
-          adapter_connection.send('select_all', 'testing') # slave
-        end
-        adapter_connection.send('select_all', 'testing') # master
-      end
-    end
-
-    it "should do the right thing when nested inside with_slave" do
-      slave_should_report_clock(0)
-      slave_connection.should_receive('select_all').exactly(3).times.with('testing').and_return(true)
-      ActiveRecord::Base.with_slave do
-        adapter_connection.send('select_all', 'testing') # slave
-        ActiveRecord::Base.with_consistency(zero) do
-          adapter_connection.send('select_all', 'testing') # slave
-        end
-        adapter_connection.send('select_all', 'testing') # slave
-      end
-    end
-
-    it "should do the right thing when wrapping with_master" do
-      slave_should_report_clock(0)
-      slave_connection.should_receive('select_all').exactly(2).times.with('testing').and_return(true)
-      master_connection.should_receive('select_all').exactly(1).times.with('testing').and_return(true)
-      ActiveRecord::Base.with_consistency(zero) do
-        adapter_connection.send('select_all', 'testing') # slave
-        ActiveRecord::Base.with_master do
-          adapter_connection.send('select_all', 'testing') # master
-        end
-        adapter_connection.send('select_all', 'testing') # slave
-      end
-    end
-
-    it "should do the right thing when wrapping with_slave" do
-      slave_should_report_clock(0)
-      slave_connection.should_receive('select_all').exactly(1).times.with('testing').and_return(true)
-      master_connection.should_receive('select_all').exactly(2).times.with('testing').and_return(true)
-      ActiveRecord::Base.with_consistency(master_position(1)) do
-        adapter_connection.send('select_all', 'testing') # master
-        ActiveRecord::Base.with_slave do
-          adapter_connection.send('select_all', 'testing') # slave
-        end
-        adapter_connection.send('select_all', 'testing') # master
-      end
-    end
-  end # /with_consistency
-
   describe "transaction callbacks" do
-    before do
-      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
-    end
-
     def run_tx
       adapter_connection.
         should_receive('master_clock').
-        and_return(Clock.new('', 1))
+        and_return(1)
       %w(begin_db_transaction
          commit_db_transaction
          increment_open_transactions