master_slave_adapter 1.0.0.beta1 → 1.0.0.beta2

data/lib/active_record/connection_adapters/mysql2_master_slave_adapter.rb

@@ -0,0 +1,48 @@
+require 'active_record/connection_adapters/master_slave_adapter'
+require 'active_record/connection_adapters/master_slave_adapter/clock'
+require 'active_record/connection_adapters/master_slave_adapter/shared_mysql_adapter_behavior'
+require 'active_record/connection_adapters/mysql2_adapter'
+require 'mysql2'
+
+module ActiveRecord
+  class Base
+    def self.mysql2_master_slave_connection(config)
+      ConnectionAdapters::Mysql2MasterSlaveAdapter.new(config, logger)
+    end
+  end
+
+  module ConnectionAdapters
+    class Mysql2MasterSlaveAdapter < AbstractAdapter
+      include MasterSlaveAdapter
+      include SharedMysqlAdapterBehavior
+
+    private
+
+      def select_hash(conn, sql)
+        conn.select_one(sql)
+      end
+
+      CONNECTION_ERRORS = {
+        2002 => "query: not connected",                         # CR_CONNECTION_ERROR
+        2003 => "Can't connect to MySQL server on",             # CR_CONN_HOST_ERROR
+        2006 => "MySQL server has gone away",                   # CR_SERVER_GONE_ERROR
+        2013 => "Lost connection to MySQL server during query", # CR_SERVER_LOST
+        -1   => "closed MySQL connection",                      # defined by Mysql2
+      }
+
+      def connection_error?(exception)
+        case exception
+        when ActiveRecord::StatementInvalid
+          CONNECTION_ERRORS.values.any? do |description|
+            exception.message.start_with?("Mysql2::Error: #{description}")
+          end
+        when Mysql2::Error
+          CONNECTION_ERRORS.keys.include?(exception.errno)
+        else
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql_master_slave_adapter.rb

@@ -1,7 +1,7 @@
-require 'active_record'
 require 'active_record/connection_adapters/master_slave_adapter'
-require 'active_record/connection_adapters/master_slave_adapter/clock'
+require 'active_record/connection_adapters/master_slave_adapter/shared_mysql_adapter_behavior'
 require 'active_record/connection_adapters/mysql_adapter'
+require 'mysql'
 
 module ActiveRecord
   class Base
@@ -11,51 +11,31 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class MysqlMasterSlaveAdapter < MasterSlaveAdapter::Base
-      CONNECTION_ERRORS = [
-        Mysql::Error::CR_CONNECTION_ERROR,  # query: not connected
-        Mysql::Error::CR_CONN_HOST_ERROR,   # Can't connect to MySQL server on '%s' (%d)
-        Mysql::Error::CR_SERVER_GONE_ERROR, # MySQL server has gone away
-        Mysql::Error::CR_SERVER_LOST,       # Lost connection to MySQL server during query
-      ]
+    class MysqlMasterSlaveAdapter < AbstractAdapter
+      include MasterSlaveAdapter
+      include SharedMysqlAdapterBehavior
 
-      def with_consistency(clock)
-        clock =
-          case clock
-          when Clock  then clock
-          when String then Clock.parse(clock)
-          when nil    then Clock.zero
-          end
-
-        super(clock)
-      end
+    private
 
-      # TODO: only do the actual conenction specific things here
-      def master_clock
-        conn = master_connection
-        if status = conn.uncached { conn.select_one("SHOW MASTER STATUS") }
-          Clock.new(status['File'], status['Position'])
-        else
-          Clock.infinity
+      if MysqlAdapter.instance_methods.map(&:to_sym).include?(:exec_without_stmt)
+        # The MysqlAdapter in ActiveRecord > v3.1 uses prepared statements which
+        # don't return any results for queries like "SHOW MASTER/SLAVE STATUS",
+        # so we have to use normal queries here.
+        def select_hash(conn, sql)
+          conn.exec_without_stmt(sql).first
         end
-      rescue MasterUnavailable
-        Clock.zero
-      rescue
-        Clock.infinity
-      end
-
-      # TODO: only do the actual conenction specific things here
-      def slave_clock(conn)
-        if status = conn.uncached { conn.select_one("SHOW SLAVE STATUS") }
-          Clock.new(status['Relay_Master_Log_File'], status['Exec_Master_Log_Pos'])
-        else
-          Clock.zero
+      else
+        def select_hash(conn, sql)
+          conn.select_one(sql)
         end
