db-charmer 1.8.4 → 1.9.0

data/lib/db_charmer.rb

@@ -2,6 +2,7 @@
 require 'active_record/version' unless defined?(::ActiveRecord::VERSION::MAJOR)
 require 'active_support/core_ext'
 
+#---------------------------------------------------------------------------------------------------
 module DbCharmer
   # Configure autoload
   autoload :Sharding, 'db_charmer/sharding'
@@ -68,64 +69,33 @@ module DbCharmer
     ::ActionController::Base.extend(DbCharmer::ActionController::ForceSlaveReads::ClassMethods)
     ::ActionController::Base.send(:include, DbCharmer::ActionController::ForceSlaveReads::InstanceMethods)
   end
-
-  #-------------------------------------------------------------------------------------------------
-  def self.with_remapped_databases(mappings, &proc)
-    old_mappings = ::ActiveRecord::Base.db_charmer_database_remappings
-    begin
-      ::ActiveRecord::Base.db_charmer_database_remappings = mappings
-      if mappings[:master] || mappings['master']
-        with_all_hijacked(&proc)
-      else
-        proc.call
-      end
-    ensure
-      ::ActiveRecord::Base.db_charmer_database_remappings = old_mappings
-    end
-  end
-
-  def self.hijack_new_classes?
-    @@hijack_new_classes
-  end
-
-private
-
-  @@hijack_new_classes = false
-  def self.with_all_hijacked
-    old_hijack_new_classes = @@hijack_new_classes
-    begin
-      @@hijack_new_classes = true
-      subclasses_method = DbCharmer.rails3? ? :descendants : :subclasses
-      ::ActiveRecord::Base.send(subclasses_method).each do |subclass|
-        subclass.hijack_connection!
-      end
-      yield
-    ensure
-      @@hijack_new_classes = old_hijack_new_classes
-    end
-  end
 end
 
 #---------------------------------------------------------------------------------------------------
 # Print warning about the broken Rails 2.3.4
 puts "WARNING: Rails 3.2.4 is not officially supported by DbCharmer. Please upgrade." if DbCharmer.rails324?
 
+#---------------------------------------------------------------------------------------------------
 # Add useful methods to global object
 require 'db_charmer/core_extensions'
 
 require 'db_charmer/connection_factory'
 require 'db_charmer/connection_proxy'
 require 'db_charmer/force_slave_reads'
+require 'db_charmer/with_remapped_databases'
 
+#---------------------------------------------------------------------------------------------------
 # Add our custom class-level attributes to AR models
 require 'db_charmer/active_record/class_attributes'
 require 'active_record'
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::ClassAttributes)
 
+#---------------------------------------------------------------------------------------------------
 # Enable connections switching in AR
 require 'db_charmer/active_record/connection_switching'
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::ConnectionSwitching)
 
+#---------------------------------------------------------------------------------------------------
 # Enable AR logging extensions
 if DbCharmer.rails3?
   require 'db_charmer/rails3/abstract_adapter/connection_name'
@@ -137,12 +107,14 @@ else
   ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, DbCharmer::AbstractAdapter::LogFormatting)
 end
 
+#---------------------------------------------------------------------------------------------------
 # Enable connection proxy in AR
 require 'db_charmer/active_record/multi_db_proxy'
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::MultiDbProxy::ClassMethods)
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::MultiDbProxy::MasterSlaveClassMethods)
 ActiveRecord::Base.send(:include, DbCharmer::ActiveRecord::MultiDbProxy::InstanceMethods)
 
+#---------------------------------------------------------------------------------------------------
 # Enable connection proxy for relations
 if DbCharmer.rails3?
   require 'db_charmer/rails3/active_record/relation_method'
@@ -151,15 +123,19 @@ if DbCharmer.rails3?
   ActiveRecord::Relation.send(:include, DbCharmer::ActiveRecord::Relation::ConnectionRouting)
 end
 
