active_record_slave 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85a394f332c93d140dda4319bd811a50332bbb3a
-  data.tar.gz: 9eb811c94d7d43de483569245d587530a7a4725f
+  metadata.gz: 36a8b052ee4be85af18beb8a350ddd263cb4e1f2
+  data.tar.gz: 81d762a267ec60c7262d37a24833f55adbfaf157
 SHA512:
-  metadata.gz: 00eb5c81081b4c205843f7a65aa7fef94f4e6614f35dfb662b0832bb2ec79813dd25fc50edb7aaa8cd612d545bf0eeb9053383d6653ee021d22fe702bce13402
-  data.tar.gz: 3e9ffeb4eb9cbe4bfea45ad2450af2c420a49b4095680a45baaa9e607d1fd49fed600d57f9b24be673da6698518eb75c36df0eed497d98251071605e3762f47f
+  metadata.gz: 1a1feef3f440cd51d70f227f5f3cafda84468856cf273b43761eb23869290ed70a3246ed4b3c90c790c86b27470637aa24292ca5cabb2a6d40f8a6c566adafd7
+  data.tar.gz: 12c4a82745181c284ed244e31e0e1a103d42e7a93a251b3ac9ea6680a4a7392501bb2f98f07c23ac26974f6fbe7c33823a4621fc68bba3fa67d3d4b1d77b0513