-      rescue
-        Clock.zero
       end
 
-    private
+      CONNECTION_ERRORS = [
+        Mysql::Error::CR_CONNECTION_ERROR,  # query: not connected
+        Mysql::Error::CR_CONN_HOST_ERROR,   # Can't connect to MySQL server on '%s' (%d)
+        Mysql::Error::CR_SERVER_GONE_ERROR, # MySQL server has gone away
+        Mysql::Error::CR_SERVER_LOST,       # Lost connection to MySQL server during query
+      ]
 
       def connection_error?(exception)
         case exception
@@ -67,6 +47,7 @@ module ActiveRecord
           false
         end
       end
+
     end
   end
 end

data/master_slave_adapter.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version     = '>= 1.8.7'
   s.required_rubygems_version = '>= 1.3.7'
 
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rake'
+  s.add_dependency 'activerecord', ['>= 2.3.9', '<= 4.0']
 
-  s.add_dependency 'activerecord', '~> 2.3.9'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
 end

data/spec/all.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+source ~/.rvm/scripts/rvm
+
+for ruby in 1.8.7 1.9.2 1.9.3; do
+  rvm use $ruby
+  for gemfile in spec/gemfiles/*; do
+    if [[ "$gemfile" =~ \.lock ]]; then
+      continue
+    fi
+
+    BUNDLE_GEMFILE=$gemfile bundle install --quiet
+    BUNDLE_GEMFILE=$gemfile bundle exec rake spec
+  done
+done

data/spec/gemfiles/activerecord2.3

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem "mysql", "~> 2.8.1"
+gem "activerecord", "~> 2.3.14"
+gemspec :path=>"../../"

data/spec/gemfiles/activerecord3.0

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem "mysql", "~> 2.8.1"
+gem "activerecord", "~> 3.0.0"
+gemspec :path=>"../../"

data/spec/gemfiles/activerecord3.2

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem "mysql", "~> 2.8.1"
+gem "mysql2", "~> 0.3.11"
+gem "activerecord", "~> 3.2.3"
+gemspec :path=>"../../"

data/spec/integration/helpers/mysql_helper.rb

@@ -0,0 +1,174 @@
+require 'fileutils'
+require 'timeout'
+
+module MysqlHelper
+  MASTER_ID   = "1"
+  MASTER_PORT = 3310
+  SLAVE_ID    = "2"
+  SLAVE_PORT  = 3311
+  TEST_TABLE  = "master_slave_adapter.master_slave_test"
+
+  def port(identifier)
+    case identifier
+    when :master then MASTER_PORT
+    when :slave  then SLAVE_PORT
+    end
+  end
+
+  def server_id(identifier)
+    case identifier
+    when :master then MASTER_ID
+    when :slave  then SLAVE_ID
+    end
+  end
+
+  def start_replication
+    execute(:slave, "start slave")
+  end
+
+  def stop_replication
+    execute(:slave, "stop slave")
+  end
+
+  def move_master_clock
+    execute(:master, "insert into #{TEST_TABLE} (message) VALUES ('test')")
+  end
+
+  def wait_for_replication_sync
+    Timeout.timeout(5) do
+      until slave_status == master_status; end
+    end
+  rescue Timeout::Error
+    raise "Replication synchronization failed"
+  end
+
+  def configure
+    execute(:master, <<-EOS)
+      SET sql_log_bin = 0;
+      create user 'slave'@'localhost' identified by 'slave';
+      grant replication slave on *.* to 'slave'@'localhost';
+      create database master_slave_adapter;
+      SET sql_log_bin = 1;
+    EOS
+
+    execute(:slave, <<-EOS)
+      change master to master_user = 'slave',
+             master_password = 'slave',
+             master_port = #{port(:master)},
+             master_host = 'localhost';
+      create database master_slave_adapter;
+    EOS
+
+    execute(:master, <<-EOS)
+      CREATE TABLE #{TEST_TABLE} (
+        id int(11) NOT NULL AUTO_INCREMENT,
+        message text COLLATE utf8_unicode_ci,
+        created_at datetime DEFAULT NULL,
+        PRIMARY KEY (id)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+    EOS
+  end
+
+  def setup
+    [:master, :slave].each do |name|
+      path        = location(name)
+      config_path = File.join(path, "my.cnf")
+      data_path   = File.join(path, "data")
+      base_dir    = File.dirname(File.dirname(`which mysql_install_db`))
+
+      FileUtils.rm_rf(path)
+      FileUtils.mkdir_p(path)
+      File.open(config_path, "w") { |file| file << config(name) }
+
+      `mysql_install_db --basedir='#{base_dir}' --datadir='#{data_path}'`
+    end
+  end
+
+  def start_master
+    start(:master)
+  end
+
+  def stop_master
+    stop(:master)
+  end
+
+  def start_slave
+    start(:slave)
+  end
+
+  def stop_slave
+    stop(:slave)
+  end
+
+private
+
+  def slave_status
+    status(:slave).values_at(9, 21)
+  end
+
+  def master_status
+    status(:master).values_at(0, 1)
+  end
+
+  def status(name)
+    `mysql --protocol=TCP -P#{port(name)} -uroot -N -s -e 'show #{name} status'`.strip.split("\t")
+  end
+
+  def execute(host, statement = '')
+    system(%{mysql --protocol=TCP -P#{port(host)} -uroot -e "#{statement}"})
+  end
+
+  def start(name)
+    $pipes ||= {}
+    $pipes[name] = IO.popen("mysqld --defaults-file='#{location(name)}/my.cnf'")
+    wait_for_database_boot(name)
+  end
+
+  def stop(name)
+    pipe = $pipes[name]
+    Process.kill("KILL", pipe.pid)
+    Process.wait(pipe.pid, Process::WNOHANG)
+
+    # Ruby 1.8.7 doesn't support IO.popen([cmd, [arg, ]]) syntax, and passing
+    # the command line as string wraps the process in a shell. The IO#pid method
+    # will then only return the pid of the wrapping shell process, which is not
+    # what we need here.
+    mysqld_pid = `ps a | grep 'mysqld.*#{location(name)}/my.cnf' | grep -v grep | awk '{print $1}'`.to_i
+    Process.kill("KILL", mysqld_pid) unless mysqld_pid.zero?
+  ensure
+    pipe.close unless pipe.closed?
+  end
+
+  def started?(host)
+    system(%{mysql --protocol=TCP -P#{port(host)} -uroot -e '' 2> /dev/null})
+  end
+
+  def wait_for_database_boot(host)
+    Timeout.timeout(5) do
+      until started?(host); sleep(0.1); end
+    end
+  rescue Timeout::Error
+    raise "Couldn't connect to MySQL in time"
+  end
+
+  def location(name)
+    File.expand_path(File.join("..", "mysql", name.to_s), File.dirname(__FILE__))
+  end
+
+  def config(name)
+    path = location(name)
+
+    <<-EOS
+[mysqld]
+pid-file = #{path}/mysqld.pid
+socket = #{path}/mysqld.sock
+port = #{port(name)}
+log-error = #{path}/error.log
+datadir = #{path}/data
+log-bin = #{name}-bin
+log-bin-index = #{name}-bin.index
+server-id = #{server_id(name)}
+lower_case_table_names = 1
+    EOS
+  end
+end

data/spec/integration/helpers/shared_mysql_examples.rb

@@ -0,0 +1,212 @@
+require 'integration/helpers/mysql_helper'
+
+shared_examples_for "a MySQL MasterSlaveAdapter" do
+  include MysqlHelper
+
+  let(:configuration) do
+    {
+      :adapter => 'master_slave',
+      :connection_adapter => connection_adapter,
+      :username => 'root',
+      :database => 'master_slave_adapter',
+      :master => {
+        :host => '127.0.0.1',
+        :port => port(:master),
+      },
+      :slaves => [{
+        :host => '127.0.0.1',
+        :port => port(:slave),
+      }],
+    }
+  end
+
+  let(:test_table) { MysqlHelper::TEST_TABLE }
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  def should_read_from(host)
+    server = server_id(host)
+    query  = "SELECT @@Server_id as Value"
+
+    connection.select_all(query).first["Value"].to_s.should == server
+    connection.select_one(query)["Value"].to_s.should == server
+    connection.select_rows(query).first.first.to_s.should == server
+    connection.select_value(query).to_s.should == server
+    connection.select_values(query).first.to_s.should == server
+  end
+
+  before(:all) do
+    setup
+    start_master
+    start_slave
+    configure
+    start_replication
+  end
+
+  after(:all) do
+    stop_master
+    stop_slave
+  end
+
+  before do
+    ActiveRecord::Base.establish_connection(configuration)
+  end
+
+  it "connects to the database" do
+    expect { ActiveRecord::Base.connection }.to_not raise_error
+  end
+
+  context "given a debug logger" do
+    let(:debug_logger) do
+      logger = []
+      def logger.debug(*args)
+        push(args.join)
+      end
+      def logger.debug?
+        true
+      end
+
+      logger
+    end
+
+    before do
+      ActiveRecord::Base.logger = debug_logger
+    end
+
+    after do
+      ActiveRecord::Base.logger = nil
+    end
+
+    it "logs the connection info" do
+      ActiveRecord::Base.connection.select_value("SELECT 42")
+
+      debug_logger.last.should =~ /\[slave:127.0.0.1:3311\] SQL .*SELECT 42/
+    end
+  end
+
+  context "when asked for master" do
+    it "reads from master" do
+      ActiveRecord::Base.with_master do
+        should_read_from :master
+      end
+    end
+  end
+
+  context "when asked for slave" do
+    it "reads from slave" do
+      ActiveRecord::Base.with_slave do
+        should_read_from :slave
+      end
+    end
+  end
+
+  context "when asked for consistency" do
+    context "given slave is fully synced" do
+      before do
+        wait_for_replication_sync
+      end
+
+      it "reads from slave" do
+        ActiveRecord::Base.with_consistency(connection.master_clock) do
+          should_read_from :slave
+        end
+      end
+    end
+
+    context "given slave lags behind" do
+      before do
+        stop_replication
+        move_master_clock
+      end
+
+      after do
+        start_replication
+      end
+
+      it "reads from master" do
+        ActiveRecord::Base.with_consistency(connection.master_clock) do
+          should_read_from :master
+        end
+      end
+
+      context "and slave catches up" do
+        before do
+          start_replication
+          wait_for_replication_sync
+        end
+
+        it "reads from slave" do
+          ActiveRecord::Base.with_consistency(connection.master_clock) do
+            should_read_from :slave
+          end
+        end
+      end
+    end
+
+    context "given we always wait for slave to catch up and be consistent" do
+      before do
+        start_replication
+      end
+
+      it "should always read from slave" do
+        wait_for_replication_sync
+        ActiveRecord::Base.with_consistency(connection.master_clock) do
+          should_read_from :slave
+        end
+        move_master_clock
+        wait_for_replication_sync
+        ActiveRecord::Base.with_consistency(connection.master_clock) do
+          should_read_from :slave
+        end
+      end
+    end
+  end
+
+  context "given master goes away in between queries" do
+    let(:query) { "INSERT INTO #{test_table} (message) VALUES ('test')" }
+
+    after do
+      start_master
+    end
+
+    it "raises a MasterUnavailable exception" do
+      expect do
+        ActiveRecord::Base.connection.insert(query)
+      end.to_not raise_error
+
+      stop_master
+
+      expect do
+        ActiveRecord::Base.connection.insert(query)
+      end.to raise_error(ActiveRecord::MasterUnavailable)
+    end
+  end
+
+  context "given master is not available" do
+    before(:all) do
+      stop_master
+    end
+
+    after(:all) do
+      start_master
+    end
+
+    context "when asked for master" do
+      it "fails" do
+        expect do
+          ActiveRecord::Base.with_master { should_read_from :master }
+        end.to raise_error(ActiveRecord::MasterUnavailable)
+      end
+    end
+
+    context "when asked for slave" do
+      it "reads from slave" do
+        ActiveRecord::Base.with_slave do
+          should_read_from :slave
+        end
+      end
+    end
+  end
+end

data/spec/integration/mysql2_master_slave_adapter_spec.rb

@@ -0,0 +1,11 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require 'rspec'
+require 'master_slave_adapter'
+require 'integration/helpers/shared_mysql_examples'
+
+describe "ActiveRecord::ConnectionAdapters::Mysql2MasterSlaveAdapter" do
+  let(:connection_adapter) { 'mysql2' }
+
+  it_should_behave_like "a MySQL MasterSlaveAdapter"
+end

data/spec/integration/mysql_master_slave_adapter_spec.rb

@@ -0,0 +1,11 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require 'rspec'
+require 'master_slave_adapter'
+require 'integration/helpers/shared_mysql_examples'
+
+describe "ActiveRecord::ConnectionAdapters::MysqlMasterSlaveAdapter" do
+  let(:connection_adapter) { 'mysql' }
+
+  it_should_behave_like "a MySQL MasterSlaveAdapter"
+end