+#---------------------------------------------------------------------------------------------------
 # Enable connection proxy for scopes (rails 2.x only)
 if DbCharmer.rails2?
   require 'db_charmer/rails2/active_record/named_scope/scope_proxy'
   ActiveRecord::NamedScope::Scope.send(:include, DbCharmer::ActiveRecord::NamedScope::ScopeProxy)
 end
 
+#---------------------------------------------------------------------------------------------------
 # Enable connection proxy for associations
-# WARNING: Inject methods to association class right here (they proxy include calls somewhere else, so include does not work)
-association_proxy_class = DbCharmer.rails31? ? ActiveRecord::Associations::CollectionProxy : ActiveRecord::Associations::AssociationProxy
+# WARNING: Inject methods to association class right here because they proxy +include+ calls
+#          somewhere else, which means we could not use +include+ method here
+association_proxy_class = DbCharmer.rails31? ? ActiveRecord::Associations::CollectionProxy :
+                                               ActiveRecord::Associations::AssociationProxy
 association_proxy_class.class_eval do
   def proxy?
     true
@@ -194,6 +170,7 @@ association_proxy_class.class_eval do
   end
 end
 
+#---------------------------------------------------------------------------------------------------
 # Enable multi-db migrations
 require 'db_charmer/active_record/migration/multi_db_migrations'
 ActiveRecord::Migration.send(:include, DbCharmer::ActiveRecord::Migration::MultiDbMigrations)
@@ -203,6 +180,7 @@ if DbCharmer.rails31?
   ActiveRecord::Migration::CommandRecorder.send(:include, DbCharmer::ActiveRecord::Migration::CommandRecorder)
 end
 
+#---------------------------------------------------------------------------------------------------
 # Enable the magic
 if DbCharmer.rails3?
   require 'db_charmer/rails3/active_record/master_slave_routing'
@@ -214,6 +192,7 @@ require 'db_charmer/active_record/sharding'
 require 'db_charmer/active_record/db_magic'
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::DbMagic)
 
+#---------------------------------------------------------------------------------------------------
 # Setup association preload magic
 if DbCharmer.rails31?
   require 'db_charmer/rails31/active_record/preloader/association'
@@ -227,17 +206,3 @@ else
   # Open up really useful API method
   ActiveRecord::AssociationPreload::ClassMethods.send(:public, :preload_associations)
 end
-
-#---------------------------------------------------------------------------------------------------
-# Hijack connection on all new AR classes when we're in a block with main AR connection remapped
-class ActiveRecord::Base
-  class << self
-    def inherited_with_hijacking(subclass)
-      out = inherited_without_hijacking(subclass)
-      hijack_connection! if DbCharmer.hijack_new_classes?
-      out
-    end
-
-    alias_method_chain :inherited, :hijacking
-  end
-end

data/lib/db_charmer/active_record/class_attributes.rb

@@ -10,17 +10,7 @@ module DbCharmer
         @@db_charmer_opts[self.name] || {}
       end
 
-      #-----------------------------------------------------------------------------
-      @@db_charmer_connection_proxies = {}
-      def db_charmer_connection_proxy=(proxy)
-        @@db_charmer_connection_proxies[self.name] = proxy
-      end
-
-      def db_charmer_connection_proxy
-        @@db_charmer_connection_proxies[self.name]
-      end
-
-      #-----------------------------------------------------------------------------
+      #---------------------------------------------------------------------------------------------
       @@db_charmer_default_connections = {}
       def db_charmer_default_connection=(conn)
         @@db_charmer_default_connections[self.name] = conn
@@ -30,7 +20,7 @@ module DbCharmer
         @@db_charmer_default_connections[self.name]
       end
 
-      #-----------------------------------------------------------------------------
+      #---------------------------------------------------------------------------------------------
       @@db_charmer_slaves = {}
       def db_charmer_slaves=(slaves)
         @@db_charmer_slaves[self.name] = slaves
@@ -40,19 +30,36 @@ module DbCharmer
         @@db_charmer_slaves[self.name] || []
       end
 
+      # Returns a random connection from the list of slaves configured for this AR class
       def db_charmer_random_slave
         return nil unless db_charmer_slaves.any?
         db_charmer_slaves[rand(db_charmer_slaves.size)]
       end
 
