activerecord-turntable 2.5.0 → 3.0.0.alpha1

data/lib/active_record/turntable/algorithm/range_algorithm.rb

@@ -7,31 +7,31 @@ module ActiveRecord::Turntable::Algorithm
 
     def calculate(key)
       idx = calculate_idx(key)
-      @config["shards"][idx]["connection"]
+      @config[:shards][idx][:connection]
     rescue
       raise ActiveRecord::Turntable::CannotSpecifyShardError, "cannot specify shard for key:#{key}"
     end
 
     def calculate_idx(key)
-      @config["shards"].find_index {|h| h["less_than"] > key }
+      @config[:shards].find_index { |h| h[:less_than] > key }
     end
 
     # { connection_name => weight, ... }
     def calculate_used_shards_with_weight(sequence_value)
       idx = calculate_idx(sequence_value)
       last_connection = calculate(sequence_value)
-      shards = @config["shards"][0..idx]
-      weighted_hash = Hash.new {|h,k| h[k]=0}
+      shards = @config[:shards][0..idx]
+      weighted_hash = Hash.new { |h, k| h[k] = 0 }
       prev_max = 0
-      shards.each_with_index do |h,idx|
-        weighted_hash[h["connection"]] += if idx < shards.size - 1
-                                            h["less_than"] - prev_max - 1
+      shards.each_with_index do |h, idx|
+        weighted_hash[h[:connection]] += if idx < shards.size - 1
+                                            h[:less_than] - prev_max - 1
                                           else
                                             sequence_value - prev_max
                                           end
-        prev_max = h["less_than"] - 1
+        prev_max = h[:less_than] - 1
       end
-      return weighted_hash
+      weighted_hash
     end
   end
 end

data/lib/active_record/turntable/algorithm/range_bsearch_algorithm.rb

@@ -1,22 +1,22 @@
 # -*- coding: utf-8 -*-
-require 'bsearch'
+require "bsearch"
 module ActiveRecord::Turntable::Algorithm
   class RangeBsearchAlgorithm < Base
     def initialize(config)
       @config = config
-      @config["shards"].sort_by! {|a| a["less_than"]}
+      @config[:shards].sort_by! { |a| a[:less_than] }
     end
 
     def calculate(key)
       idx = calculate_idx(key)
-      @config["shards"][idx]["connection"]
+      @config[:shards][idx][:connection]
     rescue
       raise ActiveRecord::Turntable::CannotSpecifyShardError, "cannot specify shard for key:#{key}"
     end
 
     def calculate_idx(key)
