slavery 1.4.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5623ea412368cf47d2502b70f7996d6206e8b25
-  data.tar.gz: 9c5b645d0c4d8ab40fb9212088b22ac1a0d7622c
+  metadata.gz: 844d663a8d247cdb698ca1e17d781749372d980c
+  data.tar.gz: 7fb134582dfa4eb45971cd1afb35f08286aef10f
 SHA512:
-  metadata.gz: d9951e3d9c4eed95ab9671f05806b9bf1b71e8b121f9ced9a628331ee8477f60dfd752a2e93bd85f8b5e265ae15f012bbaa2baaf1a417f8e7c4a1bd1f25b5631
-  data.tar.gz: 2083dd1a78aa49edf3bd3939d92f40c95aec2f00daaa5b002964a856537303d445a949f295d9a5d653fd4781f35f169e47832a008a8e0906bfbe03fbb39079c3
+  metadata.gz: a227e3ba41594385d60c96692969dbbd59d16c5e952ccfa54daf423526025b25dcc99464f9f7eee4458e8f941db1873d3f57d66d9548f9d80625e7b6c600f241
+  data.tar.gz: 1321abb5bd5394ac032bd5531117a707873251c4fd9026456ad08e3c27fb9383e45f1cdfdc4a6aad4f9080c8bf4de3270432854cfef96d5bb2395c70eb724595

data/README.md

@@ -1,12 +1,14 @@
 # Slavery - Simple, conservative slave reads for ActiveRecord
 
-Slavery is a simple, easy to use plugin for ActiveRecord that enables conservative slave reads, which means it doesn't automatically redirect all SELECTs to slaves. Instead, it lets you specify `Slavery.on_slave` to send a particular query to a slave.
+Slavery is a simple, easy to use gem for ActiveRecord that enables conservative slave reads, which means it doesn't automatically redirect all SELECTs to slaves.
 
-Probably you just start off with one single database. As your app grows, you would move to master-slave replication for redundancy. At this point, all queries still go to the master and slaves are just backups. With that configuration, it's tempting to run some long-running queries on the slave. And that's exactly what Slavery does.
+Instead, you can do `Slavery.on_slave { User.count }` to send a particular query to a slave.
+
+Background: Probably your app started off with one single database. As it grows, you would upgrade to a master-slave replication for redundancy. At this point, all queries still go to the master and slaves are just backups. With that configuration, it's tempting to run some long-running queries on the slave. And that's exactly what Slavery does.
 
 * Conservative - Safe by default. Installing Slavery won't change your app's current behavior.
-* Future proof - No dirty hacks, simply works as a proxy for `ActiveRecord::Base.connection`.
-* Simple - Only 100+ LOC, you can read the entire source and completely stay in control.
+* Future proof - No dirty hacks. Simply works as a proxy for `ActiveRecord::Base.connection`.
+* Simple code - Intentionally small. You can read the entire source and completely stay in control.
 
 Slavery works with ActiveRecord 3 or later.
 
@@ -93,7 +95,7 @@ With MySQL, `GRANT SELECT` creates a read-only user.
 GRANT SELECT ON *.* TO 'readonly'@'localhost';
 ```
 
-With this user, writes on slave should raises an exception.
+With this user, writes on slave should raise an exception.
 
 ```ruby
 Slavery.on_slave { User.create } 	# => ActiveRecord::StatementInvalid: Mysql2::Error: INSERT command denied...
@@ -101,26 +103,24 @@ Slavery.on_slave { User.create } 	# => ActiveRecord::StatementInvalid: Mysql2::E
 
 It is a good idea to confirm this behavior in your test code as well.
 
-## Database failure
-
-When one of the master or the slave goes down, you would rewrite `database.yml` to make all queries go to the surviving database, until you restore or rebuild the failed one.
+## Disable temporarily
 
-In such an event, you don't want to manually remove `Slavery.on_slave` from your code. Instead, just put the following line in `config/initializers/slavery.rb`.
+You can quickly disable slave reads by dropping the following line in `config/initializers/slavery.rb`.
 
 ```ruby
 Slavely.disabled = true
 ```
 