-      #-----------------------------------------------------------------------------
-      @@db_charmer_force_slave_reads = {}
+      #---------------------------------------------------------------------------------------------
+      def db_charmer_connection_proxies
+        Thread.current[:db_charmer_connection_proxies] ||= {}
+      end
+
+      def db_charmer_connection_proxy=(proxy)
+        db_charmer_connection_proxies[self.name] = proxy
+      end
+
+      def db_charmer_connection_proxy
+        db_charmer_connection_proxies[self.name]
+      end
+
+      #---------------------------------------------------------------------------------------------
+      def db_charmer_force_slave_reads_flags
+        Thread.current[:db_charmer_force_slave_reads] ||= {}
+      end
+
       def db_charmer_force_slave_reads=(force)
-        @@db_charmer_force_slave_reads[self.name] = force
+        db_charmer_force_slave_reads_flags[self.name] = force
       end
 
       def db_charmer_force_slave_reads
-        @@db_charmer_force_slave_reads[self.name]
+        db_charmer_force_slave_reads_flags[self.name]
       end
 
       # Slave reads are used in two cases:
@@ -62,39 +69,47 @@ module DbCharmer
         db_charmer_force_slave_reads || DbCharmer.force_slave_reads?
       end
 
-      #-----------------------------------------------------------------------------
-      @@db_charmer_connection_levels = Hash.new(0)
+      #---------------------------------------------------------------------------------------------
+      def db_charmer_connection_levels
+        Thread.current[:db_charmer_connection_levels] ||= Hash.new(0)
+      end
+
       def db_charmer_connection_level=(level)
-        @@db_charmer_connection_levels[self.name] = level
+        db_charmer_connection_levels[self.name] = level
       end
 
       def db_charmer_connection_level
-        @@db_charmer_connection_levels[self.name] || 0
+        db_charmer_connection_levels[self.name] || 0
       end
 
       def db_charmer_top_level_connection?
         db_charmer_connection_level.zero?
       end
 
-      #-----------------------------------------------------------------------------
-      @@db_charmer_database_remappings = Hash.new
+      #---------------------------------------------------------------------------------------------
       def db_charmer_remapped_connection
-        return nil if (db_charmer_connection_level || 0) > 0
+        return nil unless db_charmer_top_level_connection?
         name = :master
-        proxy = db_charmer_connection_proxy
+        proxy = db_charmer_model_connection_proxy
         name = proxy.db_charmer_connection_name.to_sym if proxy
 
-        remapped = @@db_charmer_database_remappings[name]
+        remapped = db_charmer_database_remappings[name]
         remapped ? DbCharmer::ConnectionFactory.connect(remapped, true) : nil
       end
 
       def db_charmer_database_remappings
-        @@db_charmer_database_remappings
+        Thread.current[:db_charmer_database_remappings] ||= Hash.new
       end
 
       def db_charmer_database_remappings=(mappings)
         raise "Mappings must be nil or respond to []" if mappings && (! mappings.respond_to?(:[]))
-        @@db_charmer_database_remappings = mappings || { }
+        Thread.current[:db_charmer_database_remappings] = mappings || {}
+      end
+
+      #---------------------------------------------------------------------------------------------
+      # Returns model-specific connection proxy, ignoring any global connection remappings
+      def db_charmer_model_connection_proxy
+        db_charmer_connection_proxy || db_charmer_default_connection
       end
     end
   end

data/lib/db_charmer/active_record/connection_switching.rb

@@ -31,13 +31,13 @@ module DbCharmer
         class << self
           # Make sure we check our accessors before going to the default connection retrieval method
           def connection_with_magic
-            db_charmer_remapped_connection || db_charmer_connection_proxy || connection_without_magic
+            db_charmer_remapped_connection || db_charmer_model_connection_proxy || connection_without_magic
           end
           alias_method_chain :connection, :magic
 
           def connection_pool_with_magic
