switch_connection 1.0.0

data/lib/switch_connection/proxy.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'switch_connection/error'
+
+module SwitchConnection
+  class Proxy
+    attr_reader :initial_name
+
+    AVAILABLE_MODES = %i[master slave].freeze
+    DEFAULT_MODE = :master
+
+    def initialize(name)
+      @initial_name = name
+      @current_name = name
+      define_master_model(name)
+      define_slave_model(name)
+      @global_mode = DEFAULT_MODE
+    end
+
+    def define_master_model(name)
+      model_name = SwitchConnection.config.master_model_name(name)
+      if model_name
+        model = Class.new(ActiveRecord::Base)
+        Proxy.const_set(model_name, model)
+        master_database_name = SwitchConnection.config.master_database_name(name)
+        model.establish_connection(db_specific(master_database_name))
+        model
+      else
+        ActiveRecord::Base
+      end
+    end
+
+    def define_slave_model(name)
+      return unless SwitchConnection.config.slave_exist?(name)
+
+      slave_count = SwitchConnection.config.slave_count(name)
+      (0..(slave_count - 1)).map do |index|
+        model_name = SwitchConnection.config.slave_mode_name(name, index)
+        next ActiveRecord::Base unless model_name
+
+        model = Class.new(ActiveRecord::Base)
+        Proxy.const_set(model_name, model)
+        model.establish_connection(db_specific(SwitchConnection.config.slave_database_name(name, index)))
+        model
+      end
+    end
+
+    def db_specific(db_name)
+      base_config = ::ActiveRecord::Base.configurations.fetch(SwitchConnection.config.env)
+      return base_config if db_name == :default
+
+      db_name.to_s.split('.').inject(base_config) { |h, n| h[n] }
+    end
+
+    def thread_local_mode
+      Thread.current[:"switch_point_#{@current_name}_mode"]
+    end
+
+    def thread_local_mode=(mode)
+      Thread.current[:"switch_point_#{@current_name}_mode"] = mode
+    end
+    private :thread_local_mode=
+
+    def mode
+      thread_local_mode || @global_mode
+    end
+
+    def slave!
+      if thread_local_mode
+        self.thread_local_mode = :slave
+      else
+        @global_mode = :slave
+      end
+    end
+
+    def slave?
+      mode == :slave
+    end
+
+    def master!
+      if thread_local_mode
+        self.thread_local_mode = :master
+      else
+        @global_mode = :master
+      end
+    end
+
+    def master?
+      mode == :master
+    end
+
+    def with_slave(&block)
+      with_mode(:slave, &block)
+    end
+
+    def with_master(&block)
+      with_mode(:master, &block)
+    end
+
+    def with_mode(new_mode, &block)
+      unless AVAILABLE_MODES.include?(new_mode)
+        raise ArgumentError.new("Unknown mode: #{new_mode}")
+      end
+
+      saved_mode = thread_local_mode
+      self.thread_local_mode = new_mode
+      block.call
+    ensure
+      self.thread_local_mode = saved_mode
+    end
+
+    def switch_name(new_name, &block)
+      if block
+        begin
+          old_name = @current_name
+          @current_name = new_name
+          block.call
+        ensure
+          @current_name = old_name
+        end
+      else
+        @current_name = new_name
+      end
+    end
+
+    def reset_name!
+      @current_name = @initial_name
+    end
+
+    def model_for_connection
+      ProxyRepository.checkout(@current_name) # Ensure the target proxy is created
+      model_name = SwitchConnection.config.model_name(@current_name, mode)
+      if model_name
+        Proxy.const_get(model_name)
+      elsif mode == :slave
+        # When only master is specified, re-use master connection.
+        with_master do
+          model_for_connection
+        end
+      else
+        ActiveRecord::Base
+      end
+    end
+
+    def connection
+      model_for_connection.connection
+    end
+
+    def connected?
+      model_for_connection.connected?
+    end
+
+    def cache(&block)
+      r = with_slave { model_for_connection }
+      w = with_master { model_for_connection }
+      r.cache { w.cache(&block) }
+    end
+
+    def uncached(&block)
+      r = with_slave { model_for_connection }
+      w = with_master { model_for_connection }
+      r.uncached { w.uncached(&block) }
+    end
+  end
+end