-With this line, Slavery stops connection switching and all queries go to the new master.
+With this line, Slavery stops connection switching and all queries go to the master.
+
+This may be useful when one of the master or the slave goes down. You would rewrite `database.yml` to make all queries go to the surviving database, until you restore or rebuild the failed one.
 
 ## Support for non-Rails apps
 
-If you're using ActiveRecord in a non-Rails app (e.g. Sinatra), be sure to set `Slavery.env` in the boot sequence.
+If you're using ActiveRecord in a non-Rails app (e.g. Sinatra), be sure to set `RACK_ENV` environment variable in the boot sequence, then:
 
 ```ruby
-Slavery.env = 'development'
-
-ActiveRecord::Base.send(:include, Slavery)
+require 'slavery'
 
 ActiveRecord::Base.configurations = {
   'development' =>        { adapter: 'mysql2', ... },
@@ -137,8 +137,6 @@ This is useful for deploying on EngineYard where the configuration key in databa
 Slavery.spec_key = "slave" #instead of production_slave
 ```
 
-Alternatively you can pass it a lambda for dynamically setting this.
+## Changelog
 
-```ruby
-Slavery.spec_key = lambda{ "#{Slavery.env}_slave" }
-```
+* v2.0.0: Rails 5 support

data/lib/slavery.rb

@@ -1,105 +1,49 @@
-require 'slavery/version'
-require 'slavery/railtie'
 require 'active_record'
+require 'slavery/base'
+require 'slavery/error'
+require 'slavery/slave_connection_holder'
+require 'slavery/version'
+require 'slavery/active_record/base'
+require 'slavery/active_record/relation'
 
 module Slavery
-  extend ActiveSupport::Concern
-
-  included do
-    require 'slavery/relation'
-
-    class << self
-      alias_method_chain :connection, :slavery
-    end
-  end
-
-  class Error < StandardError; end
-
   class << self
     attr_accessor :disabled
-    attr_writer :env, :spec_key
+    attr_writer :spec_key
 
     def spec_key
       case @spec_key
       when String   then @spec_key
-      when Proc     then @spec_key = @spec_key.call
-      when NilClass then @spec_key = "#{Slavery.env}_slave"
+      when NilClass then @spec_key = "#{ActiveRecord::ConnectionHandling::RAILS_ENV.call}_slave"
       end
     end
 
     def on_slave(&block)
-      run true, &block
+      Base.new(:slave).run &block
     end
 
     def on_master(&block)
-      run false, &block
-    end
-
-    def run(new_value)
-      old_value = Thread.current[:on_slave] # Save for recursive nested calls
-      Thread.current[:on_slave] = new_value
-      yield
-    ensure
-      Thread.current[:on_slave] = old_value
-    end
-
-    def env
-      @env ||= defined?(Rails) ? Rails.env.to_s : 'development'
-    end
-  end
-
-  module ClassMethods
-    def on_slave
-      # Why where(nil)?
-      # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
-      context = where(nil)
-      context.slavery_target = :slave
-      context
+      Base.new(:master).run &block
     end
 
-    def connection_with_slavery
-      if Thread.current[:on_slave] and slaveryable?
-        slave_connection
-      else
-        master_connection
+    def slave_connection_holder
+      @slave_connection_holder ||= begin
+        SlaveConnectionHolder.activate
+        SlaveConnectionHolder
       end
     end
 
-    def slaveryable?
+    def base_transaction_depth
       @base_transaction_depth ||= begin
