makara 0.3.5

data/lib/makara/railtie.rb

@@ -0,0 +1,14 @@
+module Makara
+  class Railtie < ::Rails::Railtie
+
+    config.app_middleware.use 'Makara::Middleware'
+
+
+    initializer "makara.initialize_logger" do |app|
+      ActiveRecord::LogSubscriber.log_subscribers.each do |subscriber|
+        subscriber.extend ::Makara::Logging::Subscriber
+      end
+    end
+
+  end
+end

data/lib/makara/version.rb

@@ -0,0 +1,15 @@
+module Makara
+  module VERSION
+
+    MAJOR = 0
+    MINOR = 3
+    PATCH = 5
+    PRE = nil
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+
+  end unless defined?(::Makara::VERSION)
+  ::Makara::VERSION
+end

data/makara.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/makara/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Mike Nelson"]
+  gem.email         = ["mike@mikeonrails.com"]
+  gem.description   = %q{Read-write split your DB yo}
+  gem.summary       = %q{Read-write split your DB yo}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "makara"
+  gem.require_paths = ["lib"]
+  gem.version       = Makara::VERSION
+
+  gem.add_dependency 'activerecord', '>= 3.0.0'
+end

data/spec/active_record/connection_adapters/makara_abstract_adapter_error_handling_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'active_record/connection_adapters/makara_abstract_adapter'
+
+describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter::ErrorHandler do
+
+  let(:handler){ described_class.new }
+  let(:proxy) { FakeAdapter.new(config(1,1)) }
+  let(:connection){ proxy.master_pool.connections.first }
+
+  [
+    %|Mysql::Error: : INSERT INTO `watchers` (`user_id`, `watchable_id`, `watchable_type`) VALUES|,
+    %|PGError: ERROR: column items.user_id does not exist LINE 1: SELECT "items".* FROM "items" WHERE ("items".user_id = 4) OR|
+  ].each do |msg|
+    it "should properly evaluate errors like: #{msg}" do
+      expect(handler).not_to be_connection_message(msg)
+    end
+
+    it 'should raise the error' do
+      expect{
+        handler.handle(connection) do
+          raise msg
+        end
+      }.to raise_error(msg)
+    end
+  end
+
+  [
+    %|Mysql2::Error: closed MySQL connection: SELECT `users`.* FROM `users`|,
+    %|Mysql2::Error: MySQL server has gone away: SELECT `users`.* FROM `users`|,
+    %|Mysql2::Error (Can't connect to MySQL server on '123.456.789.234' (111))|,
+    %|Mysql2::Error (Cannot connect to MySQL server on '123.456.789.234' (111))|,
+    %|Mysql2::Error Can't connect to MySQL server on '123.456.789.235' (111)|,
+    %|Mysql2::Error: Timeout waiting for a response from the last query|,
+    %|Can't connect to MySQL server on '123.456.789.235' (111)|,
+    %|Mysql2::Error: Lost connection to MySQL server during query: SELECT `geographies`.* FROM `geographies`|,
+    %|PGError: server closed the connection unexpectedly This probably me|,
+    %|Could not connect to server: Connection refused Is the server running on host|,
+    %|PG::AdminShutdown: FATAL:  terminating connection due to administrator command FATAL:  terminating connection due to administrator command|,
+    %|PG::ConnectionBad: PQconsumeInput() SSL connection has been closed unexpectedly: SELECT  1 AS one FROM "users"  WHERE "users"."registration_ip" = '10.0.2.2' LIMIT 1|,
+    %|PG::UnableToSend: no connection to the server|,
+    %|PG::ConnectionBad (could not connect to server: Connection refused|,
+    %|PG::ConnectionBad: PQsocket() can't get socket descriptor:|,
+    %|org.postgresql.util.PSQLException: Connection to localhost:123 refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections.|,
+    %|PG::ConnectionBad: timeout expired|,
+    %|PG::ConnectionBad: could not translate host name "some.sample.com" to address: Name or service not known|,
+    %|PG::ConnectionBad: FATAL: the database system is starting up|,
+    %|PG::ConnectionBad: FATAL: the database system is shutting down|
+  ].each do |msg|
+    it "should properly evaluate connection messages like: #{msg}" do
+      expect(handler).to be_connection_message(msg)
+    end
+
+    it 'should blacklist the connection' do
+      expect {
+        handler.handle(connection) do
+          raise msg
+        end
+      }.to raise_error(Makara::Errors::BlacklistConnection)
+    end
+  end
+
+  describe 'custom errors' do
+
+    let(:config_path) { File.join(File.expand_path('../../../', __FILE__), 'support', 'mysql2_database_with_custom_errors.yml') }
+    let(:config) { YAML.load_file(config_path)['test'] }
+    let(:handler){ described_class.new }
+    let(:proxy) { FakeAdapter.new(config) }
+    let(:connection){ proxy.master_pool.connections.first }
+    let(:msg1) { "ActiveRecord::StatementInvalid: Mysql2::Error: Unknown command1: SELECT `users`.* FROM `users` WHERE `users`.`id` = 53469 LIMIT 1" }
+    let(:msg2) { "activeRecord::statementInvalid: mysql2::error: unknown command2: SELECT `users`.* FROM `users` WHERE `users`.`id` = 53469 LIMIT 1" }
+    let(:msg3) { "ActiveRecord::StatementInvalid: Mysql2::Error: Unknown command3: SELECT `users`.* FROM `users` WHERE `users`.`id` = 53469 LIMIT 1" }
+    let(:msg4) { "ActiveRecord::StatementInvalid: Mysql2::Error: Unknown command3:" }
+
+    it "identifies custom errors" do
+      expect(handler).to be_custom_error_message(connection, msg1)
+      expect(handler).to be_custom_error_message(connection, msg2)
+      expect(handler).to_not be_custom_error_message(connection, msg3)
+      expect(handler).to be_custom_error_message(connection, msg4)
+    end
+
+    it "blacklists the connection" do
+      expect {
+        handler.handle(connection) do
+          raise msg1
+        end
+      }.to raise_error(Makara::Errors::BlacklistConnection)
+    end
+
+  end
+
+
+end

data/spec/active_record/connection_adapters/makara_abstract_adapter_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'active_record/connection_adapters/makara_abstract_adapter'
+
+describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter do
+
+  let(:klass){ FakeAdapter }
+
+  {
+    'insert into dogs...' => true,
+    'insert into cats (select * from felines)' => true,
+    'savepoint active_record_1' => true,
+    'begin' => true,
+    'rollback' => true,
+    'update users set' => true,
+    'delete from people' => true,
+    'release savepoint' => true,
+    'show tables' => true,
+    'show fields' => true,
+    'describe table' => true,
+    'show index' => true,
+    'set @@things' => true,
+    'SET @@things' => true,
+    'commit' => true,
+    'select * from felines' => false,
+    '    select * from felines' => false,
+    'select * from users for update' => true,
+    '    select * from users for update' => true,
+    'select * from users lock in share mode' => true,
+    'select * from users where name = "for update"' => false,
+    'select * from users where name = "lock in share mode"' => false
+  }.each do |sql, should_go_to_master|
+
+    it "determines that \"#{sql}\" #{should_go_to_master ? 'requires' : 'does not require'} master" do
+      proxy = klass.new(config(1,1))
+      expect(proxy.master_for?(sql)).to eq(should_go_to_master)
+    end
+
+  end
+
+
+  {
+    "SET @@things" => true,
+    "INSERT INTO wisdom ('The truth will set you free.')" => false,
+    "INSERT INTO wisdom ('The truth will\nset you free.')" => false,
+    "UPDATE dogs SET max_treats = 10 WHERE max_treats IS NULL" => false,
+    %Q{
+      UPDATE
+        dogs
+      SET
+        max_treats = 10
+      WHERE
+        max_treats IS NULL
+    } => false
+  }.each do |sql, should_send_to_all_connections|
+
+    it "determines that \"#{sql}\" #{should_send_to_all_connections ? 'should' : 'should not'} be sent to all underlying connections" do
+      proxy = klass.new(config(1,1))
+      proxy.master_pool.connections.each{|con| expect(con).to receive(:execute).with(sql).once}
+      proxy.slave_pool.connections.each do |con|
+        if should_send_to_all_connections
+          expect(con).to receive(:execute).with(sql).once
+        else
+          expect(con).to receive(:execute).with(sql).never
+        end
+      end
+
+      proxy.execute(sql)
+
+      if should_send_to_all_connections
+        expect(proxy.master_context).to be_nil
+      end
+    end
+
+  end
+
+  {
+    'show full tables' => false,
+    'show full table' => false,
+    'show index' => false,
+    'show indexes' => false,
+    'describe stuff' => false,
+    'explain things' => false,
+    'show database' => false,
+    'show schema' => false,
+    'show view' => false,
+    'show views' => false,
+    'show table' => false,
+    'show tables' => false,
+    'set @@things' => false,
+    'update users' => true,
+    'insert into' => true,
+    'delete from' => true,
+    'begin transaction' => true,
+    'begin deferred transaction' => true,
+    'commit transaction' => true,
+    'rollback transaction' => true,
+    %Q{
+      UPDATE
+        dogs
+      SET
+        max_treats = 10
+      WHERE
+        max_treats IS NULL
+    } => true
+  }.each do |sql,should_stick|
+
+    it "should #{should_stick ? 'stick' : 'not stick'} to master if handling sql like \"#{sql}\"" do
+      proxy = klass.new(config(0,0))
+      expect(proxy.would_stick?(sql)).to eq(should_stick)
+    end
+
+  end
+
+end

data/spec/active_record/connection_adapters/makara_mysql2_adapter_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require 'active_record/connection_adapters/mysql2_adapter'
+
+describe 'MakaraMysql2Adapter' do
+
+  let(:db_username){ ENV['TRAVIS'] ? 'travis' : 'root' }
+
+  let(:config){
+    base = YAML.load_file(File.expand_path('spec/support/mysql2_database.yml'))['test']
+    base
+  }
+
+  before :each do
+    ActiveRecord::Base.clear_all_connections!
+    change_context
+  end
+
+  context "unconnected" do
+
+    it 'should allow a connection to be established' do
+      ActiveRecord::Base.establish_connection(config)
+      expect(ActiveRecord::Base.connection).to be_instance_of(ActiveRecord::ConnectionAdapters::MakaraMysql2Adapter)
+    end
+
+    it 'should not blow up if a connection fails' do
+      wrong_config = config.deep_dup
+      wrong_config['makara']['connections'].select{|h| h['role'] == 'slave' }.each{|h| h['username'] = 'other'}
+
+      original_method = ActiveRecord::Base.method(:mysql2_connection)
+
+      allow(ActiveRecord::Base).to receive(:mysql2_connection) do |config|
+        if config[:username] == 'other'
+          raise "could not connect"
+        else
+          original_method.call(config)
+        end
+      end
+
+      ActiveRecord::Base.establish_connection(wrong_config)
+      ActiveRecord::Base.connection
+
+      load(File.dirname(__FILE__) + '/../../support/schema.rb')
+      Makara::Context.set_current Makara::Context.generate
+
+      allow(ActiveRecord::Base).to receive(:mysql2_connection) do |config|
+        config[:username] = db_username
+        original_method.call(config)
+      end
+
+      ActiveRecord::Base.connection.slave_pool.connections.each(&:_makara_whitelist!)
+      ActiveRecord::Base.connection.slave_pool.provide do |con|
+        res = con.execute('SELECT count(*) FROM users')
+        if defined?(JRUBY_VERSION)
+          expect(res[0]).to eq('count(*)' => 0)
+        else
+          expect(res.to_a[0][0]).to eq(0)
+        end
+      end
+
+      ActiveRecord::Base.remove_connection
+    end
+
+    it 'should execute a send_to_all against master even if no slaves are connected' do
+      ActiveRecord::Base.establish_connection(config)
+      connection = ActiveRecord::Base.connection
+
+      connection.slave_pool.connections.each do |c|
+        allow(c).to receive(:_makara_blacklisted?){ true }
+        allow(c).to receive(:_makara_connected?){ false }
+        expect(c).to receive(:execute).with('SET @t1 = 1').never
+      end
+
+      connection.master_pool.connections.each do |c|
+        expect(c).to receive(:execute).with('SET @t1 = 1')
+      end
+
+      expect{
+        connection.execute('SET @t1 = 1')
+      }.not_to raise_error
+    end
+
+    it 'should execute a send_to_all and raise a NoConnectionsAvailable error' do
+      ActiveRecord::Base.establish_connection(config)
+      connection = ActiveRecord::Base.connection
+
+      (connection.slave_pool.connections | connection.master_pool.connections).each do |c|
+        allow(c).to receive(:_makara_blacklisted?){ true }
+        allow(c).to receive(:_makara_connected?){ false }
+        expect(c).to receive(:execute).with('SET @t1 = 1').never
+      end
+
+      expect{
+        connection.execute('SET @t1 = 1')
+      }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+
+    end
+
+  end
+
+  context 'with the connection established and schema loaded' do
+
+    let(:connection) { ActiveRecord::Base.connection }
+
+    before do
+      ActiveRecord::Base.establish_connection(config)
+      load(File.dirname(__FILE__) + '/../../support/schema.rb')
+      change_context
+    end
+
+
+    it 'should have one master and two slaves' do
+      expect(connection.master_pool.connection_count).to eq(1)
+      expect(connection.slave_pool.connection_count).to eq(2)
+    end
+
+    it 'should allow real queries to work' do
+      connection.execute("INSERT INTO users (name) VALUES ('John')")
+
+      connection.master_pool.connections.each do |master|
+        expect(master).to receive(:execute).never
+      end
+
+      change_context
+
+      res = connection.execute('SELECT name FROM users ORDER BY id DESC LIMIT 1')
+
+      if defined?(JRUBY_VERSION)
+        expect(res[0]['name']).to eq('John')
+      else
+        expect(res.to_a[0][0]).to eq('John')
+      end
+    end
+
+    it 'should send SET operations to each connection' do
+      connection.master_pool.connections.each do |con|
+        expect(con).to receive(:execute).with('SET @t1 = 1').once
+      end
+
+      connection.slave_pool.connections.each do |con|
+        expect(con).to receive(:execute).with('SET @t1 = 1').once
+      end
+      connection.execute("SET @t1 = 1")
+    end
+
+    it 'should send reads to the slave' do
+      # ensure the next connection will be the first one
+      connection.slave_pool.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
+
+      con = connection.slave_pool.connections.first
+      expect(con).to receive(:execute).with('SELECT * FROM users').once
+
+      connection.execute('SELECT * FROM users')
+    end
+
+    it 'should send writes to master' do
+      con = connection.master_pool.connections.first
+      expect(con).to receive(:execute).with('UPDATE users SET name = "bob" WHERE id = 1')
+      connection.execute('UPDATE users SET name = "bob" WHERE id = 1')
+    end
+
+    it 'should allow reconnecting' do
+      connection.object_id
+      connection.reconnect!
+    end
+
+    it 'should allow reconnecting when one of the nodes is blacklisted' do
+      con = connection.slave_pool.connections.first
+      allow(con).to receive(:_makara_blacklisted?){ true }
+      connection.reconnect!
+    end
+
+    if !defined?(JRUBY_VERSION)
+      # yml settings only for mysql2
+      it 'should blacklist on timeout' do
+        expect {
+          connection.execute('SELECT SLEEP(2)') # read timeout set to 1
+        }.to raise_error(Makara::Errors::AllConnectionsBlacklisted)
+      end
+    end
+
+  end
+
+end

data/spec/active_record/connection_adapters/makara_postgresql_adapter_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+describe 'MakaraPostgreSQLAdapter' do
+
+  let(:db_username){ ENV['TRAVIS'] ? 'postgres' : `whoami`.chomp }
+
+  let(:config){
+    base = YAML.load_file(File.expand_path('spec/support/postgresql_database.yml'))['test']
+    base['username'] = db_username
+    base
+  }
+
+  let(:connection) { ActiveRecord::Base.connection }
+
+  before :each do
+    ActiveRecord::Base.clear_all_connections!
+    change_context
+  end
+
+
+  it 'should allow a connection to be established' do
+    ActiveRecord::Base.establish_connection(config)
+    expect(ActiveRecord::Base.connection).to be_instance_of(ActiveRecord::ConnectionAdapters::MakaraPostgreSQLAdapter)
+  end
+
+  context 'with the connection established and schema loaded' do
+
+    before do
+      ActiveRecord::Base.establish_connection(config)
+      load(File.dirname(__FILE__) + '/../../support/schema.rb')
+      change_context
+    end
+
+
+    it 'should have one master and two slaves' do
+      expect(connection.master_pool.connection_count).to eq(1)
+      expect(connection.slave_pool.connection_count).to eq(2)
+    end
+
+    it 'should allow real queries to work' do
+      connection.execute('INSERT INTO users (name) VALUES (\'John\')')
+
+      connection.master_pool.connections.each do |master|
+        expect(master).to receive(:execute).never
+      end
+
+      change_context
+      res = connection.execute('SELECT name FROM users ORDER BY id DESC LIMIT 1')
+
+      expect(res.to_a[0]['name']).to eq('John')
+    end
+
+    it 'should send SET operations to each connection' do
+      connection.master_pool.connections.each do |con|
+        expect(con).to receive(:execute).with("SET TimeZone = 'UTC'").once
+      end
+
+      connection.slave_pool.connections.each do |con|
+        expect(con).to receive(:execute).with("SET TimeZone = 'UTC'").once
+      end
+      connection.execute("SET TimeZone = 'UTC'")
+    end
+
+    it 'should send reads to the slave' do
+      # ensure the next connection will be the first one
+      connection.slave_pool.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
+
+      con = connection.slave_pool.connections.first
+      expect(con).to receive(:execute).with('SELECT * FROM users').once
+
+      connection.execute('SELECT * FROM users')
+    end
+
+    it 'should send writes to master' do
+      con = connection.master_pool.connections.first
+      expect(con).to receive(:execute).with('UPDATE users SET name = "bob" WHERE id = 1')
+      connection.execute('UPDATE users SET name = "bob" WHERE id = 1')
+    end
+
+  end
+
+  context 'without live connections' do
+      it 'should raise errors on read or write' do
+        allow(ActiveRecord::Base).to receive(:postgresql_connection).and_raise(StandardError.new('could not connect to server: Connection refused'))
+
+        ActiveRecord::Base.establish_connection(config)
+        expect { connection.execute('SELECT * FROM users') }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+        expect { connection.execute('INSERT INTO users (name) VALUES (\'John\')') }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+      end
+    end
+
+    context 'with only master connection' do
+      it 'should not raise errors on read and write' do
+        custom_config = config.deep_dup
+        custom_config['makara']['connections'].select{|h| h['role'] == 'slave' }.each{|h| h['port'] = '1'}
+
+        ActiveRecord::Base.establish_connection(custom_config)
+        load(File.dirname(__FILE__) + '/../../support/schema.rb')
+
+        connection.execute('SELECT * FROM users')
+        connection.execute('INSERT INTO users (name) VALUES (\'John\')')
+      end
+    end
+
+    context 'with only slave connection' do
+      it 'should raise error only on write' do
+        ActiveRecord::Base.establish_connection(config)
+        load(File.dirname(__FILE__) + '/../../support/schema.rb')
+        ActiveRecord::Base.clear_all_connections!
+
+        custom_config = config.deep_dup
+        custom_config['makara']['connections'].select{|h| h['role'] == 'master' }.each{|h| h['port'] = '1'}
+
+        ActiveRecord::Base.establish_connection(custom_config)
+
+        connection.execute('SELECT * FROM users')
+        expect { connection.execute('INSERT INTO users (name) VALUES (\'John\')') }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+      end
+    end
+end