master_slave_adapter_tcurdt 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.rvmrc
+nbproject

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Maurício Linhares, Torsten Curdt
+
+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/README

@@ -0,0 +1,43 @@
+master_slave_adapter
+====
+
+This simple plugin acts as a common ActiveRecord adapter and allows you to
+setup a master-slave environment using any database you like (and is supported
+by ActiveRecord).
+
+This plugin works by handling two connections, one to a master database,
+that will receive all non-"SELECT" statements, and another to a slave database
+that that is going to receive all SELECT statements. It also tries to do as
+little black magic as possible, it works just like any other ActiveRecord database
+adapter and performs no monkeypatching at all, so it's easy and simple to use
+and understand.
+
+The master database connection will also receive SELECT calls if a transaction
+is active at the moment or if a command is executed inside a "with_master" block:
+
+ActiveRecord::Base.with_master do # :with_master instructs the adapter
+    @users = User.all             # to use the master connection inside the block
+end
+
+To use this adapter you just have to install the plugin:
+
+ruby script/plugin install git://github.com/tcurdt/master_slave_adapter_mauricio.git
+
+And then configure it at your database.yml file:
+
+development:
+  database: sample_development
+  username: root
+  adapter: master_slave             # the adapter must be set to "master_slave"
+  host: 10.21.34.80
+  master_slave_adapter: mysql       # here's where you'll place the real database adapter name
+  disable_connection_test: true     # this will disable the connection test before use,
+                                    # can possibly improve the performance but you could also
+                                    # hit stale connections, default is false
+  eager_load_connections: true      # connections are lazy loaded by default, you can load gem eagerly setting this to true
+  master:                           # and here's where you'll add the master database configuration
+    database: talkies_development   # you shouldn't specify an "adapter" here, the
+    username: root                  # value at "master_slave_adapter" is going to be used
+    host: 10.21.34.82
+    adapter: postgresql             # you can use another adapter for the master connection if needed
+                                    # if you don't set it the "master_slave_adapter" property will be used

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/active_record/connection_adapters/master_slave_adapter.rb

@@ -0,0 +1,6 @@
+require 'active_record/connection_adapters/abstract/database_statements'
+require 'active_record/connection_adapters/abstract/schema_statements'
+
+require 'master_slave_adapter/adapter'
+require 'master_slave_adapter/instance_methods_generation'
+require 'master_slave_adapter/active_record_extensions'

data/lib/master_slave_adapter.rb

@@ -0,0 +1,7 @@
+require 'active_record/connection_adapters/master_slave_adapter'
+
+require 'master_slave_adapter/active_record_extension'
+require 'master_slave_adapter/adapter'
+require 'master_slave_adapter/instance_methods_generation'
+
+require 'master_slave_adapter/version'

data/lib/master_slave_adapter/active_record_extensions.rb

@@ -0,0 +1,82 @@
+ActiveRecord::Base.class_eval do
+
+  def reload_with_master( options = nil )
+    ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.with_master do
+      reload_without_master( options )
+    end
+  end
+
+  alias_method_chain :reload, :master
+
+  class << self
+
+    # Call this method to force a block of code to use the master connection
+    #
+    # ActiveRecord::Base.with_master do
+    #   User.count( :conditions => { :login => 'testuser' } )
+    # end
+    def with_master
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.with_master do
+        yield
+      end
+    end
+
+    # Call this method to force a block of code to use the slave connection
+    #
+    # ActiveRecord::Base.with_slave do
+    #   User.count( :conditions => { :login => 'testuser' } )
+    # end
+    def with_slave
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.with_slave do
+        yield
+      end
+    end
+
+    # Call this method to force a certain binlog position.
+    # Going to the slave if it's already at the position otherwise
+    # falling back to master.
+    #
+    # consistency = ActiveRecord::Base.with_consistency(consistency) do
+    #   User.count( :conditions => { :login => 'testuser' } )
+    # end
+    def with_consistency(consistency)
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.with_consistency(consistency) do
+        yield
+      end
+    end
+
+    def master_slave_connection( config )
+      config = config.symbolize_keys
+      raise "You must provide a configuration for the master database - #{config.inspect}" if config[:master].blank?
+      raise "You must provide a 'master_slave_adapter' value at your database config file" if config[:master_slave_adapter].blank?
+
+      unless self.respond_to?( "#{config[:master_slave_adapter]}_connection" )
+
+        begin
+          require 'rubygems'
+          gem "activerecord-#{config[:master_slave_adapter]}-adapter"
+          require "active_record/connection_adapters/#{config[:master_slave_adapter]}_adapter"
+        rescue LoadError
+          begin
+            require "active_record/connection_adapters/#{config[:master_slave_adapter]}_adapter"
+          rescue LoadError
+            raise "Please install the #{config[:master_slave_adapter]} adapter: `gem install activerecord-#{config[:master_slave_adapter]}-adapter` (#{$!})"
+          end
+        end
+
+      end
+
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.new( config )
+    end
+
+    def columns_with_master
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.with_master do
+        columns_without_master
+      end
+    end
+
+    alias_method_chain :columns, :master
+
+  end
+
+end