-        defined?(ActiveSupport::TestCase) &&
-        ActiveSupport::TestCase.respond_to?(:use_transactional_fixtures) &&
-        ActiveSupport::TestCase.try(:use_transactional_fixtures) ? 1 : 0
-      end
-      inside_transaction = master_connection.open_transactions > @base_transaction_depth
-      raise Error.new('on_slave cannot be used inside transaction block!') if inside_transaction
-
-      !Slavery.disabled
-    end
-
-    def master_connection
-      connection_without_slavery
-    end
-
-    def slave_connection
-      slave_connection_holder.connection_without_slavery
-    end
-
-    # Create an anonymous AR class to hold slave connection
-    def slave_connection_holder
-      @slave_connection_holder ||= Class.new(ActiveRecord::Base) {
-        self.abstract_class = true
-
-        def self.name
-          "SlaveConnectionHolder"
+        testcase = ActiveSupport::TestCase
+        if defined?(testcase) &&
+            testcase.respond_to?(:use_transactional_fixtures) &&
+            testcase.try(:use_transactional_fixtures)
+          1
+        else
+          0
         end
-
-        spec = [Slavery.spec_key, Slavery.env].find do |spec_key|
-          ActiveRecord::Base.configurations[spec_key]
-        end or raise Error.new("#{Slavery.spec_key} or #{Slavery.env} must exist!")
-
-        establish_connection spec.to_sym
-      }
+      end
     end
   end
 end

data/lib/slavery/active_record/base.rb

@@ -0,0 +1,27 @@
+module ActiveRecord
+  class Base
+    class << self
+      alias_method :connection_without_slavery, :connection
+
+      def connection
+        case Thread.current[:slavery]
+        when :slave
+          Slavery.slave_connection_holder.connection_without_slavery
+        when :master, NilClass
+          connection_without_slavery
+        else
+          raise Slavery::Error.new("invalid target: #{Thread.current[:slavery]}")
+        end
+      end
+
+      # Generate scope at top level e.g. User.on_slave
+      def on_slave
+        # Why where(nil)?
+        # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
+        context = where(nil)
+        context.slavery_target = :slave
+        context
+      end
+    end
+  end
+end

data/lib/slavery/active_record/relation.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  class Relation
+    attr_accessor :slavery_target
+
+    # Supports queries like User.on_slave.to_a
+    alias_method :exec_queries_without_slavery, :exec_queries
+
+    def exec_queries
+      if slavery_target == :slave
+        Slavery.on_slave { exec_queries_without_slavery }
+      else
+        exec_queries_without_slavery
+      end
+    end
+
+
+    # Supports queries like User.on_slave.count
+    alias_method :calculate_without_slavery, :calculate
+
+    def calculate(*args)
+      if slavery_target == :slave
+        Slavery.on_slave { calculate_without_slavery(*args) }
+      else
+        calculate_without_slavery(*args)
+      end
+    end
+  end
+end

data/lib/slavery/base.rb

@@ -0,0 +1,36 @@
+module Slavery
+  class Base
+    def initialize(target)
+      @target = decide_with(target)
+    end
+
+    def run(&block)
+      run_on @target, &block
+    end
+
+  private
+
+    def decide_with(target)
+      raise Slavery::Error.new('on_slave cannot be used inside transaction block!') if inside_transaction?
+
+      if Slavery.disabled
+        :master
+      else
+        target
+      end
+    end
+
+    def inside_transaction?
+      open_transactions = run_on(:master) { ActiveRecord::Base.connection.open_transactions }
+      open_transactions > Slavery.base_transaction_depth
+    end
+
+    def run_on(target)
+      backup = Thread.current[:slavery] # Save for recursive nested calls
+      Thread.current[:slavery] = target
+      yield
+    ensure
+      Thread.current[:slavery] = backup
+    end
+  end
+end

data/lib/slavery/error.rb

@@ -0,0 +1,4 @@
+module Slavery
+  class Error < StandardError
+  end
+end

data/lib/slavery/slave_connection_holder.rb

@@ -0,0 +1,13 @@
+module Slavery
+  class SlaveConnectionHolder < ActiveRecord::Base
+    self.abstract_class = true
+
+    class << self
+      # for delayed activation
+      def activate
+        raise Error.new('Slavery.spec_key invalid!') unless ActiveRecord::Base.configurations[Slavery.spec_key]
+        establish_connection Slavery.spec_key.to_sym
+      end
+    end
+  end
+end