-      @config["shards"].bsearch_upper_boundary { |h|
-        h["less_than"] <=> key
+      @config[:shards].bsearch_upper_boundary { |h|
+        h[:less_than] <=> key
       }
     end
 
@@ -24,18 +24,18 @@ module ActiveRecord::Turntable::Algorithm
     def calculate_used_shards_with_weight(sequence_value)
       idx = calculate_idx(sequence_value)
       last_connection = calculate(sequence_value)
-      shards = @config["shards"][0..idx]
-      weighted_hash = Hash.new {|h,k| h[k]=0}
+      shards = @config[:shards][0..idx]
+      weighted_hash = Hash.new { |h, k| h[k] = 0 }
       prev_max = 0
-      shards.each_with_index do |h,idx|
-        weighted_hash[h["connection"]] += if idx < shards.size - 1
-                                            h["less_than"] - prev_max - 1
+      shards.each_with_index do |h, idx|
+        weighted_hash[h[:connection]] += if idx < shards.size - 1
+                                            h[:less_than] - prev_max - 1
                                           else
                                             sequence_value - prev_max
                                           end
-        prev_max = h["less_than"] - 1
+        prev_max = h[:less_than] - 1
       end
-      return weighted_hash
+      weighted_hash
     end
   end
 end

data/lib/active_record/turntable/base.rb

@@ -1,4 +1,4 @@
-require 'active_support/lazy_load_hooks'
+require "active_support/lazy_load_hooks"
 
 module ActiveRecord::Turntable
   module Base
@@ -6,14 +6,14 @@ module ActiveRecord::Turntable
 
     included do
       class_attribute :turntable_connections, :turntable_clusters,
-                        :turntable_enabled, :turntable_sequencer_enabled
+                      :turntable_enabled, :turntable_sequencer_enabled
 
       self.turntable_connections = {}
       self.turntable_clusters = {}.with_indifferent_access
       self.turntable_enabled = false
       self.turntable_sequencer_enabled = false
       class << self
-        delegate :shards_transaction, :with_all, :to => :connection
+        delegate :shards_transaction, :with_all, to: :connection
       end
 
       ActiveSupport.on_load(:turntable_config_loaded) do
@@ -22,37 +22,52 @@ module ActiveRecord::Turntable
       include ClusterHelperMethods
     end
 
+    module ConnectionExtension
+      module ClassMethods
+        def connection_specification_name
+          return super unless turntable_enabled?
+          self.connection_specification_name = "turntable_pool_proxy::#{name}"
+        end
+      end
+
+      def self.prepended(base)
+        class << base
+          prepend ClassMethods
+        end
+      end
+    end
+
     module ClassMethods
       # @param [Symbol] cluster_name cluster name for this class
       # @param [Symbol] shard_key_name shard key attribute name
       # @param [Hash] options
       def turntable(cluster_name, shard_key_name, options = {})
         class_attribute :turntable_shard_key,
-                          :turntable_cluster, :turntable_cluster_name
+                        :turntable_cluster, :turntable_cluster_name
 
         self.turntable_enabled = true
         self.turntable_cluster_name = cluster_name
         self.turntable_shard_key = shard_key_name
         self.turntable_cluster =
           self.turntable_clusters[cluster_name] ||= Cluster.new(
-                                                      turntable_config[:clusters][cluster_name],
-                                                      options
-                                                    )
+            turntable_config[:clusters][cluster_name],
+            options
+        )
+        prepend ConnectionExtension
         turntable_replace_connection_pool
       end
 
-
       def turntable_replace_connection_pool
         ch = connection_handler
         cp = ConnectionProxy.new(self, turntable_cluster)
         pp = PoolProxy.new(cp)
-        ch.class_to_pool.clear if defined?(ch.class_to_pool)
-        ch.send(:class_to_pool)[name] = ch.send(:owner_to_pool)[name] = pp
+
+        ch.send(:owner_to_pool)[connection_specification_name] = pp
       end
 
       def initialize_clusters!
         turntable_config[:clusters].each do |name, spec|
-          self.turntable_clusters[name] ||= Cluster.new(spec, {})
+          self.turntable_clusters[name] ||= Cluster.new(spec)
         end
       end
 
@@ -67,9 +82,7 @@ module ActiveRecord::Turntable
       end
 
       def clear_all_connections!
-        turntable_connections.values.each do |pool|
-          pool.disconnect!
-        end
+        turntable_connections.values.each(&:disconnect!)
       end
 
       def sequencer(sequence_name, *args)

data/lib/active_record/turntable/cluster.rb

@@ -1,8 +1,7 @@
-require 'active_support/core_ext/hash/indifferent_access'
+require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord::Turntable
   class Cluster