data/lib/master_slave_adapter/adapter.rb

@@ -0,0 +1,256 @@
+module ActiveRecord
+
+  module ConnectionAdapters
+
+    class MasterSlaveAdapter
+
+      class Clock
+        include Comparable
+        attr_reader :file, :position
+        def initialize(file, position)
+          @file, @position = file, position.to_i
+        end
+        def <=>(other)
+          @file == other.file ? @position <=> other.position : @file <=> other.file
+        end
+        def to_s
+          "#{@file}@#{@position}"
+        end
+        def self.zero
+          @zero ||= Clock.new('', 0)
+        end
+     end
+
+      SELECT_METHODS = [ :select_all, :select_one, :select_rows, :select_value, :select_values ]
+
+      include ActiveSupport::Callbacks
+      define_callbacks :checkout, :checkin
+
+      checkout :test_connections
+
+      attr_accessor :connections
+      attr_accessor :master_config
+      attr_accessor :slave_config
+      attr_accessor :disable_connection_test
+
+
+      delegate :select_all, :select_one, :select_rows, :select_value, :select_values, :to => :select_connection
+
+      def initialize( config )
+        if config[:master].blank?
+          raise "There is no :master config in the database configuration provided -> #{config.inspect} "
+        end
+        self.slave_config = config.symbolize_keys
+        self.master_config = self.slave_config.delete(:master).symbolize_keys
+        self.slave_config[:adapter] = self.slave_config.delete(:master_slave_adapter)
+        self.master_config[:adapter] ||= self.slave_config[:adapter]
+        self.disable_connection_test = self.slave_config.delete( :disable_connection_test ) == 'true'
+        self.connections = []
+        if self.slave_config.delete( :eager_load_connections ) == 'true'
+          connect_to_master
+          connect_to_slave
+        end
+      end
+
+      def insert(sql, *args)
+        on_write do
+          self.master_connection.insert(sql, *args)
+        end
+      end
+
+      def update(sql, *args)
+        on_write do
+          self.master_connection.update(sql, *args)
+        end
+      end
+
+      def delete(sql, *args)
+        on_write do
+          self.master_connection.delete(sql, *args)
+        end
+      end
+
+      def commit_db_transaction()
+        on_write do
+          self.master_connection.commit_db_transaction()
+        end
+      end
+  
+      def reconnect!
+        @active = true
+        self.connections.each { |c| c.reconnect! }
+      end
+
+      def disconnect!
+        @active = false
+        self.connections.each { |c| c.disconnect! }
+      end
+
+      def reset!
+        self.connections.each { |c| c.reset! }
+      end
+
+      def method_missing( name, *args, &block )
+        self.master_connection.send( name.to_sym, *args, &block )
+      end
+
+      def master_connection
+        connect_to_master
+      end
+
+      def slave_connection
+        connect_to_slave
+      end
+
+      def connections
+        [ @master_connection, @slave_connection ].compact
+      end
+
+      def test_connections
+        return if self.disable_connection_test
+        self.connections.each do |c|
+          begin
+            c.select_value( 'SELECT 1', 'test select' )
+          rescue
+            c.reconnect!
+          end
+        end
+      end
+
+      class << self
+
+        def with_master
+          Thread.current[:master_slave_select_connection] = [ :master ] + (Thread.current[:master_slave_select_connection]||[])
+          result = yield
+          Thread.current[:master_slave_select_connection] = Thread.current[:master_slave_select_connection].drop(1)
+          result
+        end
+
+        def with_slave
+          Thread.current[:master_slave_select_connection] = [ :slave ] + (Thread.current[:master_slave_select_connection]||[])
+          result = yield
+          Thread.current[:master_slave_select_connection] = Thread.current[:master_slave_select_connection].drop(1)
+          result
+        end
+
+
+        def with_consistency(clock)
+          raise ArgumentError, "consistency cannot be nil" if !clock
+
+          Thread.current[:master_slave_select_connection] = [ nil ] + (Thread.current[:master_slave_select_connection]||[])
+          Thread.current[:master_slave_clock] = [ clock || Clock::zero ] + (Thread.current[:master_slave_clock]||[])
+
+          yield
+          result = Thread.current[:master_slave_clock][0]
+
+          Thread.current[:master_slave_clock] = Thread.current[:master_slave_clock].drop(1)
+          Thread.current[:master_slave_select_connection] = Thread.current[:master_slave_select_connection].drop(1)
+          result
+        end
+
+        def reset!
+          Thread.current[:master_slave_select_connection] = nil
+          Thread.current[:master_slave_clock] = nil
+        end
+
+        def master_forced?
+          Thread.current[:master_slave_enabled] == true
+        end
+
+        def master_forced=(state)
+          Thread.current[:master_slave_enabled] = state ? true : nil
+        end
+
+        def using_master?
+          if Thread.current[:master_slave_select_connection]
+            Thread.current[:master_slave_select_connection][0] == :master
+          else
+            nil
+          end
+        end
+
+      end
+
+      private
+
+      def update_clock
+        # update the clock, if there was problem keep using the old one
+        Thread.current[:master_slave_clock][0] = master_clock || Thread.current[:master_slave_clock][0]
+        # it's a write so from now on we use the master connection
+        # as replication is not likely to be that fast
+        Thread.current[:master_slave_select_connection][0] = :master
+      end
+
+      def on_write
+        result = yield
+        if !MasterSlaveAdapter.master_forced? && @master_connection.open_transactions == 0
+          update_clock
+        end
+        result
+      end
+
+      def connection_for_clock(required_clock)
+        if required_clock
+          # check the slave for it's replication state
+          if clock = slave_clock
+            if clock >= required_clock
+              # slave is safe to use
+              :slave
+            else
+              # slave is not there yet
+              :master
+            end
+          else
+            # not getting slave status, better turn to master
+            # maybe this should be logged or raised?
+            :master
+          end
+        else
+          # no required clock so slave is good enough
+          :slave
+        end
+      end
+
+      def select_connection
+        connection_stack = Thread.current[:master_slave_select_connection] ||= []
+        clock_stack = Thread.current[:master_slave_clock] ||= []
+
+        # pick the right connection
+        if MasterSlaveAdapter.master_forced? || @master_connection.open_transactions > 0
+          connection_stack[0] = :master
+        end
+        connection_stack[0] ||= connection_for_clock(clock_stack[0])
+
+        # return the current connection
+        if connection_stack[0] == :slave
+          slave_connection
+        else
+          master_connection
+        end
+      end
+
+      def master_clock
+        if status = connect_to_master.select_one("SHOW MASTER STATUS")
+          Clock.new(status['File'], status['Position'])
+        end
+      end
+
+      def slave_clock
+        if status = connect_to_slave.select_one("SHOW SLAVE STATUS")
+          Clock.new(status['Master_Log_File'], status['Exec_Master_Log_Pos'])
+        end
+      end
+
+      def connect_to_master
+        @master_connection ||= ActiveRecord::Base.send( "#{self.master_config[:adapter]}_connection", self.master_config )
+      end
+
+      def connect_to_slave
+        @slave_connection ||= ActiveRecord::Base.send( "#{self.slave_config[:adapter]}_connection", self.slave_config)
+      end
+
+    end
+
+  end
+
+end