data/lib/switch_connection/proxy_repository.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'switch_connection/proxy'
+
+module SwitchConnection
+  class ProxyRepository
+    include Singleton
+
+    def self.checkout(name)
+      instance.checkout(name)
+    end
+
+    def self.find(name)
+      instance.find(name)
+    end
+
+    def checkout(name)
+      proxies[name] ||= Proxy.new(name)
+    end
+
+    def find(name)
+      proxies.fetch(name)
+    end
+
+    def proxies
+      @proxies ||= {}
+    end
+  end
+end

data/lib/switch_connection/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SwitchConnection
+  VERSION = '1.0.0'
+end

data/spec/models.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+SwitchConnection.configure do |config|
+  config.define_switch_point :main,
+                             slaves: [:main_slave],
+                             master: :main_master
+  config.define_switch_point :main2,
+                             slaves: [:main2_slave],
+                             master: :main2_master
+  config.define_switch_point :user,
+                             slaves: [:user],
+                             master: :user
+  config.define_switch_point :comment,
+                             slaves: [:comment_slave],
+                             master: :comment_master
+  config.define_switch_point :special,
+                             slaves: [:main_slave_special],
+                             master: :main_master
+  config.define_switch_point :nanika1,
+                             slaves: [:main_slave],
+                             master: :main_master
+  config.define_switch_point :nanika2,
+                             slaves: [:main_slave],
+                             master: :main_master
+  config.define_switch_point :nanika3,
+                             master: :comment_master
+end
+
+require 'active_record'
+
+class Book < ActiveRecord::Base
+  use_switch_point :main
+  after_save :do_after_save
+
+  private
+
+  def do_after_save; end
+end
+
+class Book2 < ActiveRecord::Base
+  use_switch_point :main
+end
+
+class Book3 < ActiveRecord::Base
+  use_switch_point :main2
+end
+
+class Publisher < ActiveRecord::Base
+  use_switch_point :main
+end
+
+class Comment < ActiveRecord::Base
+  use_switch_point :comment
+end
+
+class User < ActiveRecord::Base
+  use_switch_point :user
+end
+
+class BigData < ActiveRecord::Base
+  use_switch_point :special
+end
+
+class Note < ActiveRecord::Base
+end
+
+class Nanika1 < ActiveRecord::Base
+  use_switch_point :nanika1
+end
+
+class Nanika2 < ActiveRecord::Base
+  use_switch_point :nanika2
+end
+
+class Nanika3 < ActiveRecord::Base
+  use_switch_point :nanika3
+end
+
+class AbstractNanika < ActiveRecord::Base
+  use_switch_point :main
+  self.abstract_class = true
+end
+
+class DerivedNanika1 < AbstractNanika
+end
+
+class DerivedNanika2 < AbstractNanika
+  use_switch_point :main2
+end
+
+base =
+  if RUBY_PLATFORM == 'java'
+    { adapter: 'jdbcsqlite3' }
+  else
+    { adapter: 'sqlite3', pool: 10 }
+  end
+
+databases = {
+  test: {
+    'main_slave' => base.merge(database: 'main_slave.sqlite3'),
+    'main_master' => base.merge(database: 'main_master.sqlite3'),
+    'main2_slave' => base.merge(database: 'main2_slave.sqlite3'),
+    'main2_master' => base.merge(database: 'main2_master.sqlite3'),
+    'main_slave_special' => base.merge(database: 'main_slave_special.sqlite3'),
+    'user' => base.merge(database: 'user.sqlite3'),
+    'comment_slave' => base.merge(database: 'comment_slave.sqlite3'),
+    'comment_master' => base.merge(database: 'comment_master.sqlite3'),
+    'default' => base.merge(database: 'default.sqlite3')
+  }
+}
+ActiveRecord::Base.configurations =
+  # ActiveRecord.gem_version was introduced in ActiveRecord 4.0
+  if ActiveRecord.respond_to?(:gem_version) && ActiveRecord.gem_version >= Gem::Version.new('5.1.0')
+    { 'test' => databases }
+  else
+    databases
+  end
+
+default_database_config = ActiveRecord::Base.configurations[SwitchConnection.config.env]['default']
+ActiveRecord::Base.establish_connection(default_database_config)
+
+# XXX: Check connection laziness
+[Book, User, Note, Nanika1, ActiveRecord::Base].each do |model|
+  if model.connected?
+    raise "ActiveRecord::Base didn't establish connection lazily!"
+  end
+end
+ActiveRecord::Base.connection # Create connection
+
+[Book, User, Nanika3].each do |model|
+  model.with_master do
+    if model.switch_point_proxy.connected?
+      raise "#{model.name} didn't establish connection lazily!"
+    end
+  end
+  model.with_slave do
+    if model.switch_point_proxy.connected?
+      raise "#{model.name} didn't establish connection lazily!"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'coveralls'
+require 'simplecov'
+
+SimpleCov.formatters = [
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter,
+]
+SimpleCov.start do
+  add_filter Bundler.bundle_path.to_s
+  add_filter File.dirname(__FILE__)
+end
+
+require 'switch_connection'
+require 'models'
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  if config.files_to_run.one?
+    config.full_backtrace = true
+    config.default_formatter = 'doc'
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  config.before(:suite) do
+    Book.with_master do
+      Book.connection.execute('CREATE TABLE books (id integer primary key autoincrement)')
+    end
+
+    Book2.with_master do
+      Book2.connection.execute('CREATE TABLE book2s (id integer primary key autoincrement)')
+    end
+
+    FileUtils.cp('main_master.sqlite3', 'main_slave.sqlite3')
+
+    Book3.with_master do
+      Book3.connection.execute('CREATE TABLE book3s (id integer primary key autoincrement)')
+    end
+
+    FileUtils.cp('main2_master.sqlite3', 'main2_slave.sqlite3')
+
+    Note.connection.execute('CREATE TABLE notes (id integer primary key autoincrement)')
+
+    Nanika3.connection.execute('CREATE TABLE nanika3s (id integer primary key)')
+  end
+
+  config.after(:suite) do
+    ActiveRecord::Base.configurations[SwitchConnection.config.env].each_value do |c|
+      FileUtils.rm_f(c[:database])
+    end
+  end
+
+  config.after(:each) do
+    Book.with_master do
+      Book.delete_all
+    end
+    FileUtils.cp('main_master.sqlite3', 'main_slave.sqlite3')
+
+    Nanika3.delete_all
+  end
+end
+
+RSpec::Matchers.define :connect_to do |expected|
+  database_name = lambda do |model|
+    model.connection.pool.spec.config[:database]
+  end
+
+  match do |actual|
+    database_name.call(actual) == expected
+  end
+
+  failure_message do |actual|
+    "expected #{actual.name} to connect to #{expected} but connected to #{database_name.call(actual)}"
+  end
+end

