master_slave_adapter 0.2.0 → 1.0.0.beta1

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
+  - 1.8.7
   - 1.9.2
   - 1.9.3

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 1.0.0 (not released yet)
+
+* Add support for unavailable master connection
+* Fallback to slave connection if possible
+* Restrict the public interface. Removed the following methods:
+  * all class methods from ActiveRecord::ConnectionAdapters::MasterSlaveAdapter
+  * #current_connection=
+  * #current_clock=
+  * #slave_consistent?
+* Fix 1.8.7 compliance
+
 # 0.2.0 (April 2, 2012)
 
 * Add support for ActiveRecord's query cache

data/TODO.txt

@@ -1,8 +1,18 @@
 Read only mode
 --------------
 
-- Add better fallback to connection_for_read
+- Write tests
+  - Clock.parse
+  - connection_error (integration test)
+  - integration tests
+  - with_consistency accepts string clock
+  - raise MasterUnavailable in all cases
+  - connection stack usage
 
-- write tests
-- extract adapter specific code
-- make everything nice
+- Check
+  - thread safety
+  - AR reconnect behavior / connection check
+  - replication in other databases
+
+- restructure MasterSlaveAdapter with proper namespaces
+- make clock private

data/lib/active_record/connection_adapters/master_slave_adapter/circuit_breaker.rb

@@ -0,0 +1,61 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MasterSlaveAdapter
+      class CircuitBreaker
+        def initialize(logger = nil, failure_threshold = 5, timeout = 30)
+          @logger = logger
+          @failure_count = 0
+          @failure_threshold = failure_threshold
+          @timeout = timeout
+          @state = :closed
+        end
+
+        def tripped?
+          if open? && timeout_exceeded?
+            change_state_to :half_open
+          end
+
+          open?
+        end
+
+        def success!
+          if !closed?
+            @failure_count = 0
+            change_state_to :closed
+          end
+        end
+
+        def fail!
+          @failure_count += 1
+          if !open? && @failure_count >= @failure_threshold
+            @opened_at = Time.now
+            change_state_to :open
+          end
+        end
+
+      private
+
+        def open?
+          :open == @state
+        end
+
+        def half_open?
+          :half_open == @state
+        end
+
+        def closed?
+          :closed == @state
+        end
+
+        def timeout_exceeded?
+          (Time.now - @opened_at) >= @timeout
+        end
+
+        def change_state_to(state)
+          @state = state
+          @logger && @logger.warn("circuit is now #{state}")
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/master_slave_adapter/clock.rb

@@ -0,0 +1,42 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MasterSlaveAdapter
+      class Clock
+        include Comparable
+        attr_reader :file, :position
+
+        def initialize(file, position)
+          raise ArgumentError, "file and postion may not be nil" if file.nil? || position.nil?
+          @file, @position = file, position.to_i
+        end
+
+        def <=>(other)
+          @file == other.file ? @position <=> other.position : @file <=> other.file
+        end
+
+        def to_s
+          [ @file, @position ].join('@')
+        end
+
+        def infinity?
+          self == self.class.infinity
+        end
+
+        def self.zero
+          @zero ||= Clock.new('', 0)
+        end
+
+        def self.infinity
+          @infinity ||= Clock.new('', Float::MAX.to_i)
+        end
+
+        # TODO: tests
+        def self.parse(string)
+          new(*string.split('@'))
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/master_slave_adapter/version.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MasterSlaveAdapter
+      VERSION = "1.0.0.beta1"
+    end
+  end
+end

data/lib/active_record/connection_adapters/master_slave_adapter.rb