data/lib/slavery/version.rb

@@ -1,3 +1,3 @@
 module Slavery
-  VERSION = '1.4.3'
+  VERSION = '2.0.0'
 end

data/spec/slavery_spec.rb

@@ -1,13 +1,17 @@
 require 'spec_helper'
 
 describe Slavery do
+  def slavery_value
+    Thread.current[:slavery]
+  end
+
   def on_slave?
-    Thread.current[:on_slave]
+    slavery_value == :slave
   end
 
   it 'sets thread local' do
-    Slavery.on_master { expect(on_slave?).to be false }
-    Slavery.on_slave  { expect(on_slave?).to be true }
+    Slavery.on_master { expect(slavery_value).to be :master }
+    Slavery.on_slave  { expect(slavery_value).to be :slave }
   end
 
   it 'returns value from block' do
@@ -39,36 +43,46 @@ describe Slavery do
     end
   end
 
-  it 'disables in transaction' do
+  it 'raises error in transaction' do
     User.transaction do
-      expect { User.slaveryable? }.to raise_error(Slavery::Error)
+      expect { Slavery.on_slave { User.first } }.to raise_error(Slavery::Error)
     end
   end
 
   it 'disables by configuration' do
-    allow(Slavery).to receive(:disabled).and_return(false)
-    Slavery.on_slave { expect(User.slaveryable?).to be true }
+    backup = Slavery.disabled
+
+    Slavery.disabled = false
+    Slavery.on_slave { expect(slavery_value).to be :slave }
 
-    allow(Slavery).to receive(:disabled).and_return(true)
-    Slavery.on_slave { expect(User.slaveryable?).to be false }
+    Slavery.disabled = true
+    Slavery.on_slave { expect(slavery_value).to be :master }
+
+    Slavery.disabled = backup
   end
 
   it 'sets the Slavery database spec name by configuration' do
-    Slavery.spec_key = "custom_slave"
+    Slavery.spec_key = 'custom_slave'
     expect(Slavery.spec_key).to eq 'custom_slave'
+  end
 
-    Slavery.spec_key = lambda{
-      "kewl_slave"
-    }
-    expect(Slavery.spec_key).to eq "kewl_slave"
+  it 'avoids stack overflow with 3rdparty gem that defines alias_method. namely newrelic...' do
+    class ActiveRecord::Relation
+      alias_method :calculate_without_thirdparty, :calculate
 
-    Slavery.spec_key = lambda{
-      "#{Slavery.env}_slave"
-    }
-    expect(Slavery.spec_key).to eq "test_slave"
+      def calculate(*args)
+        calculate_without_thirdparty(*args)
+      end
+    end
+
+    expect(User.count).to be 2
+
+    class ActiveRecord::Relation
+      alias_method :calculate, :calculate_without_thirdparty
+    end
   end
 
-  it 'works with scopes' do
+  it 'works with any scopes' do
     expect(User.count).to be 2
     expect(User.on_slave.count).to be 1
 
@@ -81,28 +95,30 @@ describe Slavery do
   describe 'configuration' do
     before do
       # Backup connection and configs
-      @old_conn = User.instance_variable_get :@slave_connection_holder
-      @old_config = ActiveRecord::Base.configurations.dup
-      User.instance_variable_set :@slave_connection_holder, nil
+      @backup_conn = Slavery.instance_variable_get :@slave_connection_holder
+      @backup_config = ActiveRecord::Base.configurations.dup
+      @backup_disabled = Slavery.disabled
+      Slavery.instance_variable_set :@slave_connection_holder, nil
     end
 
     after do
       # Restore connection and configs
-      User.instance_variable_set :@slave_connection_holder, @old_conn
-      ActiveRecord::Base.configurations = @old_config
+      Slavery.instance_variable_set :@slave_connection_holder, @backup_conn
+      ActiveRecord::Base.configurations = @backup_config
+      Slavery.disabled = @backup_disabled
     end
 