-
     DEFAULT_CONFIG = {
       "shards" => [],
       "algorithm" => "range",
@@ -15,19 +14,19 @@ module ActiveRecord::Turntable
 
       # setup sequencer
       seq = (@options[:seq] || @config[:seq])
-      if seq 
-        if seq.values.size > 0 && seq.values.first["seq_type"] == "mysql"
+      if seq
+        if seq.values.size > 0 && seq.values.first[:seq_type] == "mysql"
           @seq_shard = SeqShard.new(seq.values.first)
         end
       end
 
       # setup shards
       @config[:shards].each do |spec|
-        @shards[spec["connection"]] ||= Shard.new(spec)
+        @shards[spec[:connection]] ||= Shard.new(spec)
       end
 
       # setup algorithm
-      alg_name = "ActiveRecord::Turntable::Algorithm::#{@config["algorithm"].camelize}Algorithm"
+      alg_name = "ActiveRecord::Turntable::Algorithm::#{@config[:algorithm].camelize}Algorithm"
       @algorithm = alg_name.constantize.new(@config)
     end
 
@@ -35,15 +34,13 @@ module ActiveRecord::Turntable
       @seq_shard
     end
 
-    def shards
-      @shards
-    end
+    attr_reader :shards
 
     def shard_for(key)
       @shards[@algorithm.calculate(key)]
     rescue
       raise ActiveRecord::Turntable::CannotSpecifyShardError,
-        "cannot select_shard for key:#{key}"
+            "cannot select_shard for key:#{key}"
     end
 
     def select_shard(key)
@@ -65,7 +62,7 @@ module ActiveRecord::Turntable
         end
       else
         shard.connection.transaction(options) do
-          block.call
+          yield
         end
       end
     end
@@ -82,12 +79,12 @@ module ActiveRecord::Turntable
         shards[shard_or_object]
       else
         raise ActiveRecord::Turntable::TurntableError,
-                "transaction cannot call to object: #{shard_or_object}"
+              "transaction cannot call to object: #{shard_or_object}"
       end
     end
 
     def weighted_shards(key = nil)
-      Hash[@algorithm.calculate_used_shards_with_weight(key).map do |k,v|
+      Hash[@algorithm.calculate_used_shards_with_weight(key).map do |k, v|
         [@shards[k], v]
       end]
     end

data/lib/active_record/turntable/cluster_helper_methods.rb

@@ -4,14 +4,14 @@ module ActiveRecord::Turntable
 
     included do
       ActiveSupport.on_load(:turntable_config_loaded) do
-        turntable_clusters.each do |name, cluster|
+        turntable_clusters.each do |name, _cluster|
           turntable_define_cluster_methods(name)
         end
       end
     end
 
     module ClassMethods
-      def force_transaction_all_shards!(options={}, &block)
+      def force_transaction_all_shards!(options = {}, &block)
         force_connect_all_shards!
         shards = turntable_connections.values
         shards += [ActiveRecord::Base.connection_pool]
@@ -31,9 +31,9 @@ module ActiveRecord::Turntable
 
       def force_connect_all_shards!
         conf = configurations[Rails.env]
-        shards = {}
-        shards = shards.merge(conf["shards"]) if conf["shards"]
-        shards = shards.merge(conf["seq"]) if conf["seq"]
+        shards = HashWithIndifferentAccess.new
+        shards = shards.merge(conf[:shards]) if conf[:shards]
+        shards = shards.merge(conf[:seq]) if conf[:seq]
         shards.each do |name, config|
           turntable_connections[name] ||=
             ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
@@ -44,7 +44,7 @@ module ActiveRecord::Turntable
         shards_weight = self.turntable_cluster.weighted_shards(self.current_sequence)
         sum = shards_weight.values.inject(&:+)
         idx = rand(sum)
-        shard, weight = shards_weight.find {|k,v|
+        shard, weight = shards_weight.find {|_k, v|
           (idx -= v) < 0
         }
         self.connection.with_recursive_shards(shard.name, *klasses, &block)

data/lib/active_record/turntable/config.rb

@@ -1,5 +1,5 @@
-require 'active_support/lazy_load_hooks'
-require 'active_support/core_ext/hash/indifferent_access'
+require "active_support/lazy_load_hooks"
+require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord::Turntable
   class Config
@@ -14,7 +14,7 @@ module ActiveRecord::Turntable
       @config[key]
     end
 
-    def self.load!(config_file = ActiveRecord::Base.turntable_config_file, env = (defined?(Rails) ? Rails.env : 'development'))
+    def self.load!(config_file = ActiveRecord::Base.turntable_config_file, env = (defined?(Rails) ? Rails.env : "development"))
       instance.load!(config_file, env)
     end
 

data/lib/active_record/turntable/connection_proxy/mixable.rb

@@ -10,7 +10,7 @@ module ActiveRecord::Turntable
       def mixable?(method, *args)
         (method.to_s =~ METHODS_REGEXP &&
          args.first !~ EXCLUDE_QUERY_REGEXP) ||
-          (method.to_s == 'execute' && args.first =~ QUERY_REGEXP)
+          (method.to_s == "execute" && args.first =~ QUERY_REGEXP)
       end
     end
   end

data/lib/active_record/turntable/connection_proxy.rb

@@ -1,10 +1,10 @@
-require 'active_record/turntable/connection_proxy/mixable'
+require "active_record/turntable/connection_proxy/mixable"
 module ActiveRecord::Turntable
   class ConnectionProxy
     include Mixable
 
     # for expiring query cache
-    CLEAR_CACHE_METHODS = [:update, :insert, :delete, :exec_insert, :exec_update, :exec_delete, :insert_many]
+    CLEAR_CACHE_METHODS = [:update, :insert, :delete, :exec_insert, :exec_update, :exec_delete, :insert_many].freeze
 
     attr_reader :klass
     attr_writer :spec
@@ -22,9 +22,9 @@ module ActiveRecord::Turntable
     delegate :shards_transaction, to: :cluster
 
     delegate :create_table, :rename_table, :drop_table, :add_column, :remove_colomn,
-      :change_column, :change_column_default, :rename_column, :add_index,
-      :remove_index, :initialize_schema_information,
-      :dump_schema_information, :execute_ignore_duplicate, to: :master_connection
+             :change_column, :change_column_default, :rename_column, :add_index,
+             :remove_index, :initialize_schema_information,
+             :dump_schema_information, :execute_ignore_duplicate, to: :master_connection
 
     def transaction(options = {}, &block)
       connection.transaction(options, &block)
@@ -38,7 +38,7 @@ module ActiveRecord::Turntable
     end
 
     def enable_query_cache!
-      klass.turntable_connections.each do |k,v|
+      klass.turntable_connections.each do |_k, v|
         v.connection.enable_query_cache!
       end
     end
@@ -48,7 +48,7 @@ module ActiveRecord::Turntable
     end
 
     def clear_query_cache
-      klass.turntable_connections.each do |k,v|
+      klass.turntable_connections.each do |_k, v|
         v.connection.clear_query_cache
       end
     end
@@ -59,9 +59,11 @@ module ActiveRecord::Turntable
         connection.send(method, *args, &block)
       elsif mixable?(method, *args)
         fader = @mixer.build_fader(method, *args, &block)
-        logger.debug { "[ActiveRecord::Turntable] Sending method: #{method}, " +
-          "sql: #{args.first}, " +
-          "shards: #{fader.shards_query_hash.keys.map(&:name)}" }
+        logger.debug {
+          "[ActiveRecord::Turntable] Sending method: #{method}, " \
+          "sql: #{args.first}, " \
+          "shards: #{fader.shards_query_hash.keys.map(&:name)}"
+        }
         fader.execute
       else
         connection.send(method, *args, &block)
@@ -76,9 +78,7 @@ module ActiveRecord::Turntable
       master.connection.to_sql(arel, binds)
     end
 
-    def cluster
-      @cluster
-    end
+    attr_reader :cluster
 
     def shards
       @cluster.shards
@@ -113,7 +113,7 @@ module ActiveRecord::Turntable
     end
 
     def current_shard=(shard)
-      logger.debug { "Changing #{klass}'s shard to #{shard.name}"}
+      logger.debug { "Changing #{klass}'s shard to #{shard.name}" }
       current_shard_entry[object_id] = shard
     end
 
@@ -136,7 +136,8 @@ module ActiveRecord::Turntable
     def with_shard(shard)
       shard = cluster.to_shard(shard)
 
-      old_shard, old_fixed = current_shard, fixed_shard
+      old_shard = current_shard
+      old_fixed = fixed_shard
       self.current_shard = shard
       self.fixed_shard = shard
       yield
@@ -197,7 +198,7 @@ module ActiveRecord::Turntable
     end
 
     delegate :connected?, :automatic_reconnect, :automatic_reconnect=, :checkout_timeout, :dead_connection_timeout,
-               :spec, :connections, :size, :reaper, :table_exists?, to: :connection_pool
+             :spec, :connections, :size, :reaper, :table_exists?, to: :connection_pool
 
     %w(columns columns_hash column_defaults primary_keys).each do |name|
       define_method(name.to_sym) do
@@ -239,12 +240,12 @@ module ActiveRecord::Turntable
 
     private
 
-    def fixed_shard_entry
-      Thread.current[:turntable_fixed_shard] ||= ThreadSafe::Cache.new
-    end
+      def fixed_shard_entry
+        Thread.current[:turntable_fixed_shard] ||= ThreadSafe::Cache.new
+      end
 
-    def current_shard_entry
-      Thread.current[:turntable_current_shard] ||= ThreadSafe::Cache.new
-    end
+      def current_shard_entry
+        Thread.current[:turntable_current_shard] ||= ThreadSafe::Cache.new
+      end
   end
 end

data/lib/active_record/turntable/helpers/test_helper.rb

@@ -2,15 +2,15 @@ module ActiveRecord::Turntable
   module Helpers
     module TestHelper
       # all shards
-      def FabricateAll(name, overrides={}, &block)
+      def FabricateAll(name, overrides = {}, &block)
         obj = Fabrication::Fabricator.generate(name, {
-                                                 :save => true
-                                               }, overrides, &block)
+          save: true,
+        }, overrides, &block)
 
         default_pool = obj.class.connection_pool
         connection_pools = obj.class.connection_handler.instance_variable_get(:@connection_pools)
 
-        ActiveRecord::Base.turntable_connections.each do |conn_name, conn|
+        ActiveRecord::Base.turntable_connections.each do |_conn_name, conn|
           new_obj = obj.dup
           connection_pools[new_obj.class.name] = conn
           new_obj.id = obj.id

data/lib/active_record/turntable/master_shard.rb

@@ -1,21 +1,27 @@
 module ActiveRecord::Turntable
   class MasterShard < Shard
     def initialize(klass)
-      (klass and klass.connection_pool) or
+      (klass and original_connection_pool(klass)) or
         raise MasterShardNotConnected, "connection_pool is nil"
       @klass = klass
-      @name  = 'master'
+      @name  = "master"
     end
 
     def connection_pool
       if ActiveRecord::Base == @klass
         ActiveRecord::Base.connection_pool
       else
-        # use parentclass connection which is turntable disabled
-        klass = @klass.superclass
+        # use original parent class connection which is turntable disabled
+        original_connection_pool
+      end
+    end
+
+    private
+
+      def original_connection_pool(klass = @klass)
         candidate_connection_pool = nil
-        while !candidate_connection_pool
-          if klass == ActiveRecord::Base or !klass.turntable_enabled?
+        until candidate_connection_pool
+          if klass == ActiveRecord::Base || !klass.turntable_enabled?
             candidate_connection_pool = klass.connection_pool
           else
             klass = klass.superclass
@@ -23,6 +29,5 @@ module ActiveRecord::Turntable
         end
         candidate_connection_pool
       end
-    end
   end
 end

data/lib/active_record/turntable/migration.rb

@@ -3,12 +3,11 @@ module ActiveRecord::Turntable::Migration
 
   included do
     extend ShardDefinition
+    prepend OverrideMethods
     class_attribute :target_shards, :current_shard
-    alias_method_chain :announce, :turntable
-    alias_method_chain :exec_migration, :turntable
-    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, SchemaStatementsExt)
-    ::ActiveRecord::Migration::CommandRecorder.send(:include, CommandRecorder)
-    ::ActiveRecord::Migrator.send(:include, Migrator)
+    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(SchemaStatementsExt)
+    ::ActiveRecord::Migration::CommandRecorder.include(CommandRecorder)
+    ::ActiveRecord::Migrator.prepend(Migrator)
   end
 
   module ShardDefinition