-            abstract_connection_class = connection.abstract_connection_class rescue nil # respond_to? doesn't work on connection_proxy...
-            if abstract_connection_class
+            if connection.respond_to?(:abstract_connection_class)
+              abstract_connection_class = connection.abstract_connection_class
               connection_handler.retrieve_connection_pool(abstract_connection_class) || connection_pool_without_magic
             else
               connection_pool_without_magic
@@ -49,26 +49,31 @@ module DbCharmer
 
       #-----------------------------------------------------------------------------------------------------------------
       def coerce_to_connection_proxy(conn, should_exist = true)
+        # Return nil if given no connection specification
         return nil if conn.nil?
 
+        # For sharded proxies just use them as-is
+        return conn if conn.respond_to?(:set_real_connection)
+
+        # For connection proxies and objects that could be coerced into a proxy just call the coercion method
+        return conn.db_charmer_connection_proxy if conn.respond_to?(:db_charmer_connection_proxy)
+
+        # For plain AR connection adapters, just use them as-is
+        return conn if conn.kind_of?(::ActiveRecord::ConnectionAdapters::AbstractAdapter)
+
+        # For connection names, use connection factory to create new connections
         if conn.kind_of?(Symbol) || conn.kind_of?(String)
           return DbCharmer::ConnectionFactory.connect(conn, should_exist)
         end
 
+        # For connection configs (hashes), create connections
         if conn.kind_of?(Hash)
           conn = conn.symbolize_keys
           raise ArgumentError, "Missing required :connection_name parameter" unless conn[:connection_name]
           return DbCharmer::ConnectionFactory.connect_to_db(conn[:connection_name], conn)
         end
 
-        if conn.respond_to?(:db_charmer_connection_proxy)
-          return conn.db_charmer_connection_proxy
-        end
-
-        if conn.kind_of?(::ActiveRecord::ConnectionAdapters::AbstractAdapter) || conn.kind_of?(DbCharmer::Sharding::StubConnection)
-          return conn
-        end
-
+        # Fails for unsupported connection types
         raise "Unsupported connection type: #{conn.class}"
       end
 
@@ -76,14 +81,12 @@ module DbCharmer
       def switch_connection_to(conn, should_exist = true)
         new_conn = coerce_to_connection_proxy(conn, should_exist)
 
-        if db_charmer_connection_proxy.is_a?(DbCharmer::Sharding::StubConnection)
+        if db_charmer_connection_proxy.respond_to?(:set_real_connection)
           db_charmer_connection_proxy.set_real_connection(new_conn)
         end
 
         self.db_charmer_connection_proxy = new_conn
         self.hijack_connection!
-
-        # self.reset_column_information
       end
 
     end

data/lib/db_charmer/active_record/db_magic.rb

@@ -64,8 +64,9 @@ module DbCharmer
       end
 
       def setup_connection_magic(conn, should_exist = true)
-        switch_connection_to(conn, should_exist)
-        self.db_charmer_default_connection = conn
+        conn_proxy = coerce_to_connection_proxy(conn, should_exist)
+        self.db_charmer_default_connection = conn_proxy
+        switch_connection_to(conn_proxy, should_exist)
       end
 
       def setup_slaves_magic(slaves, force_slave_reads, should_exist = true)

data/lib/db_charmer/connection_factory.rb

@@ -6,22 +6,28 @@
 #
 module DbCharmer
   module ConnectionFactory
-    @@connection_classes = {}
+    def self.connection_classes
+      Thread.current[:db_charmer_generated_connection_classes] ||= {}
+    end
+
+    def self.connection_classes=(val)
+      Thread.current[:db_charmer_generated_connection_classes] = val
+    end
 
     def self.reset!
-      @@connection_classes = {}
+      self.connection_classes = {}
     end
 
     # Establishes connection or return an existing one from cache
     def self.connect(connection_name, should_exist = true)
       connection_name = connection_name.to_s
-      @@connection_classes[connection_name] ||= establish_connection(connection_name, should_exist)
+      connection_classes[connection_name] ||= establish_connection(connection_name, should_exist)
     end
 
     # Establishes connection or return an existing one from cache (not using AR database configs)
     def self.connect_to_db(connection_name, config)
       connection_name = connection_name.to_s
