master_slave_adapter_soundcloud 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+tags
+test/*
+pkg/*

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2011 Maurício Linhares,
+                   Torsten Curdt,
+                   Kim Altintop,
+                   Omid Aladini,
+                   SoundCloud Ltd
+
+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/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/active_record/connection_adapters/master_slave_adapter.rb

@@ -0,0 +1 @@
+require 'master_slave_adapter'

data/lib/master_slave_adapter.rb

@@ -0,0 +1,380 @@
+require 'active_record'
+
+module ActiveRecord
+  class Base
+    class << self
+      def with_consistency(clock, &blk)
+        if connection.respond_to? :with_consistency
+          connection.with_consistency(clock, &blk)
+        else
+          yield
+          nil
+        end
+      end
+
+      def with_master(&blk)
+        if connection.respond_to? :with_master
+          connection.with_master(&blk)
+        else
+          yield
+        end
+      end
+
+      def with_slave(&blk)
+        if connection.respond_to? :with_slave
+          connection.with_slave(&blk)
+        else
+          yield
+        end
+      end
+
+      def on_commit(&blk)
+        connection.on_commit(&blk) if connection.respond_to? :on_commit
+      end
+
+      def on_rollback(&blk)
+        connection.on_rollback(&blk) if connection.respond_to? :on_rollback
+      end
+
+      def master_slave_connection(config)
+        config = massage(config)
+        load_adapter(config.fetch(:connection_adapter))
+        ConnectionAdapters::MasterSlaveAdapter.new(config, logger)
+      end
+
+    private
+
+      def massage(config)
+        config = config.symbolize_keys
+        skip = [ :adapter, :connection_adapter, :master, :slaves ]
+        defaults = config.reject { |k,_| skip.include?(k) }
+                         .merge(:adapter => config.fetch(:connection_adapter))
+        ([config.fetch(:master)] + config.fetch(:slaves, [])).map do |cfg|
+          cfg.symbolize_keys!.reverse_merge!(defaults)
+        end
+        config
+      end
+
+      def load_adapter(adapter_name)
+        unless self.respond_to?("#{adapter_name}_connection")
+          begin
+            require 'rubygems'
+            gem "activerecord-#{adapter_name}-adapter"
+            require "active_record/connection_adapters/#{adapter_name}_adapter"
+          rescue LoadError
+            begin
+              require "active_record/connection_adapters/#{adapter_name}_adapter"
+            rescue LoadError
+              raise %Q{Please install the #{adapter_name} adapter:
+                       `gem install activerecord-#{adapter_name}-adapter` (#{$!})"}
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module ConnectionAdapters
+
+    class AbstractAdapter
+      alias_method :orig_log_info, :log_info
+      def log_info(sql, name, ms)
+        connection_name =
+          [ @config[:name], @config[:host], @config[:port] ].compact.join(":")
+        orig_log_info sql, "[#{connection_name}] #{name || 'SQL'}", ms
+      end
+    end
+
+    class MasterSlaveAdapter < AbstractAdapter
+
+      class Clock
+        include Comparable
+        attr_reader :file, :position
+
+        def initialize(file, position)
+          raise ArgumentError, "file and postion may not be nil" if file.nil? || position.nil?
+          @file, @position = file, position.to_i
+        end
+
+        def <=>(other)
+          @file == other.file ? @position <=> other.position : @file <=> other.file
+        end
+
+        def to_s
+          [ @file, @position ].join('@')
+        end
+
+        def self.zero
+          @zero ||= Clock.new('', 0)
+        end
+
+        def self.infinity
+          @infinity ||= Clock.new('', Float::MAX.to_i)
+        end
+      end
+
+      checkout :active?
+
+      def initialize(config, logger)
+        super(nil, logger)
+
+        @connections = {}
+        @connections[:master] = connect(config.fetch(:master), :master)
+        @connections[:slaves] = config.fetch(:slaves).map { |cfg| connect(cfg, :slave) }
+
+        @disable_connection_test = config.delete(:disable_connection_test) == 'true'
+
+        self.current_connection = slave_connection!
+      end
+
+      # MASTER SLAVE ADAPTER INTERFACE ========================================
+
+      def with_master
+        with(self.master_connection, :master) { yield }
+      end
+
+      def with_slave
+        with(self.slave_connection!, :slave) { yield }
+      end
+
+      def with_consistency(clock)
+        raise ArgumentError, "consistency cannot be nil" if clock.nil?
+        # try random slave, else fall back to master
+        slave = slave_connection!
+        conn =
+          if !open_transaction? && slave_clock(slave) >= clock
+            [ slave, :slave ]
+          else
+            [ master_connection, :master ]
+          end
+
+        with(*conn) { yield }
+
+        self.current_clock || clock
+      end
+
+      def on_commit(&blk)
+        on_commit_callbacks.push blk
+      end
+
+      def on_rollback(&blk)
+        on_rollback_callbacks.push blk
+      end
+
+
+      # backwards compatibility
+      class << self
+        def with_master(&blk)
+          ActiveRecord::Base.with_master(&blk)
+        end
+        def with_slave(&blk)
+          ActiveRecord::Base.with_slave(&blk)
+        end
+        def with_consistency(clock, &blk)
+          ActiveRecord::Base.with_consistency(clock, &blk)
+        end
+        def reset!
+          Thread.current[:master_slave_clock]      =
+          Thread.current[:master_slave_connection] =
+          Thread.current[:on_commit_callbacks]     =
+          Thread.current[:on_rollback_callbacks]   =
+          nil
+        end
+      end
+
+      # ADAPTER INTERFACE OVERRIDES ===========================================
+
+      def insert(*args)
+        on_write { |conn| conn.insert(*args) }
+      end
+
+      def update(*args)
+        on_write { |conn| conn.update(*args) }
+      end
+
+      def delete(*args)
+        on_write { |conn| conn.delete(*args) }
+      end
+
+      def commit_db_transaction
+        on_write { |conn| conn.commit_db_transaction }
+        on_commit_callbacks.shift.call(current_clock) until on_commit_callbacks.blank?
+      end
+
+      def rollback_db_transaction
+        on_commit_callbacks.clear
+        with(master_connection, :master) { |conn| conn.rollback_db_transaction }
+        on_rollback_callbacks.shift.call until on_rollback_callbacks.blank?
+      end
+
+      def active?
+        return true if @disable_connection_test
+        self.connections.map { |c| c.active? }.reduce(true) { |m,s| s ? m : s }
+      end
+
+      def reconnect!
+        self.connections.each { |c| c.reconnect! }
+      end
+
+      def disconnect!
+        self.connections.each { |c| c.disconnect! }
+      end
+
+      def reset!
+        self.connections.each { |c| c.reset! }
+      end
+
+      # Someone calling execute directly on the connection is likely to be a
+      # write, respectively some DDL statement. People really shouldn't do that,
+      # but let's delegate this to master, just to be sure.
+      def execute(*args)
+        on_write { |conn| conn.execute(*args) }
+      end
+
+      # ADAPTER INTERFACE DELEGATES ===========================================
+
+      # === must go to master
+      delegate :adapter_name,
+               :supports_migrations?,
+               :supports_primary_key?,
+               :supports_savepoints?,
+               :native_database_types,
+               :raw_connection,
+               :open_transactions,
+               :increment_open_transactions,
+               :decrement_open_transactions,
+               :transaction_joinable=,
+               :create_savepoint,
+               :rollback_to_savepoint,
+               :release_savepoint,
+               :current_savepoint_name,
+               :begin_db_transaction,
+               :to => :master_connection
+      delegate *ActiveRecord::ConnectionAdapters::SchemaStatements.instance_methods,
+               :to => :master_connection
+      # silly: :tables is commented in SchemaStatements.
+      delegate :tables, :to => :master_connection
+      # monkey patch from databasecleaner gem
+      delegate :truncate_table, :to => :master_connection
+
+      # === determine read connection
+      delegate :select_all,
+               :select_one,
+               :select_rows,
+               :select_value,
+               :select_values,
+               :to => :connection_for_read
+
+      def connection_for_read
+        open_transaction? ? master_connection : self.current_connection
+      end
+      private :connection_for_read
+
+      # === doesn't really matter, but must be handled by underlying adapter
+      delegate *ActiveRecord::ConnectionAdapters::Quoting.instance_methods,
+               :to => :current_connection
+
+      # UTIL ==================================================================
+
+      def master_connection
+        @connections[:master]
+      end
+
+      # Returns a random slave connection
+      # Note: the method is not referentially transparent, hence the bang
+      def slave_connection!
+        @connections[:slaves].sample
+      end
+
+      def connections
+        @connections.values.inject([]) { |m,c| m << c }.flatten.compact
+      end
+
+      def current_connection
+        connection_stack.first
+      end
+
+      def current_connection=(conn)
+        connection_stack.unshift conn
+      end
+
+      def current_clock
+        Thread.current[:master_slave_clock]
+      end
+
+      def current_clock=(clock)
+        Thread.current[:master_slave_clock] = clock
+      end
+
+      def master_clock
+        conn = master_connection
+        if status = conn.uncached { conn.select_one("SHOW MASTER STATUS") }
+          Clock.new(status['File'], status['Position'])
+        end
+      end
+
+      def slave_clock(connection = nil)
+        conn ||= slave_connection!
+        if status = conn.uncached { conn.select_one("SHOW SLAVE STATUS") }
+          Clock.new(status['Relay_Master_Log_File'], status['Exec_Master_Log_Pos'])
+        end
+      end
+
+    protected
+
+      def on_write
+        with(master_connection, :master) do |conn|
+          yield(conn).tap do
+            unless open_transaction?
+              if mc = master_clock
+                self.current_clock = mc unless current_clock.try(:>=, mc)
+              end
+              # keep using master after write
+              self.current_connection = conn
+            end
+          end
+        end
+      end
+
+      def with(conn, name)
+        self.current_connection = conn
+        yield(conn).tap { connection_stack.shift }
+      end
+
+    private
+
+      def logger
+        @logger # ||= Logger.new(STDOUT)
+      end
+
+      def info(msg)
+        logger.try(:info, msg)
+      end
+
+      def debug(msg)
+        logger.debug(msg) if logger && logger.debug?
+      end
+
+      def connect(cfg, name)
+        adapter_method = "#{cfg.fetch(:adapter)}_connection".to_sym
+        ActiveRecord::Base.send(adapter_method, { :name => name }.merge(cfg))
+      end
+
+      def open_transaction?
+        master_connection.open_transactions > 0
+      end
+
+      def connection_stack
+        Thread.current[:master_slave_connection] ||= []
+      end
+
+      def on_commit_callbacks
+        Thread.current[:on_commit_callbacks] ||= []
+      end
+
+      def on_rollback_callbacks
+        Thread.current[:on_rollback_callbacks] ||= []
+      end
+    end
+  end
+end

data/master_slave_adapter.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'master_slave_adapter_soundcloud'
+  s.version     = File.read('VERSION').to_s
+  s.date        = '2011-06-21'
+  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.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.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_rubygems_version = '1.3.7'
+  s.add_development_dependency 'rspec'
+
+  s.add_dependency 'activerecord', '= 2.3.9'
+end

data/specs/specs.rb

@@ -0,0 +1,516 @@
+require 'rubygems'
+require 'active_record'
+require 'rspec'
+
+ActiveRecord::Base.logger =
+  Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+
+$LOAD_PATH << File.expand_path(File.join( File.dirname( __FILE__ ), '..', 'lib' ))
+
+require 'active_record/connection_adapters/master_slave_adapter'
+
+class ActiveRecord::Base
+  cattr_accessor :master_mock, :slave_mock
+  def self.test_connection(config)
+    config[:database] == 'slave' ? slave_mock : master_mock
+  end
+end
+
+describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
+  let(:default_database_setup) do
+    {
+      :adapter => 'master_slave',
+      :username => 'root',
+      :database => 'slave',
+      :connection_adapter => 'test',
+      :master => { :username => 'root', :database => 'master' },
+      :slaves => [{ :database => 'slave' }],
+    }
+  end
+
+  let(:database_setup) { default_database_setup }
+
+  let(:mocked_methods) do
+    {
+      #:verify! => true,
+      :reconnect! => true,
+      #:run_callbacks => true,
+      :disconnect! => true,
+    }
+  end
+
+  let!(:master_connection) do
+    mock(
+      'master connection',
+      mocked_methods.merge(:open_transactions => 0)
+    ).tap do |conn|
+      conn.stub!(:uncached) { |blk| blk.call }
+      ActiveRecord::Base.master_mock = conn
+    end
+  end
+
+  let!(:slave_connection) do
+    mock('slave connection', mocked_methods).tap do |conn|
+      conn.stub!(:uncached) { |blk| blk.call }
+      ActiveRecord::Base.slave_mock = conn
+    end
+  end
+
+  def adapter_connection
+    ActiveRecord::Base.connection
+  end
+
+  SchemaStatements = ActiveRecord::ConnectionAdapters::SchemaStatements.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
+
+  after do
+    ActiveRecord::Base.connection_handler.clear_all_connections!
+  end
+
+  describe 'with 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
+
+    xit "should call 'columns' on master" do
+    end
+
+    SelectMethods.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 )
+        adapter_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
+          adapter_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
+          adapter_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
+          adapter_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
+          adapter_connection.send( method, 'testing' )
+        end
+      end
+    end # /SelectMethods.each
+
+    SchemaStatements.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 )
+        adapter_connection.send( method )
+      end
+    end
+
+    (SchemaStatements - SelectMethods).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 )
+        adapter_connection.send( method )
+      end
+    end
+
+    it 'should be a master slave connection' do
+      adapter_connection.class.should == ActiveRecord::ConnectionAdapters::MasterSlaveAdapter
+    end
+
+    it 'should have a master connection' do
+      adapter_connection.master_connection.should == master_connection
+    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
+
+  context "connection testing" do
+    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
+      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
+      end
+    end
+  end
+
+  describe 'with connection eager loading enabled' do
+    it 'should eager load the connections' do
+      adapter_connection.connections.should include(master_connection, slave_connection)
+    end
+  end
+
+  describe 'with 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).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, 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
+          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
+        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
+          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))
+      %w(begin_db_transaction
+         commit_db_transaction
+         increment_open_transactions
+         decrement_open_transactions).each do |txstmt|
+        master_connection
+          .should_receive(txstmt).exactly(1).times
+      end
+      master_connection
+        .should_receive('open_transactions').exactly(4).times
+        .and_return(0, 1, 0, 0)
+
+      master_connection
+        .should_receive('update').with('testing')
+        .and_return(true)
+
+      ActiveRecord::Base.transaction do
+        adapter_connection.send('update', 'testing')
+      end
+    end
+
+    def fail_tx
+      %w(begin_db_transaction
+         rollback_db_transaction
+         increment_open_transactions
+         decrement_open_transactions).each do |txstmt|
+        master_connection
+          .should_receive(txstmt).exactly(1).times
+      end
+      master_connection
+        .should_receive('open_transactions').exactly(3).times
+        .and_return(0, 1, 0)
+      master_connection
+        .should_receive('update').with('testing')
+        .and_return(true)
+
+      ActiveRecord::Base.transaction do
+        adapter_connection.send('update', 'testing')
+        raise "rollback"
+      end
+    rescue
+      nil
+    end
+
+    context "on commit" do
+      it "on_commit callback should be called" do
+        x = false
+        adapter_connection.on_commit { x = true }
+        lambda { run_tx }.should change { x }.to(true)
+      end
+
+      it "on_rollback callback should not be called" do
+        x = false
+        adapter_connection.on_rollback { x = true }
+        lambda { run_tx }.should_not change { x }
+      end
+    end
+
+    context "rollback" do
+      it "on_commit callback should not be called" do
+        x = false
+        adapter_connection.on_commit { x = true }
+        lambda { fail_tx }.should_not change { x }
+      end
+
+      it "on_rollback callback should be called" do
+        x = false
+        adapter_connection.on_rollback { x = true }
+        lambda { fail_tx }.should change { x }.to(true)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: master_slave_adapter_soundcloud
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mauricio Linhares
+- Torsten Curdt
+- Kim Altintop
+- Omid Aladini
+- SoundCloud
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-21 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 9
+        version: 2.3.9
+  type: :runtime
+  version_requirements: *id002
+description: (MySQL) Replication Aware Master/Slave Database Adapter for Rails/ActiveRecord
+email: kim@soundcloud.com tcurdt@soundcloud.com omid@soundcloud.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- lib/active_record/connection_adapters/master_slave_adapter.rb
+- lib/master_slave_adapter.rb
+- master_slave_adapter.gemspec
+- specs/specs.rb
+has_rdoc: true
+homepage: http://github.com/soundcloud/master_slave_adapter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 2
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - "="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 7
+      version: 1.3.7
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Replication Aware Master/Slave Database Adapter for Rails/ActiveRecord
+test_files: []
+