-    it 'connects to master if slave configuration not specified' do
-      ActiveRecord::Base.configurations[Slavery.spec_key] = nil
+    it 'raises error if slave configuration not specified' do
+      ActiveRecord::Base.configurations['test_slave'] = nil
 
-      expect(Slavery.on_slave { User.count }).to be 2
+      expect { Slavery.on_slave { User.count } }.to raise_error(Slavery::Error)
     end
 
-    it 'raises error when no configuration found' do
-      ActiveRecord::Base.configurations['test'] = nil
-      ActiveRecord::Base.configurations[Slavery.spec_key] = nil
+    it 'connects to master if slave configuration not specified' do
+      ActiveRecord::Base.configurations['test_slave'] = nil
+      Slavery.disabled = true
 
-      expect { Slavery.on_slave { User.count } }.to raise_error(Slavery::Error)
+      expect(Slavery.on_slave { User.count }).to be 2
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,36 +1,28 @@
 require 'rubygems'
 require 'bundler/setup'
 
-require 'slavery'
-
-# Activate Slavery
-ActiveRecord::Base.send(:include, Slavery)
+ENV['RACK_ENV'] = 'test'
 
-# Prepare databases
-class User < ActiveRecord::Base
-end
-
-# Should be equal to Rails.env
-Slavery.env = 'test'
+require 'slavery'
 
 ActiveRecord::Base.configurations = {
   'test' =>        { adapter: 'sqlite3', database: 'test_db' },
   'test_slave' =>  { adapter: 'sqlite3', database: 'test_slave_db' }
 }
 
+# Prepare databases
+class User < ActiveRecord::Base
+end
+
 # Create two records on master
 ActiveRecord::Base.establish_connection(:test)
-ActiveRecord::Base.connection.create_table :users, force: true do |t|
-  t.boolean :disabled
-end
+ActiveRecord::Base.connection.create_table :users, force: true
 User.create
 User.create
 
 # Create one record on slave, emulating replication lag
 ActiveRecord::Base.establish_connection(:test_slave)
-ActiveRecord::Base.connection.create_table :users, force: true do |t|
-  t.boolean :disabled
-end
+ActiveRecord::Base.connection.create_table :users, force: true
 User.create
 
 # Reconnect to master

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slavery
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Kenn Ejima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-03 00:00:00.000000000 Z
+date: 2016-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,8 +66,11 @@ files:
 - README.md
 - Rakefile
 - lib/slavery.rb
-- lib/slavery/railtie.rb
-- lib/slavery/relation.rb
+- lib/slavery/active_record/base.rb
+- lib/slavery/active_record/relation.rb
+- lib/slavery/base.rb
+- lib/slavery/error.rb
+- lib/slavery/slave_connection_holder.rb
 - lib/slavery/version.rb
 - slavery.gemspec
 - spec/slavery_spec.rb

data/lib/slavery/railtie.rb

@@ -1,11 +0,0 @@
-module Slavery
-  if defined? Rails::Railtie
-  	class Railtie < Rails::Railtie
-  	  initializer 'slavery.insert_into_active_record' do |app|
-  	    ActiveSupport.on_load :active_record do
-  	      include Slavery
-  	    end
-  	  end
-  	end
-  end
-end

data/lib/slavery/relation.rb

@@ -1,24 +0,0 @@
-class ActiveRecord::Relation
-  attr_accessor :slavery_target
-
-  # Supports queries like User.on_slave.to_a
-  def exec_queries_with_slavery
-    if slavery_target == :slave
-      Slavery.on_slave { exec_queries_without_slavery }
-    else
-      exec_queries_without_slavery
-    end
-  end
-
-  # Supports queries like User.on_slave.count
-  def calculate_with_slavery(operation, column_name, options = {})
-    if slavery_target == :slave
-      Slavery.on_slave { calculate_without_slavery(operation, column_name, options) }
-    else
-      calculate_without_slavery(operation, column_name, options)
-    end
-  end
-
-  alias_method_chain :exec_queries, :slavery
-  alias_method_chain :calculate, :slavery
-end