yam-db-charmer 1.7.01

data/lib/db_charmer/active_record/multi_db_proxy.rb

@@ -0,0 +1,77 @@
+module DbCharmer
+  module ActiveRecord
+    module MultiDbProxy
+      # Simple proxy class that switches connections and then proxies all the calls
+      # This class is used to implement chained on_db calls
+      class OnDbProxy < ActiveSupport::BasicObject
+        # We need to do this because in Rails 2.3 BasicObject does not remove object_id method, which is stupid
+        undef_method(:object_id) if instance_methods.member?('object_id')
+
+        def initialize(proxy_target, slave)
+          @proxy_target = proxy_target
+          @slave = slave
+        end
+
+      private
+
+        def method_missing(meth, *args, &block)
+          # Switch connection and proxy the method call
+          @proxy_target.on_db(@slave) do |proxy_target|
+            res = proxy_target.__send__(meth, *args, &block)
+
+            # If result is a scope/association, return a new proxy for it, otherwise return the result itself
+            (res.proxy?) ? OnDbProxy.new(res, @slave) : res
+          end
+        end
+      end
+
+      module ClassMethods
+        def on_db(con, proxy_target = nil)
+          proxy_target ||= self
+
+          # Chain call
+          return OnDbProxy.new(proxy_target, con) unless block_given?
+
+          # Block call
+          begin
+            self.db_charmer_connection_level += 1
+            old_proxy = db_charmer_connection_proxy
+            switch_connection_to(con, DbCharmer.connections_should_exist?)
+            yield(proxy_target)
+          ensure
+            switch_connection_to(old_proxy)
+            self.db_charmer_connection_level -= 1
+          end
+        end
+      end
+
+      module InstanceMethods
+        def on_db(con, proxy_target = nil, &block)
+          proxy_target ||= self
+          self.class.on_db(con, proxy_target, &block)
+        end
+      end
+
+      module MasterSlaveClassMethods
+        def on_slave(con = nil, proxy_target = nil, &block)
+          con ||= db_charmer_random_slave
+          raise ArgumentError, "No slaves found in the class and no slave connection given" unless con
+          on_db(con, proxy_target, &block)
+        end
+
+        def on_master(proxy_target = nil, &block)
+          on_db(db_charmer_default_connection, proxy_target, &block)
+        end
+
+        def first_level_on_slave
+          first_level = db_charmer_top_level_connection? && on_master.connection.open_transactions.zero?
+          if first_level && db_charmer_force_slave_reads? && db_charmer_slaves.any?
+            on_slave { yield }
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_charmer/active_record/sharding.rb

@@ -0,0 +1,40 @@
+module DbCharmer
+  module ActiveRecord
+    module Sharding
+
+      def self.extended(model)
+        model.cattr_accessor(:sharded_connection)
+      end
+
+      def shard_for(key, proxy_target = nil, &block)
+        raise ArgumentError, "No sharded connection configured!" unless sharded_connection
+        conn = sharded_connection.sharder.shard_for_key(key)
+        on_db(conn, proxy_target, &block)
+      end
+
+      # Run on default shard (if supported by the sharding method)
+      def on_default_shard(proxy_target = nil, &block)
+        raise ArgumentError, "No sharded connection configured!" unless sharded_connection
+
+        if sharded_connection.support_default_shard?
+          shard_for(:default, proxy_target, &block)
+        else
+          raise ArgumentError, "This model's sharding method does not support default shard"
+        end
+      end
+
+      # Enumerate shards
+      def on_each_shard(proxy_target = nil, &block)
+        raise ArgumentError, "No sharded connection configured!" unless sharded_connection
+
+        conns = sharded_connection.shard_connections
+        raise ArgumentError, "This model's sharding method does not support shards enumeration" unless conns
+
+        conns.each do |conn|
+          on_db(conn, proxy_target, &block)
+        end
+      end
+
+    end
+  end
+end

data/lib/db_charmer/connection_factory.rb