data/lib/master_slave_adapter/instance_methods_generation.rb

@@ -0,0 +1,20 @@
+ignored_methods = ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::SELECT_METHODS + ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.instance_methods
+ignored_methods.uniq!
+ignored_methods.map! { |v| v.to_sym }
+
+instance_methods = ActiveRecord::ConnectionAdapters::DatabaseStatements.instance_methods + ActiveRecord::ConnectionAdapters::SchemaStatements.instance_methods
+instance_methods.uniq!
+instance_methods.map! { |v| v.to_sym }
+instance_methods.reject! { |v| ignored_methods.include?( v ) }
+
+instance_methods.each do |method|
+
+  ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.class_eval %Q!
+
+    def #{method}( *args, &block )
+        self.master_connection.#{method}( *args, &block )
+    end
+
+  !
+
+end

data/lib/master_slave_adapter/version.rb

@@ -0,0 +1,3 @@
+module MasterSlaveAdapter
+  VERSION = "0.0.1"
+end

data/master_slave_adapter.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "master_slave_adapter/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'master_slave_adapter_tcurdt'
+  s.version     = MasterSlaveAdapter::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ 'Mauricio Linhares', 'Torsten Curdt' ]
+  s.email       = 'tcurdt at vafer.org'
+  s.homepage    = 'http://github.com/tcurdt/master_slave_adapter_mauricio'
+  s.summary     = 'Master Slave Adapter'
+  s.description = 'Acts as a ActiveRecord adapter and allows you to setup a master-slave environment.'
+
+  s.rubyforge_project = "master_slave_adapter_tcurdt"
+
+  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" ]
+
+  s.add_dependency('activerecord', [ "= 2.3.9" ])
+end