@@ -1 +1,501 @@
-require 'master_slave_adapter'
+require 'active_record'
+require 'active_record/connection_adapters/master_slave_adapter/circuit_breaker'
+
+module ActiveRecord
+  class MasterUnavailable < ConnectionNotEstablished; end
+
+  class Base
+    class << self
+      def with_consistency(clock, &blk)
+        if connection.respond_to? :with_consistency
+          connection.with_consistency(clock, &blk)
+        else
+          yield
+          nil
+        end
+      end
+
+      def with_master(&blk)
+        if connection.respond_to? :with_master
+          connection.with_master(&blk)
+        else
+          yield
+        end
+      end
+
+      def with_slave(&blk)
+        if connection.respond_to? :with_slave
+          connection.with_slave(&blk)
+        else
+          yield
+        end
+      end
+
+      def on_commit(&blk)
+        connection.on_commit(&blk) if connection.respond_to? :on_commit
+      end
+
+      def on_rollback(&blk)
+        connection.on_rollback(&blk) if connection.respond_to? :on_rollback
+      end
+
+      def master_slave_connection(config)
+        config  = massage(config)
+        name    = config.fetch(:connection_adapter)
+        adapter = "#{name.classify}MasterSlaveAdapter"
+
+        load_adapter("#{name}_master_slave")
+        ConnectionAdapters.const_get(adapter).new(config, logger)
+      end
+
+    private
+
+      def massage(config)
+        config = config.symbolize_keys
+        skip = [ :adapter, :connection_adapter, :master, :slaves ]
+        defaults = config.
+          reject { |k,_| skip.include?(k) }.
+          merge(:adapter => config.fetch(:connection_adapter))
+        ([config.fetch(:master)] + config.fetch(:slaves, [])).map do |cfg|
+          cfg.symbolize_keys!.reverse_merge!(defaults)
+        end
+        config
+      end
+
+      def load_adapter(adapter_name)
+        unless respond_to?("#{adapter_name}_connection")
+          begin
+            require "active_record/connection_adapters/#{adapter_name}_adapter"
+          rescue LoadError
+            begin
+              require 'rubygems'
+              gem "activerecord-#{adapter_name}-adapter"
+              require "active_record/connection_adapters/#{adapter_name}_adapter"
+            rescue LoadError
+              raise %Q{Please install the #{adapter_name} adapter:
+                       `gem install activerecord-#{adapter_name}-adapter` (#{$!})"}
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    class AbstractAdapter
+      alias_method :orig_log_info, :log_info
+      def log_info(sql, name, ms)
+        connection_name =
+          [ @config[:name], @config[:host], @config[:port] ].compact.join(":")
+        orig_log_info sql, "[#{connection_name}] #{name || 'SQL'}", ms
+      end
+    end
+
+    module MasterSlaveAdapter
+      class Base < AbstractAdapter
+        def initialize(config, logger)
+          super(nil, logger)
+
+          @config = config
+
+          @connections = {}
+          @connections[:master] = connect_to_master
+          @connections[:slaves] = @config.fetch(:slaves).map { |cfg| connect(cfg, :slave) }
+
+          @disable_connection_test = @config[:disable_connection_test] == 'true'
+          @circuit = CircuitBreaker.new(logger)
+
+          self.current_connection = slave_connection!
+        end
+
+        # MASTER SLAVE ADAPTER INTERFACE ========================================
+
+        def with_master
+          with(master_connection) { yield }
+        end
+
+        def with_slave
+          with(slave_connection!) { yield }
+        end
+
+        def with_consistency(clock)
+          if clock.nil?
+            raise ArgumentError, "consistency must be a valid comparable value"
+          end
+
+          # try random slave, else fall back to master
+          slave = slave_connection!
+          conn =
+            if !open_transaction? && slave_consistent?(slave, clock)
+              slave
+            else
+              master_connection
+            end
+
+          with(conn) { yield }
+
+          current_clock || clock
+        end
+
+        def on_commit(&blk)
+          on_commit_callbacks.push blk
+        end
+
+        def on_rollback(&blk)
+          on_rollback_callbacks.push blk
+        end
+
+        # ADAPTER INTERFACE OVERRIDES ===========================================
+
+        def insert(*args)
+          on_write { |conn| conn.insert(*args) }
+        end
+
+        def update(*args)
+          on_write { |conn| conn.update(*args) }
+        end
+
+        def delete(*args)
+          on_write { |conn| conn.delete(*args) }
+        end
+
+        def commit_db_transaction
+          on_write { |conn| conn.commit_db_transaction }
+          on_commit_callbacks.shift.call(current_clock) until on_commit_callbacks.blank?
+        end
+
+        def rollback_db_transaction
+          on_commit_callbacks.clear
+          with(master_connection) { |conn| conn.rollback_db_transaction }
+          on_rollback_callbacks.shift.call until on_rollback_callbacks.blank?
+        end
+
+        def active?
+          return true if @disable_connection_test
+          connections.map { |c| c.active? }.all?
+        end
+
+        def reconnect!
+          connections.each { |c| c.reconnect! }
+        end
+
+        def disconnect!
+          connections.each { |c| c.disconnect! }
+        end
+
+        def reset!
+          connections.each { |c| c.reset! }
+        end
+
+        def cache(&blk)
+          connections.inject(blk) do |block, connection|
+            lambda { connection.cache(&block) }
+          end.call
+        end
+
+        def uncached(&blk)
+          connections.inject(blk) do |block, connection|
+            lambda { connection.uncached(&block) }
+          end.call
+        end
+
+        def clear_query_cache
+          connections.each { |connection| connection.clear_query_cache }
+        end
+
+        # Someone calling execute directly on the connection is likely to be a
+        # write, respectively some DDL statement. People really shouldn't do that,
+        # but let's delegate this to master, just to be sure.
+        def execute(*args)
+          on_write { |conn| conn.execute(*args) }
+        end
+
+        # ADAPTER INTERFACE DELEGATES ===========================================
+
+        def self.rescued_delegate(*methods)
+          options = methods.pop
+          to = options[:to]
+
+          file, line = caller.first.split(':', 2)
+          line = line.to_i
+
+          methods.each do |method|
+            module_eval(<<-EOS, file, line)
+              def #{method}(*args, &block)
+                begin
+                  #{to}.__send__(:#{method}, *args, &block)
+                rescue => exception
+                  if master_connection?(#{to}) && connection_error?(exception)
+                    reset_master_connection
+                    raise MasterUnavailable
+                  else
+                    raise
+                  end
+                end
+              end
+            EOS
+          end
+        end
+        class << self; private :rescued_delegate; end
+
+        # === must go to master
+        rescued_delegate :adapter_name,
+                         :supports_migrations?,
+                         :supports_primary_key?,
+                         :supports_savepoints?,
+                         :native_database_types,
+                         :raw_connection,
+                         :open_transactions,
+                         :increment_open_transactions,
+                         :decrement_open_transactions,
+                         :transaction_joinable=,
+                         :create_savepoint,
+                         :rollback_to_savepoint,
+                         :release_savepoint,
+                         :current_savepoint_name,
+                         :begin_db_transaction,
+                         :outside_transaction?,
+                         :add_limit!,
+                         :default_sequence_name,
+                         :reset_sequence!,
+                         :insert_fixture,
+                         :empty_insert_statement,
+                         :case_sensitive_equality_operator,
+                         :limited_update_conditions,
+                         :insert_sql,
+                         :update_sql,
+                         :delete_sql,
+                         :to => :master_connection
+        # schema statements
+        rescued_delegate :table_exists?,
+                         :create_table,
+                         :change_table,
+                         :rename_table,
+                         :drop_table,
+                         :add_column,
+                         :remove_column,
+                         :remove_columns,
+                         :change_column,
+                         :change_column_default,
+                         :rename_column,
+                         :add_index,
+                         :remove_index,
+                         :remove_index!,
+                         :rename_index,
+                         :index_name,
+                         :index_exists?,
+                         :structure_dump,
+                         :dump_schema_information,
+                         :initialize_schema_migrations_table,
+                         :assume_migrated_upto_version,
+                         :type_to_sql,
+                         :add_column_options!,
+                         :distinct,
+                         :add_order_by_for_association_limiting!,
+                         :add_timestamps,
+                         :remove_timestamps,
+                         :to => :master_connection
+        # ActiveRecord 3.0
+        rescued_delegate :visitor,
+                         :to => :master_connection
+        # no clear interface contract:
+        rescued_delegate :tables,         # commented in SchemaStatements
+                         :truncate_table, # monkeypatching database_cleaner gem
+                         :primary_key,    # is Base#primary_key meant to be the contract?
+                         :to => :master_connection
+        # No need to be so picky about these methods
+        rescued_delegate :add_limit_offset!, # DatabaseStatements
+                         :add_lock!, #DatabaseStatements
+                         :columns,
+                         :table_alias_for,
+                         :to => :prefer_master_connection
+
+        # ok, we might have missed more
+        def method_missing(name, *args, &blk)
+          master_connection.send(name.to_sym, *args, &blk).tap do
+            @logger.try(:warn, %Q{
+              You called the unsupported method '#{name}' on #{self.class.name}.
+              In order to help us improve master_slave_adapter, please report this
+              to: https://github.com/soundcloud/master_slave_adapter/issues
+
+              Thank you.
+            })
+          end
+        rescue => exception
+          if connection_error?(exception)
+            reset_master_connection
+            raise MasterUnavailable
+          else
+            raise
+          end
+        end
+
+        # === determine read connection
+        rescued_delegate :select_all,
+                         :select_one,
+                         :select_rows,
+                         :select_value,
+                         :select_values,
+                         :to => :connection_for_read
+
+        def connection_for_read
+          open_transaction? ? master_connection : current_connection
+        end
+        private :connection_for_read
+
+        # === doesn't really matter, but must be handled by underlying adapter
+        rescued_delegate *(ActiveRecord::ConnectionAdapters::Quoting.instance_methods + [{
+                         :to => :current_connection }])
+        # issue #4: current_database is not supported by all adapters, though
+        rescued_delegate :current_database, :to => :current_connection
+
+        # UTIL ==================================================================
+
+        def master_connection
+          if circuit.tripped?
+            raise MasterUnavailable
+          end
+
+          @connections[:master] ||= connect_to_master
+          if @connections[:master]
+            circuit.success!
+            @connections[:master]
+          else
+            circuit.fail!
+            raise MasterUnavailable
+          end
+        end
+
+        def master_available?
+          !@connections[:master].nil?
+        end
+
+        # Returns a random slave connection
+        # Note: the method is not referentially transparent, hence the bang
+        def slave_connection!
+          @connections[:slaves].sample
+        end
+
+        def connections
+          @connections.values.flatten.compact
+        end
+
+        def current_connection
+          connection_stack.first
+        end
+
+        def current_clock
+          @master_slave_clock
+        end
+
+        def master_clock
+          raise NotImplementedError
+        end
+
+        def slave_clock(conn)
+          raise NotImplementedError
+        end
+
+      protected
+
+        def prefer_master_connection
+          master_available? ? master_connection : slave_connection!
+        end
+
+        def master_connection?(connection)
+          @connections[:master] == connection
+        end
+
+        def reset_master_connection
+          @connections[:master] = nil
+        end
+
+        def current_clock=(clock)
+          @master_slave_clock = clock
+        end
+
+        def slave_consistent?(conn, clock)
+          if (last_seen_clock = get_last_seen_slave_clock(conn))
+            last_seen_clock >= clock
+          elsif (slave_clk = slave_clock(conn))
+            set_last_seen_slave_clock(conn, slave_clk)
+            slave_clk >= clock
+          else
+            false
+          end
+        end
+
+        def on_write
+          with(master_connection) do |conn|
+            yield(conn).tap do
+              unless open_transaction?
+                if mc = master_clock
+                  self.current_clock = mc unless current_clock.try(:>=, mc)
+                end
+                # keep using master after write
+                connection_stack.replace([ conn ])
+              end
+            end
+          end
+        end
+
+        def with(conn)
+          self.current_connection = conn
+          yield(conn).tap { connection_stack.shift if connection_stack.size > 1 }
+        end
+
+      private
+
+        def connect(cfg, name)
+          adapter_method = "#{cfg.fetch(:adapter)}_connection".to_sym
+          ActiveRecord::Base.send(adapter_method, { :name => name }.merge(cfg))
+        end
+
+        def open_transaction?
+          master_available? ? (master_connection.open_transactions > 0) : false
+        end
+
+        def connection_stack
+          @master_slave_connection ||= []
+        end
+
+        def current_connection=(conn)
+          connection_stack.unshift(conn)
+        end
+
+        def on_commit_callbacks
+          Thread.current[:on_commit_callbacks] ||= []
+        end
+
+        def on_rollback_callbacks
+          Thread.current[:on_rollback_callbacks] ||= []
+        end
+
+        def get_last_seen_slave_clock(conn)
+          conn.instance_variable_get(:@last_seen_slave_clock)
+        end
+
+        def set_last_seen_slave_clock(conn, clock)
+          last_seen = get_last_seen_slave_clock(conn)
+          if last_seen.nil? || last_seen < clock
+            conn.instance_variable_set(:@last_seen_slave_clock, clock)
+          end
+        end
+
+        def connect_to_master
+          connect(@config.fetch(:master), :master)
+        rescue => exception
+          connection_error?(exception) ? nil : raise
+        end
+
+        def connection_error?(exception)
+          raise NotImplementedError
+        end
+
+        def circuit
+          @circuit
+        end
+      end
+    end
+  end
+end