@@ -0,0 +1,76 @@
+#
+# This class is used to automatically generate small abstract ActiveRecord classes
+# that would then be used as a source of database connections for DbCharmer magic.
+# This way we do not need to re-implement all the connection establishing code
+# that ActiveRecord already has and we make our code less dependant on Rails versions.
+#
+module DbCharmer
+  module ConnectionFactory
+    @@connection_classes = {}
+
+    def self.reset!
+      @@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)
+    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)
+    end
+
+    # Establish connection with a specified name
+    def self.establish_connection(connection_name, should_exist = true)
+      abstract_class = generate_abstract_class(connection_name, should_exist)
+      DbCharmer::ConnectionProxy.new(abstract_class, connection_name)
+    end
+
+    # Establish connection with a specified name (not using AR database configs)
+    def self.establish_connection_to_db(connection_name, config)
+      abstract_class = generate_abstract_class_for_db(connection_name, config)
+      DbCharmer::ConnectionProxy.new(abstract_class, connection_name)
+    end
+
+    # Generate an abstract AR class with specified connection established
+    def self.generate_abstract_class(connection_name, should_exist = true)
+      # Generate class
+      klass = generate_empty_abstract_ar_class(abstract_connection_class_name(connection_name))
+
+      # Establish connection
+      klass.establish_real_connection_if_exists(connection_name.to_sym, !!should_exist)
+
+      # Return the class
+      return klass
+    end
+
+    # Generate an abstract AR class with specified connection established (not using AR database configs)
+    def self.generate_abstract_class_for_db(connection_name, config)
+      # Generate class
+      klass = generate_empty_abstract_ar_class(abstract_connection_class_name(connection_name))
+
+      # Establish connection
+      klass.establish_connection(config)
+
+      # Return the class
+      return klass
+    end
+
+    def self.generate_empty_abstract_ar_class(klass)
+      # Define class
+      module_eval "class #{klass} < ::ActiveRecord::Base; self.abstract_class = true; end"
+
+      # Return class
+      klass.constantize
+    end
+
+    # Generates unique names for our abstract AR classes
+    def self.abstract_connection_class_name(connection_name)
+      "::AutoGeneratedAbstractConnectionClass#{connection_name.to_s.gsub(/\W+/, '_').camelize}"
+    end
+  end
+end

data/lib/db_charmer/connection_proxy.rb

@@ -0,0 +1,27 @@
+# Simple proxy that sends all method calls to a real database connection
+module DbCharmer
+  class ConnectionProxy < ActiveSupport::BasicObject
+    # We need to do this because in Rails 2.3 BasicObject does not remove object_id method, which is stupid
+    undef_method(:object_id) if instance_methods.member?('object_id')
+
+    # We use this to get a connection class from the proxy
+    attr_accessor :abstract_connection_class
+
+    def initialize(abstract_class, db_name)
+      @abstract_connection_class = abstract_class
+      @db_name = db_name
+    end
+
+    def db_charmer_connection_name
+      @db_name
+    end
+
+    def db_charmer_connection_proxy
+      self
+    end
+
+    def method_missing(meth, *args, &block)
+      @abstract_connection_class.retrieve_connection.send(meth, *args, &block)
+    end
+  end
+end

data/lib/db_charmer/core_extensions.rb

@@ -0,0 +1,23 @@
+class Object
+  unless defined?(try)
+    def try(method, *options, &block)
+      send(method, *options, &block)
+    end
+  end
+
+  # These methods are added to all objects so we could call proxy? on anything
+  # and figure if an object is a proxy w/o hitting method_missing or respond_to?
+  def self.proxy?
+    false
+  end
+
+  def proxy?
+    false
+  end
+end
+
+class NilClass
+  def try(method, *options, &block)
+    nil
+  end
+end

data/lib/db_charmer/force_slave_reads.rb

@@ -0,0 +1,36 @@
+module DbCharmer
+  @@current_controller = nil
+  mattr_accessor :current_controller
+
+  @@forced_slave_reads = false
+
+  def self.force_slave_reads?
+    # If global force slave reads is requested, do it
+    return @@forced_slave_reads if @@forced_slave_reads
+
+    # If not, try to use current controller to decide on this
+    return false unless current_controller.respond_to?(:force_slave_reads?)
+
+    slave_reads = current_controller.force_slave_reads?
+    logger.debug("Using controller to figure out if slave reads should be forced: #{slave_reads}")
+    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}")
+    self.current_controller = controller
+    yield
+  ensure
+    logger.debug('Clearing current controller for db_charmer')
+    self.current_controller = nil
+  end
+
+  def self.force_slave_reads
+    raise ArgumentError, "No block given" unless block_given?
+    @@forced_slave_reads = true
+    yield
+  ensure
+    @@forced_slave_reads = false
+  end
+end

data/lib/db_charmer/rails2/abstract_adapter/log_formatting.rb