-      @@connection_classes[connection_name] ||= establish_connection_to_db(connection_name, config)
+      connection_classes[connection_name] ||= establish_connection_to_db(connection_name, config)
     end
 
     # Establish connection with a specified name
@@ -70,7 +76,9 @@ module DbCharmer
 
     # Generates unique names for our abstract AR classes
     def self.abstract_connection_class_name(connection_name)
-      "::AutoGeneratedAbstractConnectionClass#{connection_name.to_s.gsub(/\W+/, '_').camelize}"
+      conn_name_klass = connection_name.to_s.gsub(/\W+/, '_').camelize
+      thread = Thread.current.object_id.abs # need to make sure it is non-negative
+      "::AutoGeneratedAbstractConnectionClass#{conn_name_klass}ForThread#{thread}"
     end
   end
 end

data/lib/db_charmer/connection_proxy.rb

@@ -20,8 +20,37 @@ module DbCharmer
       self
     end
 
+    def db_charmer_retrieve_connection
+      @abstract_connection_class.retrieve_connection
+    end
+
+    def nil?
+      false
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    RESPOND_TO_METHODS = [
+      :abstract_connection_class,
+      :db_charmer_connection_name,
+      :db_charmer_connection_proxy,
+      :db_charmer_retrieve_connection,
+      :nil?
+    ].freeze
+
+    # Short-circuit some of the methods for which we know there is a separate check in coercion code
+    DOESNT_RESPOND_TO_METHODS = [
+      :set_real_connection
+    ].freeze
+
+    def respond_to?(method_name, include_all = false)
+      return true if RESPOND_TO_METHODS.include?(method_name)
+      return false if DOESNT_RESPOND_TO_METHODS.include?(method_name)
+      db_charmer_retrieve_connection.respond_to?(method_name, include_all)
+    end
+
+    #-----------------------------------------------------------------------------------------------
     def method_missing(meth, *args, &block)
-      @abstract_connection_class.retrieve_connection.send(meth, *args, &block)
+      db_charmer_retrieve_connection.send(meth, *args, &block)
     end
   end
 end

data/lib/db_charmer/force_slave_reads.rb

@@ -1,12 +1,25 @@
 module DbCharmer
-  @@current_controller = nil
-  mattr_accessor :current_controller
+  def self.current_controller
+    Thread.current[:db_charmer_current_controller]
+  end
+
+  def self.current_controller=(val)
+    Thread.current[:db_charmer_current_controller] = val
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  def self.forced_slave_reads_setting
+    Thread.current[:db_charmer_forced_slave_reads]
+  end
 
-  @@forced_slave_reads = false
+  def self.forced_slave_reads_setting=(val)
+    Thread.current[:db_charmer_forced_slave_reads] = val
+  end
 
+  #-------------------------------------------------------------------------------------------------
   def self.force_slave_reads?
     # If global force slave reads is requested, do it
-    return @@forced_slave_reads if @@forced_slave_reads
+    return true if Thread.current[:db_charmer_forced_slave_reads]
 
     # If not, try to use current controller to decide on this
     return false unless current_controller.respond_to?(:force_slave_reads?)
@@ -16,6 +29,7 @@ module DbCharmer
     return slave_reads
   end
 
+  #-------------------------------------------------------------------------------------------------
   def self.with_controller(controller)
     raise ArgumentError, "No block given" unless block_given?
     logger.debug("Setting current controller for db_charmer: #{controller.class.name}")
@@ -26,11 +40,16 @@ module DbCharmer
     self.current_controller = nil
   end
 
+  #-------------------------------------------------------------------------------------------------
+  # Force all reads in a block of code to go to a slave
   def self.force_slave_reads
     raise ArgumentError, "No block given" unless block_given?
-    @@forced_slave_reads = true
-    yield
-  ensure
-    @@forced_slave_reads = false
+    old_forced_slave_reads = self.forced_slave_reads_setting
+    begin
+      self.forced_slave_reads_setting = true
+      yield
+    ensure
+      self.forced_slave_reads_setting = old_forced_slave_reads
+    end
   end
 end