@@ -16,13 +15,13 @@ module ActiveRecord::Turntable::Migration
       config = ActiveRecord::Base.turntable_config
       (self.target_shards ||= []).concat(
         if cluster_names.first == :all
-          config['clusters'].map do |name, cluster_conf|
-            cluster_conf["shards"].map {|shard| shard["connection"]}
+          config[:clusters].map do |_name, cluster_conf|
+            cluster_conf[:shards].map { |shard| shard[:connection] }
           end
         else
           cluster_names.map do |cluster_name|
-            config['clusters'][cluster_name]["shards"].map do |shard|
-              shard["connection"]
+            config[:clusters][cluster_name][:shards].map do |shard|
+              shard[:connection]
             end
           end.flatten
         end
@@ -34,32 +33,34 @@ module ActiveRecord::Turntable::Migration
     end
   end
 
-  def target_shard?(shard_name)
-    target_shards.blank? or target_shards.include?(shard_name)
-  end
+  module OverrideMethods
+    def announce(message)
+      super("#{message} - Shard: #{current_shard}")
+    end
 
-  def announce_with_turntable(message)
-    announce_without_turntable("#{message} - Shard: #{current_shard}")
-  end
+    def exec_migration(*args)
+      super(*args) if target_shard?(current_shard)
+    end
 
-  def exec_migration_with_turntable(*args)
-    exec_migration_without_turntable(*args) if target_shard?(current_shard)
+    def target_shard?(shard_name)
+      target_shards.blank? or target_shards.include?(shard_name)
+    end
   end
 
   module SchemaStatementsExt
-    def create_sequence_for(table_name, options = { })
-      options = options.merge(:id => false)
+    def create_sequence_for(table_name, options = {})
+      options = options.merge(id: false)
 
       # TODO: pkname should be pulled from table definitions
       pkname = "id"
       sequence_table_name = ActiveRecord::Turntable::Sequencer.sequence_name(table_name, "id")
       create_table(sequence_table_name, options) do |t|
-        t.integer :id, :limit => 8
+        t.integer :id, limit: 8
       end
       execute "INSERT INTO #{quote_table_name(sequence_table_name)} (`id`) VALUES (0)"
     end
 
-    def drop_sequence_for(table_name, options = { })
+    def drop_sequence_for(table_name, options = {})
       # TODO: pkname should be pulled from table definitions
       pkname = "id"
       sequence_table_name = ActiveRecord::Turntable::Sequencer.sequence_name(table_name, "id")
@@ -85,56 +86,49 @@ module ActiveRecord::Turntable::Migration
 
     private
 
-    def invert_create_sequence_for(args)
-      [:drop_sequence_for, args]
-    end
+      def invert_create_sequence_for(args)
+        [:drop_sequence_for, args]
+      end
 
-    def invert_rename_sequence_for(args)
-      [:rename_sequence_for, args.reverse]
-    end
+      def invert_rename_sequence_for(args)
+        [:rename_sequence_for, args.reverse]
+      end
   end
 
   module Migrator
     extend ActiveSupport::Concern
 
-    included do
-      klass = self
-      (class << klass; self; end).instance_eval {
-        [:up, :down, :run].each do |method_name|
-          original_method_alias = "_original_#{method_name}"
-          unless klass.respond_to?(original_method_alias)
-            alias_method original_method_alias, method_name
-          end
-          alias_method_chain method_name, :turntable
-        end
-      }
+    def self.prepended(base)
+      class << base
+        prepend ClassMethods
+      end
     end
 
     module ClassMethods
-      def up_with_turntable(migrations_paths, target_version = nil)
-        up_without_turntable(migrations_paths, target_version)
+      def up(migrations_paths, target_version = nil)
+        super
 
         ActiveRecord::Tasks::DatabaseTasks.each_current_turntable_cluster_connected do |name, configuration|
           puts "[turntable] *** Migrating database: #{configuration['database']}(Shard: #{name})"
-          _original_up(migrations_paths, target_version)
+          super(migrations_paths, target_version)
         end
       end
 
-      def down_with_turntable(migrations_paths, target_version = nil, &block)
-        down_without_turntable(migrations_paths, target_version, &block)
+      def down(migrations_paths, target_version = nil, &block)
+        super
 
         ActiveRecord::Tasks::DatabaseTasks.each_current_turntable_cluster_connected do |name, configuration|
           puts "[turntable] *** Migrating database: #{configuration['database']}(Shard: #{name})"
-          _original_down(migrations_paths, target_version, &block)
+          super(migrations_paths, target_version, &block)
         end
       end
 
-      def run_with_turntable(*args)
-        run_without_turntable(*args)
+      def run(*args)
+        super
 
         ActiveRecord::Tasks::DatabaseTasks.each_current_turntable_cluster_connected do |name, configuration|
           puts "[turntable] *** Migrating database: #{configuration['database']}(Shard: #{name})"
-          _original_run(*args)
+          super(*args)
         end
       end
     end