@@ -0,0 +1,24 @@
+module DbCharmer
+  module AbstractAdapter
+    module LogFormatting
+# TODO: this causes stack overflows
+=begin
+      def self.included(base)
+        base.alias_method_chain :format_log_entry, :connection_name
+      end
+
+      def connection_name
+        raise "Can't find connection configuration!" unless @config
+        @config[:connection_name]
+      end
+
+      # Rails 2.X specific logging method
+      def format_log_entry_with_connection_name(message, dump = nil)
+        msg = connection_name ? "[#{connection_name}] " : ''
+        msg = "  \e[0;34;1m#{msg}\e[0m" if connection_name && ::ActiveRecord::Base.colorize_logging
+        msg << format_log_entry_without_connection_name(message, dump)
+      end
+=end
+    end
+  end
+end

data/lib/db_charmer/rails2/active_record/master_slave_routing.rb

@@ -0,0 +1,49 @@
+module DbCharmer
+  module ActiveRecord
+    module MasterSlaveRouting
+
+      module ClassMethods
+        SLAVE_METHODS = [ :find_by_sql, :count_by_sql, :calculate ]
+        MASTER_METHODS = [ :update, :create, :delete, :destroy, :delete_all, :destroy_all, :update_all, :update_counters ]
+
+        SLAVE_METHODS.each do |slave_method|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            def #{slave_method}(*args, &block)
+              first_level_on_slave do
+                super(*args, &block)
+              end
+            end
+          EOF
+        end
+
+        MASTER_METHODS.each do |master_method|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            def #{master_method}(*args, &block)
+              on_master do
+                super(*args, &block)
+              end
+            end
+          EOF
+        end
+
+        def find(*args, &block)
+          options = args.last
+          if options.is_a?(Hash) && options[:lock]
+            on_master { super(*args, &block) }
+          else
+            super(*args, &block)
+          end
+        end
+      end
+
+      module InstanceMethods
+        def reload(*args, &block)
+          self.class.on_master do
+            super(*args, &block)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/db_charmer/rails2/active_record/named_scope/scope_proxy.rb

@@ -0,0 +1,26 @@
+module DbCharmer
+  module ActiveRecord
+    module NamedScope
+      module ScopeProxy
+
+        def proxy?
+          true
+        end
+
+        def on_db(con, proxy_target = nil, &block)
+          proxy_target ||= self
+          proxy_scope.on_db(con, proxy_target, &block)
+        end
+
+        def on_slave(con = nil, &block)
+          proxy_scope.on_slave(con, self, &block)
+        end
+
+        def on_master(&block)
+          proxy_scope.on_master(self, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/db_charmer/rails3/abstract_adapter/connection_name.rb

@@ -0,0 +1,38 @@
+module DbCharmer
+  module AbstractAdapter
+    module ConnectionName
+
+      # We use this proxy to push connection name down to instrumenters w/o monkey-patching the log method itself
+      class InstrumenterDecorator < ActiveSupport::BasicObject
+        def initialize(adapter, instrumenter)
+          @adapter = adapter
+          @instrumenter = instrumenter
+        end
+
+        def instrument(name, payload = {}, &block)
+          payload[:connection_name] ||= @adapter.connection_name
+          @instrumenter.instrument(name, payload, &block)
+        end
+
+        def method_missing(meth, *args, &block)
+          @instrumenter.send(meth, *args, &block)
+        end
+      end
+
+      def self.included(base)
+        base.alias_method_chain :initialize, :connection_name
+      end
+
+      def connection_name
+        raise "Can't find connection configuration!" unless @config
+        @config[:connection_name]
+      end
+
+      def initialize_with_connection_name(*args)
+        initialize_without_connection_name(*args)
+        @instrumenter = InstrumenterDecorator.new(self, @instrumenter)
+      end
+
+    end
+  end
+end

data/lib/db_charmer/rails3/active_record/log_subscriber.rb

@@ -0,0 +1,23 @@
+module DbCharmer
+  module ActiveRecord
+    module LogSubscriber
+
+      def self.included(base)
+        base.send(:attr_accessor, :connection_name)
+        base.alias_method_chain :sql, :connection_name
+        base.alias_method_chain :debug, :connection_name
+      end
+
+      def sql_with_connection_name(event)
+        self.connection_name = event.payload[:connection_name]
+        sql_without_connection_name(event)
+      end
+
+      def debug_with_connection_name(msg)
+        conn = connection_name ? color("  [#{connection_name}]", ActiveSupport::LogSubscriber::BLUE, true) : ''
+        debug_without_connection_name(conn + msg)
+      end
+
+    end
+  end
+end