data/specs/specs.rb

@@ -0,0 +1,407 @@
+require 'rubygems'
+require 'active_record'
+require 'spec'
+
+$LOAD_PATH << File.expand_path(File.join( File.dirname( __FILE__ ), '..', 'lib' ))
+
+require 'active_record/connection_adapters/master_slave_adapter'
+
+ActiveRecord::Base.instance_eval do
+
+  def test_connection( config )
+    config[:database] == 'slave' ? _slave : _master
+  end
+
+  def _master=( new_master )
+    @_master = new_master
+  end
+
+  def _master
+    @_master
+  end
+
+  def _slave=( new_slave )
+    @_slave = new_slave
+  end
+
+  def _slave
+    @_slave
+  end
+
+end
+
+describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
+
+  before do
+
+    @mocked_methods = { :verify! => true, :reconnect! => true, :run_callbacks => true, :disconnect! => true }
+
+    ActiveRecord::Base._master = mock( 'master connection', @mocked_methods.merge( :open_transactions => 0 )  )
+    ActiveRecord::Base._slave = mock( 'slave connection', @mocked_methods )
+
+    @master_connection = ActiveRecord::Base._master
+    @slave_connection = ActiveRecord::Base._slave
+
+  end
+
+  after do
+    ActiveRecord::Base.connection_handler.clear_all_connections!
+  end
+
+  describe 'with common configuration' do
+
+
+    before do
+
+      @database_setup = {
+        :adapter => 'master_slave',
+        :username => 'root',
+        :database => 'slave',
+        :master_slave_adapter => 'test',
+        :master => { :username => 'root', :database => 'master' }
+      }
+
+      ActiveRecord::Base.establish_connection( @database_setup )
+
+      [ @master_connection, @slave_connection ].each do |c|
+        c.stub!( :select_value ).with( "SELECT 1", "test select" ).and_return( true )
+      end
+
+    end
+
+    ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::SELECT_METHODS.each do |method|
+
+      it "should send the method '#{method}' to the slave connection" do
+        @master_connection.stub!( :open_transactions ).and_return( 0 )
+        @slave_connection.should_receive( method ).with('testing').and_return( true )
+        ActiveRecord::Base.connection.send( method, 'testing' )
+      end
+
+      it "should send the method '#{method}' to the master connection if with_master was specified" do
+        @master_connection.should_receive( method ).with('testing').and_return( true )
+        ActiveRecord::Base.with_master do
+          ActiveRecord::Base.connection.send( method, 'testing' )
+        end
+      end
+
+      it "should send the method '#{method}' to the slave connection if with_slave was specified" do
+        @slave_connection.should_receive( method ).with('testing').and_return( true )
+        ActiveRecord::Base.with_slave do
+          ActiveRecord::Base.connection.send( method, 'testing' )
+        end
+      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 )
+        ActiveRecord::Base.with_master do
+          ActiveRecord::Base.connection.send( method, 'testing' )
+        end
+      end
+
+      it "should send the method '#{method}' to the master connection if there are open transactions, even in with_slave" do
+        @master_connection.stub!( :open_transactions ).and_return( 1 )
+        @master_connection.should_receive( method ).with('testing').and_return( true )
+        ActiveRecord::Base.with_slave do
+          ActiveRecord::Base.connection.send( method, 'testing' )
+        end
+      end
+
+    end
+
+    ActiveRecord::ConnectionAdapters::SchemaStatements.instance_methods.map(&:to_sym).each do |method|
+
+      it "should send the method '#{method}' from ActiveRecord::ConnectionAdapters::SchemaStatements to the master"  do
+        @master_connection.should_receive( method ).and_return( true )
+        ActiveRecord::Base.connection.send( method )
+      end
+
+    end
+
+    (ActiveRecord::ConnectionAdapters::SchemaStatements.instance_methods.map(&:to_sym) - ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::SELECT_METHODS).each do |method|
+
+      it "should send the method '#{method}' from ActiveRecord::ConnectionAdapters::DatabaseStatements to the master"  do
+        @master_connection.should_receive( method ).and_return( true )
+        ActiveRecord::Base.connection.send( method )
+      end
+
+    end
+
+    it 'should be a master slave connection' do
+      ActiveRecord::Base.connection.class.should == ActiveRecord::ConnectionAdapters::MasterSlaveAdapter
+    end
+
+    it 'should have a master connection' do
+      ActiveRecord::Base.connection.master_connection.should == @master_connection
+    end
+
+    it 'should have a slave connection' do
+      @master_connection.stub!( :open_transactions ).and_return( 0 )
+      ActiveRecord::Base.connection.slave_connection.should == @slave_connection
+    end
+
+  end
+
+  describe 'with connection testing disabled' do
+
+    before do
+      @database_setup = {
+        :adapter => 'master_slave',
+        :username => 'root',
+        :database => 'slave',
+        :disable_connection_test => 'true',
+        :master_slave_adapter => 'test',
+        :master => { :username => 'root', :database => 'master' }
+      }
+
+      ActiveRecord::Base.establish_connection( @database_setup )
+
+    end
+
+    ActiveRecord::ConnectionAdapters::SchemaStatements.instance_methods.map(&:to_sym).each do |method|
+
+      it "should not perform the testing select on the master if #{method} is called" do
+        @master_connection.should_not_receive( :select_value ).with( "SELECT 1", "test select" )
+        @master_connection.should_receive( method ).with('testing').and_return(true)
+        ActiveRecord::Base.connection.send(method, 'testing')
+      end
+
+    end
+
+    ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::SELECT_METHODS.each do |method|
+
+      it "should not perform the testing select on the slave if #{method} is called" do
+        @slave_connection.should_not_receive( :select_value ).with( "SELECT 1", "test select" )
+        @slave_connection.should_receive( method ).with('testing').and_return(true)
+        ActiveRecord::Base.connection.send(method, 'testing')
+      end
+
+    end
+
+  end
+
+  describe 'with connection eager loading enabled' do
+
+    before do
+      @database_setup = {
+        :adapter => 'master_slave',
+        :username => 'root',
+        :database => 'slave',
+        :eager_load_connections => 'true',
+        :master_slave_adapter => 'test',
+        :master => { :username => 'root', :database => 'master' }
+      }
+
+      ActiveRecord::Base.establish_connection( @database_setup )
+
+      [ @master_connection, @slave_connection ].each do |c|
+        c.should_receive( :select_value ).with( "SELECT 1", "test select" ).and_return( true )
+      end
+
+    end
+
+    it 'should load the master connection before any method call' do
+      ActiveRecord::Base.connection.instance_variable_get(:@master_connection).should == @master_connection
+    end
+
+    it 'should load the slave connection before any method call' do
+      ActiveRecord::Base.connection.instance_variable_get(:@slave_connection).should == @slave_connection
+    end
+
+  end
+
+  describe 'with consistency' do
+    before do
+
+      @database_setup = {
+        :adapter => 'master_slave',
+        :username => 'root',
+        :database => 'slave',
+        :master_slave_adapter => 'test',
+        :master => { :username => 'root', :database => 'master' }
+      }
+
+      ActiveRecord::Base.establish_connection( @database_setup )
+
+      [ @master_connection, @slave_connection ].each do |c|
+        c.stub!( :select_value ).with( "SELECT 1", "test select" ).and_return( true )
+      end
+
+    end
+
+    def zero
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::Clock.zero
+    end
+
+    def master_position(pos)
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::Clock.new('', pos)
+    end
+
+    def slave_should_report_clock(pos)
+      if pos.instance_of? Fixnum
+        pos = [ pos ]
+      end
+      values = pos.map { |p| { '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)
+      if pos.instance_of? Fixnum
+        pos = [ pos ]
+      end
+      values = pos.map { |p| { 'File' => '', 'Position' => p } }
+      @master_connection.should_receive('select_one').exactly(pos.length).with('SHOW MASTER STATUS').and_return(*values)
+    end
+
+    ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::SELECT_METHODS.each do |method|
+      it "should raise an exception if consistency is nil" do
+        ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+        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
+        ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+        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
+          ActiveRecord::Base.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
+        ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+        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
+          ActiveRecord::Base.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
+        ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+        @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
+          ActiveRecord::Base.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
+        ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+        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
+          ActiveRecord::Base.connection.send(method, 'testing')
+          ActiveRecord::Base.connection.send('update', 'testing')
+          ActiveRecord::Base.connection.send(method, 'testing')
+        end
+        new_clock.should be_a(zero.class)
+        new_clock.should > old_clock
+      end
+
+    end
+
+    it "should do the right thing when nested inside with_consistency" do
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+      slave_should_report_clock([ 0, 0 ])
+      @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
+        ActiveRecord::Base.connection.send('select_one', 'testing')
+        ActiveRecord::Base.with_consistency(old_clock) do
+          ActiveRecord::Base.connection.send('select_one', 'testing')
+        end
+        ActiveRecord::Base.connection.send('select_one', 'testing')
+      end
+      new_clock.should equal(old_clock)
+
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+      slave_should_report_clock([0,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)
+      start_clock = zero
+      inner_clock = zero
+      outer_clock = ActiveRecord::Base.with_consistency(start_clock) do
+        ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+        inner_clock = ActiveRecord::Base.with_consistency(master_position(1)) do
+          ActiveRecord::Base.connection.send('select_all', 'testing') # master
+        end
+        ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+      end
+      start_clock.should equal(outer_clock)
+      inner_clock.should > start_clock
+    end
+
+    it "should do the right thing when nested inside with_master" do
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+      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
+        ActiveRecord::Base.connection.send('select_all', 'testing') # master
+        ActiveRecord::Base.with_consistency(zero) do
+          ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+        end
+        ActiveRecord::Base.connection.send('select_all', 'testing') # master
+      end
+    end
+
+    it "should do the right thing when nested inside with_slave" do
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+      slave_should_report_clock(0)
+      @slave_connection.should_receive('select_all').exactly(3).times.with('testing').and_return(true)
+      ActiveRecord::Base.with_slave do
+        ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+        ActiveRecord::Base.with_consistency(zero) do
+          ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+        end
+        ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+      end
+    end
+
+    it "should do the right thing when wrapping with_master" do
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+      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
+        ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+        ActiveRecord::Base.with_master do
+          ActiveRecord::Base.connection.send('select_all', 'testing') # master
+        end
+        ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+      end
+    end
+
+    it "should do the right thing when wrapping with_slave" do
+      ActiveRecord::ConnectionAdapters::MasterSlaveAdapter.reset!
+      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
+        ActiveRecord::Base.connection.send('select_all', 'testing') # master
+        ActiveRecord::Base.with_slave do
+          ActiveRecord::Base.connection.send('select_all', 'testing') # slave
+        end
+        ActiveRecord::Base.connection.send('select_all', 'testing') # master
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: master_slave_adapter_tcurdt
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mauricio Linhares
+- Torsten Curdt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-30 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 9
+        version: 2.3.9
+  type: :runtime
+  version_requirements: *id001
+description: Acts as a ActiveRecord adapter and allows you to setup a master-slave environment.
+email: tcurdt at vafer.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- lib/active_record/connection_adapters/master_slave_adapter.rb
+- lib/master_slave_adapter.rb
+- lib/master_slave_adapter/active_record_extensions.rb
+- lib/master_slave_adapter/adapter.rb
+- lib/master_slave_adapter/instance_methods_generation.rb
+- lib/master_slave_adapter/version.rb
+- master_slave_adapter.gemspec
+- specs/specs.rb
+has_rdoc: true
+homepage: http://github.com/tcurdt/master_slave_adapter_mauricio
+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: master_slave_adapter_tcurdt
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Master Slave Adapter
+test_files: []
+