data/LICENSE.txt

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2012 Clarity Services, Inc.
+   Copyright 2012, 2013, 2014 Reid Morrison
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -1,4 +1,4 @@
-active_record_slave
+active_record_slave [![Build Status](https://secure.travis-ci.org/reidmorrison/active_record_slave.png?branch=master)](http://travis-ci.org/reidmorrison/active_record_slave)
 ===================
 
 ActiveRecord drop-in solution to efficiently redirect reads to slave databases
@@ -91,6 +91,39 @@ D, [2012-11-06T19:43:26.891667 #89002] DEBUG -- :   SQL (0.4ms)  DELETE FROM "us
 D, [2012-11-06T19:43:26.892697 #89002] DEBUG -- :    (0.9ms)  commit transaction
 ```
 
+## Transactions
+
+By default ActiveRecordSlave detects when a call is inside a transaction and will
+send all reads to the _master_ when a transaction is active.
+
+With the latest Rails releases, Rails automatically wraps all Controller Action
+calls with a transaction, effectively sending all reads to the master database.
+
+It is now possible to send reads to database slaves and ignore whether currently
+inside a transaction:
+
+In file config/application.rb:
+
+```ruby
+# Read from slave even when in an active transaction
+config.active_record_slave.ignore_transactions = true
+```
+
+It is important to identify any code in the application that depends on being
+able to read any changes already part of the transaction, but not yet committed
+and wrap those reads with `ActiveRecordSlave.read_from_master`
+
+```ruby
+# Create a new inquiry
+Inquiry.create
+
+# Then make sure that the new inquiry that is not yet committed is visible during
+# the read below:
+ActiveRecordSlave.read_from_master do
+  count = Inquiry.count
+end
+```
+
 ## Dependencies
 
 * Tested on Rails 3 and Rails 4

data/lib/active_record_slave/active_record_slave.rb

@@ -25,9 +25,11 @@ module ActiveRecordSlave
       # Inject a new #select method into the ActiveRecord Database adapter
       base = adapter_class || ActiveRecord::Base.connection.class
       base.send(:include, InstanceMethods)
-      base.alias_method_chain(:select, :slave_reader)
+      SELECT_METHODS.each do |select_method|
+        base.alias_method_chain(select_method, :slave_reader)
+      end
     else
-      ActiveRecord::Base.logger.info "ActiveRecordSlave no slave database defined"
+      ActiveRecord::Base.logger.info "ActiveRecordSlave not installed since no slave database defined"
     end
   end
 
@@ -45,37 +47,67 @@ module ActiveRecordSlave
     end
   end
 
-  if RUBY_VERSION.to_i >= 2
-    # Fibers have their own thread local variables so use thread_variable_get
+  # Whether this thread is currently forcing all reads to go against the master database
+  def self.read_from_master?
+    thread_variable_get(:active_record_slave) == :master
+  end
 
-    # Whether this thread is currently forcing all reads to go against the master database
-    def self.read_from_master?
-      Thread.current.thread_variable_get(:active_record_slave) == :master
-    end
+  # Force all subsequent reads on this thread and any fibers called by this thread to go the master
+  def self.read_from_master!
+    thread_variable_set(:active_record_slave, :master)
+  end
 
-    # Force all subsequent reads on this thread and any fibers called by this thread to go the master
-    def self.read_from_master!
-      Thread.current.thread_variable_set(:active_record_slave, :master)
-    end
+  # Subsequent reads on this thread and any fibers called by this thread can go to a slave
+  def self.read_from_slave!
+    thread_variable_set(:active_record_slave, nil)
+  end
+
+  # Returns whether slave reads are ignoring transactions
+  def self.ignore_transactions?
+    @ignore_transactions
+  end
+
+  # Set whether slave reads should ignore transactions
+  def self.ignore_transactions=(ignore_transactions)
+    @ignore_transactions = ignore_transactions
+  end
 
-    # Subsequent reads on this thread and any fibers called by this thread can go to a slave
-    def self.read_from_slave!
-      Thread.current.thread_variable_set(:active_record_slave, nil)
+  ##############################################################################
+  private
+
+  @ignore_transactions = false
+
+  # Returns the value of the local thread variable
+  #
+  # Parameters
+  #   variable [Symbol]
+  #     Name of variable to get
+  if RUBY_VERSION.to_i >= 2
+    # Fibers have their own thread local variables so use thread_variable_get
+    def self.thread_variable_get(variable)
+      Thread.current.thread_variable_get(variable)
     end
   else
-    # Whether this thread is currently forcing all reads to go against the master database
-    def self.read_from_master?
-      Thread.current[:active_record_slave] == :master
+    def self.thread_variable_get(variable)
+      Thread.current[variable]
     end
+  end
 
-    # Force all subsequent reads on this thread and any fibers called by this thread to go the master
-    def self.read_from_master!
-      Thread.current[:active_record_slave] = :master
+  # Sets the value of the local thread variable
+  #
+  # Parameters
+  #   variable [Symbol]
+  #     Name of variable to set
+  #   value [Object]
+  #     Value to set the thread variable to
+  if RUBY_VERSION.to_i >= 2
+    # Fibers have their own thread local variables so use thread_variable_set
+    def self.thread_variable_set(variable, value)
+      Thread.current.thread_variable_set(variable, value)
     end
-
-    # Subsequent reads on this thread and any fibers called by this thread can go to a slave
-    def self.read_from_slave!
-      Thread.current[:active_record_slave] = nil
+  else
+    def self.thread_variable_set(variable, value)
+      Thread.current[variable] = value
     end
   end
 

data/lib/active_record_slave/instance_methods.rb

@@ -1,17 +1,35 @@
 module ActiveRecordSlave
-  module InstanceMethods
+  # Select Methods
+  SELECT_METHODS = [:select, :select_all, :select_one, :select_rows, :select_value, :select_values]
+
+  # In case in the future we are forced to intercept connection#execute if the
+  # above select methods are not sufficient
+  #   SQL_READS = /\A\s*(SELECT|WITH|SHOW|CALL|EXPLAIN|DESCRIBE)/i
 
-    # Database Adapter method #select is called for every select call
-    # Replace #select with one that calls the slave connection instead
-    def select_with_slave_reader(sql, name = nil, *args)
-      # Only read from slave when not in a transaction and when this is not already the slave connection
-      if (open_transactions == 0) && !ActiveRecordSlave.read_from_master?
-        ActiveRecordSlave.read_from_master do
-          Slave.connection.select(sql, "Slave: #{name || 'SQL'}", *args)
+  module InstanceMethods
+    SELECT_METHODS.each do |select_method|
+      # Database Adapter method #exec_query is called for every select call
+      # Replace #exec_query with one that calls the slave connection instead
+      eval <<-METHOD
+      def #{select_method}_with_slave_reader(sql, name = nil, *args)
+        if active_record_slave_read_from_master?
+          #{select_method}_without_slave_reader(sql, name, *args)
+        else
+          # Calls are going against the Slave now, prevent an infinite loop
+          ActiveRecordSlave.read_from_master do
+            Slave.connection.#{select_method}(sql, "Slave: \#{name || 'SQL'}", *args)
+          end
         end
-      else
-        select_without_slave_reader(sql, name, *args)
       end
+      METHOD
+    end
+
+    # Returns whether to read from the master database
+    def active_record_slave_read_from_master?
+      # Read from master when forced by thread variable, or
+      # in a transaction and not ignoring transactions
+      ActiveRecordSlave.read_from_master? ||
+        (open_transactions > 0) && !ActiveRecordSlave.ignore_transactions?
     end
 
   end

data/lib/active_record_slave/railtie.rb

@@ -1,8 +1,23 @@
 module ActiveRecordSlave #:nodoc:
   class Railtie < Rails::Railtie #:nodoc:
 
+    # Make the ActiveRecordSlave configuration available in the Rails application config
+    #
+    # Example: For this application ignore the current transactions since the application
+    #          has been coded to use ActiveRecordSlave.read_from_master whenever
+    #          the current transaction must be visible to reads.
+    #            In file config/application.rb
+    #
+    #   Rails::Application.configure do
+    #     # Read from slave even when in an active transaction
+    #     # The application will use ActiveRecordSlave.read_from_master to make
+    #     # changes in the current transaction visible to reads
+    #     config.active_record_slave.ignore_transactions = true
+    #   end
+    config.active_record_slave = ::ActiveRecordSlave
+
     # Initialize ActiveRecordSlave
-    initializer "load active_record_slave" , :after=>"active_record.initialize_database" do
+    initializer "load active_record_slave" , :after => "active_record.initialize_database" do
       ActiveRecordSlave.install!
     end
 

data/lib/active_record_slave/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordSlave #:nodoc
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/test/active_record_slave_test.rb

@@ -52,6 +52,8 @@ class ActiveRecordSlaveTest < Test::Unit::TestCase
   context 'the active_record_slave gem' do
 
     setup do
+      ActiveRecordSlave.ignore_transactions = false
+
       User.delete_all
 
       @name    = "Joe Bloggs"
@@ -89,7 +91,12 @@ class ActiveRecordSlaveTest < Test::Unit::TestCase
     end
 
     should "save to master, read from master when in a transaction" do
+      assert_equal false, ActiveRecordSlave.ignore_transactions?
+
       User.transaction do
+        # The delete_all in setup should have cleared the table
+        assert_equal 0, User.count
+
         # Read from Master
         assert_equal 0, User.where(:name => @name, :address => @address).count
 
@@ -99,6 +106,31 @@ class ActiveRecordSlaveTest < Test::Unit::TestCase
         # Read from Master
         assert_equal 1, User.where(:name => @name, :address => @address).count
       end
+
+      # Read from Non-replicated slave
+      assert_equal 0, User.where(:name => @name, :address => @address).count
+    end
+
+    should "save to master, read from slave when ignoring transactions" do
+      ActiveRecordSlave.ignore_transactions = true
+      assert_equal true, ActiveRecordSlave.ignore_transactions?
+
+      User.transaction do
+        # The delete_all in setup should have cleared the table
+        assert_equal 0, User.count
+
+        # Read from Master
+        assert_equal 0, User.where(:name => @name, :address => @address).count
+
+        # Write to master
+        assert_equal true, @user.save!
+
+        # Read from Non-replicated slave
+        assert_equal 0, User.where(:name => @name, :address => @address).count
+      end
+
+      # Read from Non-replicated slave
+      assert_equal 0, User.where(:name => @name, :address => @address).count
     end
 
     should "save to master, force a read from master even when _not_ in a transaction" do

data/test/database.yml

@@ -1,12 +1,12 @@
 test:
   adapter:  sqlite3
-  database: test/db/test.sqlite3
+  database: test/test.sqlite3
   pool:     5
   timeout:  5000
   # Make the slave a separate database that is not slaved to ensure reads
   # and writes go to the appropriate databases
   slave:
     adapter:  sqlite3
-    database: test/db/test_slave.sqlite3
+    database: test/test_slave.sqlite3
     pool:     5
     timeout:  5000

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_slave
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-28 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -56,6 +56,8 @@ files:
 - lib/active_record_slave/version.rb
 - test/active_record_slave_test.rb
 - test/database.yml
+- test/test.sqlite3
+- test/test_slave.sqlite3
 homepage: https://github.com/reidmorrison/active_record_slave
 licenses:
 - Apache License V2.0
@@ -83,3 +85,5 @@ summary: ActiveRecord drop-in solution to efficiently redirect reads to slave da
 test_files:
 - test/active_record_slave_test.rb
 - test/database.yml
+- test/test.sqlite3
+- test/test_slave.sqlite3