data/spec/switch_connection/model_spec.rb

@@ -0,0 +1,402 @@
+# frozen_string_literal: true
+
+RSpec.describe SwitchConnection::Model do
+  describe '.use_switch_point' do
+    after do
+      Book.use_switch_point :main
+    end
+
+    it 'changes connection' do
+      expect(Book).to connect_to('main_master.sqlite3')
+      Book.use_switch_point :comment
+      expect(Book).to connect_to('comment_master.sqlite3')
+
+      Thread.start do
+        Book.with_switch_point(:main) do
+          expect(Book).to connect_to('main_master.sqlite3')
+        end
+        Book.with_switch_point(:comment) do
+          expect(Book).to connect_to('comment_master.sqlite3')
+        end
+      end.join
+    end
+
+    context 'with non-existing switch point name' do
+      it 'raises error' do
+        expect {
+          Class.new(ActiveRecord::Base) do
+            use_switch_point :not_found
+          end
+        }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe '.connection' do
+    it 'returns master connection by default' do
+      expect(Book).to connect_to('main_master.sqlite3')
+      expect(Publisher).to connect_to('main_master.sqlite3')
+      expect(User).to connect_to('user.sqlite3')
+      expect(Comment).to connect_to('comment_master.sqlite3')
+      expect(Note).to connect_to('default.sqlite3')
+      expect(Book.switch_point_proxy).to be_master
+    end
+
+    context 'when auto_master is disabled' do
+      it 'raises error when destructive query is requested in slave mode' do
+        expect { Book.create }.to_not raise_error
+        expect { Book.with_master { Book.create } }.to_not raise_error
+      end
+    end
+
+    context 'when auto_master is enabled' do
+      around do |example|
+        SwitchConnection.configure do |config|
+          config.auto_master = true
+        end
+        example.run
+        SwitchConnection.configure do |config|
+          config.auto_master = false
+        end
+      end
+
+      it 'executes after_save callback in slave mode!' do
+        book = Book.new
+        expect(book).to receive(:do_after_save) {
+          expect(Book.switch_point_proxy).to be_master
+          expect(Book.connection.open_transactions).to eq(1)
+        }
+        book.save!
+      end
+    end
+
+    it 'works with newly checked-out connection' do
+      Thread.start do
+        Book.with_master do
+          Book.create
+        end
+        Book.with_slave { expect(Book.count).to eq(0) }
+        Book.with_master { expect(Book.count).to eq(1) }
+      end.join
+    end
+
+    context 'without switch_point configuration' do
+      it 'returns default connection' do
+        expect(Note.connection).to equal(ActiveRecord::Base.connection)
+      end
+    end
+
+    context 'with the same switch point name' do
+      it 'shares connection' do
+        expect(Book.connection).to equal(Publisher.connection)
+      end
+    end
+
+    context 'with the same database name' do
+      it 'does NOT shares a connection' do
+        expect(Book.connection).to_not equal(BigData.connection)
+        Book.with_master do
+          BigData.with_master do
+            expect(Book.connection).to_not equal(BigData.connection)
+          end
+        end
+      end
+    end
+
+    context 'when superclass uses use_switch_point' do
+      context 'without use_switch_point in derived class' do
+        it 'inherits switch_point configuration' do
+          expect(DerivedNanika1).to connect_to('main_master.sqlite3')
+        end
+
+        it 'shares connection with superclass' do
+          expect(DerivedNanika1.connection).to equal(AbstractNanika.connection)
+        end
+      end
+
+      context 'with use_switch_point in derived class' do
+        it 'overrides superclass' do
+          expect(DerivedNanika2).to connect_to('main2_master.sqlite3')
+        end
+      end
+
+      context 'when superclass changes switch_point' do
+        after do
+          AbstractNanika.use_switch_point :main
+        end
+
+        it 'follows' do
+          AbstractNanika.use_switch_point :main2
+          expect(DerivedNanika1).to connect_to('main2_master.sqlite3')
+        end
+      end
+    end
+
+    context 'without :master' do
+      it 'sends destructive queries to ActiveRecord::Base' do
+        expect(Nanika1).to connect_to('main_master.sqlite3')
+        Nanika1.with_master do
+          expect(Nanika1).to connect_to('main_master.sqlite3')
+        end
+      end
+    end
+
+    context 'without :slave' do
+      it 'sends all queries to :master' do
+        expect(Nanika3).to connect_to('comment_master.sqlite3')
+        Nanika3.with_master do
+          expect(Nanika3).to connect_to('comment_master.sqlite3')
+          Nanika3.create
+        end
+        expect(Nanika3.count).to eq(1)
+        expect(Nanika3.with_slave { Nanika3.connection }).to equal(Nanika3.with_master { Nanika3.connection })
+      end
+    end
+  end
+
+  describe '.with_master' do
+    it 'changes connection locally' do
+      Book.with_master do
+        expect(Book).to connect_to('main_master.sqlite3')
+        expect(Book.switch_point_proxy).to be_master
+      end
+      expect(Book).to connect_to('main_master.sqlite3')
+      expect(Book.switch_point_proxy).to be_master
+    end
+
+    it 'changes connection locally' do
+      Book.with_switch_point(:comment) do
+        expect(Book.switch_point_proxy).to be_master
+        expect(Book).to connect_to('comment_master.sqlite3')
+        Thread.start do
+          expect(Book).to connect_to('main_master.sqlite3')
+        end.join
+      end
+
+      expect(Book.switch_point_proxy).to be_master
+      expect(Book).to connect_to('main_master.sqlite3')
+    end
+
+    it 'affects to other models with the same switch point' do
+      Book.with_master do
+        expect(Publisher).to connect_to('main_master.sqlite3')
+      end
+      expect(Publisher).to connect_to('main_master.sqlite3')
+    end
+
+    it 'does not affect to other models with different switch point' do
+      Book.with_master do
+        expect(Comment).to connect_to('comment_master.sqlite3')
+      end
+    end
+
+    context 'with the same switch point' do
+      it 'shares connection' do
+        Book.with_master do
+          expect(Book.connection).to equal(Publisher.connection)
+        end
+      end
+    end
+
+    context 'without use_switch_point' do
+      it 'raises error' do
+        expect { Note.with_master { :bypass } }.to raise_error(SwitchConnection::UnconfiguredError)
+      end
+    end
+
+    it 'affects thread-locally' do
+      Book.with_slave do
+        expect(Book).to connect_to('main_slave.sqlite3')
+        Thread.start do
+          expect(Book).to connect_to('main_master.sqlite3')
+        end.join
+      end
+    end
+  end
+
+  describe '#with_master' do
+    it 'behaves like .with_master' do
+      book = Book.with_master { Book.create! }
+      book.with_master do
+        expect(Book).to connect_to('main_master.sqlite3')
+      end
+      expect(Book).to connect_to('main_master.sqlite3')
+    end
+  end
+
+  describe '.with_slave' do
+    context 'when master! is called globally' do
+      before do
+        SwitchConnection.master!(:main)
+      end
+
+      it 'locally overwrites global mode' do
+        Book.with_slave do
+          expect(Book).to connect_to('main_slave.sqlite3')
+        end
+        expect(Book).to connect_to('main_master.sqlite3')
+      end
+    end
+  end
+
+  describe '#with_slave' do
+    it 'behaves like .with_slave' do
+      book = Book.create!
+      book.with_slave do
+        expect(Book).to connect_to('main_slave.sqlite3')
+      end
+      expect(Book).to connect_to('main_master.sqlite3')
+    end
+  end
+
+  describe '#with_mode' do
+    it 'raises error if unknown mode is given' do
+      expect { SwitchConnection::ProxyRepository.checkout(:main).with_mode(:typo) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '.switch_name' do
+    after do
+      Book.switch_point_proxy.reset_name!
+    end
+
+    it 'switches proxy configuration' do
+      Book.switch_point_proxy.switch_name(:comment)
+      expect(Book).to connect_to('comment_master.sqlite3')
+      expect(Publisher).to connect_to('comment_master.sqlite3')
+    end
+
+    context 'with block' do
+      it 'switches proxy configuration locally' do
+        Book.switch_point_proxy.switch_name(:comment) do
+          expect(Book).to connect_to('comment_master.sqlite3')
+          expect(Publisher).to connect_to('comment_master.sqlite3')
+        end
+        expect(Book).to connect_to('main_master.sqlite3')
+        expect(Publisher).to connect_to('main_master.sqlite3')
+      end
+    end
+  end
+
+  describe '.transaction_with' do
+    context 'when each model has a same master' do
+      before do
+        @before_book_count  = Book.count
+        @before_book2_count = Book2.count
+
+        Book.transaction_with(Book2) do
+          Book.create
+          Book2.create
+        end
+
+        @after_book_count = Book.with_master do
+          Book.count
+        end
+        @after_book2_count = Book2.with_master do
+          Book2.count
+        end
+      end
+
+      it 'should create a new record' do
+        expect(
+          Book.with_master do
+            Book.count
+          end
+        ).to be > @before_book_count
+
+        expect(
+          Book2.with_master do
+            Book2.count
+          end
+        ).to be > @before_book2_count
+      end
+    end
+
+    context 'when each model has a other master' do
+      it {
+        expect {
+          Book.transaction_with(Book3) do
+            Book.create
+            Book3.create
+          end
+        }.to raise_error(SwitchConnection::Error)
+      }
+    end
+
+    context 'when raise exception in transaction that include some model, and models each have other master' do
+      before do
+        @before_book_count  = Book.count
+        @before_book3_count = Book3.count
+
+        Book.transaction_with(Book2) do
+          Book.create
+          Book3.with_master do
+            Book3.create
+          end
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      it 'Book should not create a new record (rollbacked)' do
+        expect(
+          Book.with_master do
+            Book.count
+          end
+        ).to eq @before_book_count
+      end
+
+      it 'Book3 should create a new record (not rollbacked)' do
+        expect(
+          Book3.with_master do
+            Book3.count
+          end
+        ).to be > @before_book3_count
+      end
+    end
+
+    context 'when nested transaction_with then parent transaction rollbacked' do
+      before do
+        @before_book_count  = Book.count
+        @before_book3_count = Book3.count
+
+        Book.transaction_with do
+          Book.create
+
+          Book3.transaction_with do
+            Book3.create
+          end
+
+          raise ActiveRecord::Rollback
+        end
+
+        it {
+          expect(
+            Book.with_master do
+              Book.count
+            end
+          ).to be = @before_book_count
+
+          expect(
+            Book3.with_master do
+              Book3.count
+            end
+          ).to be > @before_book3_count
+        }
+      end
+    end
+  end
+
+  describe '#transaction_with' do
+    it 'behaves like .transaction_with' do
+      book = Book.with_master { Book.create! }
+      expect(Book.with_master { Book.count }).to eq(1)
+      book.transaction_with(Book2) do
+        Book.create!
+        raise ActiveRecord::Rollback
+      end
+      expect(Book.with_master { Book.count }).to eq(1)
+
+      expect { book.transaction_with(Book3) {} }.to raise_error(SwitchConnection::Error)
+    end
+  end
+end