seamless_database_pool 1.0.1 → 1.0.2

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 spec = Gem::Specification.new do |s| 
   s.name = "seamless_database_pool"
-  s.version = "1.0.1"
+  s.version = "1.0.2"
   s.author = "Brian Durand"
   s.platform = Gem::Platform::RUBY
   s.summary = "Support for master/slave database clusters in ActiveRecord"

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -31,7 +31,9 @@ module ActiveRecord
         end
       end if config[:read_pool]
       
-      ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.new(nil, logger, master_connection, read_connections, pool_weights)
+
+      klass = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
+      klass.new(nil, logger, master_connection, read_connections, pool_weights)
     end
     
     def self.establish_adapter (adapter)
@@ -79,12 +81,60 @@ module ActiveRecord
 
   module ConnectionAdapters
     class SeamlessDatabasePoolAdapter < AbstractAdapter
-
-      READ_ONLY_METHODS = [:select_one, :select_all, :select_value, :select_values, :select_rows, :select]
-      CONNECTION_METHODS = [:adapter_name, :active?, :reconnect!, :disconnect!, :verify!, :reset_runtime]
       
       attr_reader :read_connections, :master_connection
       
+      # Create an anonymous class that extends this one and proxies methods to the pool connections.
+      def self.adapter_class (master_connection)
+        # Define methods to proxy to the appropriate pool
+        read_only_methods = [:select_one, :select_all, :select_value, :select_values, :select_rows, :select]
+        connection_methods = [:adapter_name, :active?, :reconnect!, :disconnect!, :reset!, :verify!, :reset_runtime]
+        master_methods = master_connection.public_methods(false) + master_connection.protected_methods(false) + master_connection.private_methods(false)
+        master_methods -= public_methods(false) + protected_methods(false) + private_methods(false)
+        master_methods = master_methods.collect{|m| m.to_sym}
+        master_methods -= read_only_methods
+        master_methods -= connection_methods
+        master_methods.delete(:transaction)
+
+        klass = Class.new(self)
+        master_methods.each do |method_name|
+          klass.class_eval(%Q(
+            def #{method_name}(*args, &block)
+              begin
+                proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
+              rescue DatabaseConnectionError => e
+                raise e.wrapped_exception
+              end
+            end
+          ))
+        end
+
+        read_only_methods.each do |method_name|
+          klass.class_eval(%Q(
+            def #{method_name}(*args, &block)
+              connection = current_read_connection
+              begin
+                proxy_connection_method(connection, :#{method_name}, :read, *args, &block)
+              rescue DatabaseConnectionError => e
+                unless block or using_master_connection?
+                  # Try again with a different connection if needed unless it could have a side effect
+                  unless connection.active?
+                    suppress_read_connection(connection, 30)
+                    connection = current_read_connection
+                    SeamlessDatabasePool.set_persistent_read_connection(self, connection)
+                  end
+                  proxy_connection_method(connection, :#{method_name}, :retry, *args, &block)
+                else
+                  raise e.wrapped_exception
+                end
+              end
+            end
+          ))
+        end
+        
+        return klass
+      end
+      
       def initialize (connection, logger, master_connection, read_connections, pool_weights)
         super(connection, logger)
         
@@ -96,8 +146,6 @@ module ActiveRecord
           weight.times{@weighted_read_connections << conn}
         end
         @available_read_connections = [AvailableConnections.new(@weighted_read_connections)]
-        
-        define_proxy_methods
       end
       
       def adapter_name #:nodoc:
@@ -128,8 +176,12 @@ module ActiveRecord
         all_connections.each{|conn| conn.disconnect!}
       end
       
-      def verify!(timeout)
-        all_connections.each{|conn| conn.verify!(timeout)}
+      def reset!
+        all_connections.each{|conn| conn.reset!}
+      end
+      
+      def verify!(*ignored)
+        all_connections.each{|conn| conn.verify!(*ignored)}
       end
       
       def reset_runtime
@@ -254,49 +306,6 @@ module ActiveRecord
         end
       end
       
-      # Define proxy methods to handle actual database work.
-      def define_proxy_methods
-        master_methods = master_connection.public_methods(false) + master_connection.protected_methods(false) + master_connection.private_methods(false)
-        master_methods -= READ_ONLY_METHODS
-        master_methods -= CONNECTION_METHODS
-        master_methods.delete(:transaction)
-        
-        master_methods.each do |method_name|
-          instance_eval(%Q(
-            def #{method_name}(*args, &block)
-              begin
-                proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
-              rescue DatabaseConnectionError => e
-                raise e.wrapped_exception
-              end
-            end
-          ))
-        end
-        
-        READ_ONLY_METHODS.each do |method_name|
-          instance_eval(%Q(
-            def #{method_name}(*args, &block)
-              connection = current_read_connection
-              begin
-                proxy_connection_method(connection, :#{method_name}, :read, *args, &block)
-              rescue DatabaseConnectionError => e
-                unless block or using_master_connection?
-                  # Try again with a different connection if needed unless it could have a side effect
-                  unless connection.active?
-                    suppress_read_connection(connection, 30)
-                    connection = current_read_connection
-                    SeamlessDatabasePool.set_persistent_read_connection(self, connection)
-                  end
-                  proxy_connection_method(connection, :#{method_name}, :retry, *args, &block)
-                else
-                  raise e.wrapped_exception
-                end
-              end
-            end
-          ))
-        end
-      end
-      
     end
   end
 end

data/lib/seamless_database_pool/controller_filter.rb

@@ -8,7 +8,7 @@ module SeamlessDatabasePool
   # Example:
   # 
   #   ApplicationController < ActionController::Base
-  #     include SeamlessDatabasePool
+  #     include SeamlessDatabasePool::ControllerFilter
   #     use_database_pool :all => :persistent, [:save, :delete] => :master
   #     ...
   

data/spec/filter_spec.rb

@@ -9,7 +9,7 @@ describe "SeamlessDatabasePool::ControllerFilter" do
       
       def initialize(action, session = nil)
         @action_name = action
-        session ||= CGI::Session.new(CGI.new)
+        session ||= {}
         @session = session
       end
       
@@ -89,7 +89,7 @@ describe "SeamlessDatabasePool::ControllerFilter" do
   end
   
   it "should be able to force using the master connection on the next request" do
-    session = CGI::Session.new(CGI.new)
+    session = {}
     
     # First request
     controller = SeamlessDatabasePool::TestOtherController.new('read', session)
@@ -116,7 +116,7 @@ describe "SeamlessDatabasePool::ControllerFilter" do
   end
   
   it "should force the master connection on the next request for a redirect in master connection block" do
-    session = CGI::Session.new(CGI.new)
+    session = {}
     controller = SeamlessDatabasePool::TestOtherController.new('redirect_master_action', session)
     controller.perform_action.should == {:action => :read}
     
@@ -125,7 +125,7 @@ describe "SeamlessDatabasePool::ControllerFilter" do
   end
 
   it "should not force the master connection on the next request for a redirect not in master connection block" do
-    session = CGI::Session.new(CGI.new)
+    session = {}
     controller = SeamlessDatabasePool::TestOtherController.new('redirect_read_action', session)
     controller.perform_action.should == {:action => :read}
     

data/spec/seamless_database_pool_adapter_spec.rb

@@ -52,7 +52,9 @@ describe "SeamlessDatabasePoolAdapter ActiveRecord::Base extension" do
     ActiveRecord::Base.should_receive(:reader_connection).with(:adapter => 'reader', :host => 'read_host_1', :username => 'user', :pool_weight => 1).and_return(read_connection_1)
     ActiveRecord::Base.should_receive(:reader_connection).with(:adapter => 'reader', :host => 'read_host_2', :username => 'user', :pool_weight => 2).and_return(read_connection_2)
     
-    ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.should_receive(:new).with(nil, logger, master_connection, [read_connection_1, read_connection_2], weights).and_return(pool_connection)
+    klass = mock(:class)
+    ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.should_receive(:adapter_class).with(master_connection).and_return(klass)
+    klass.should_receive(:new).with(nil, logger, master_connection, [read_connection_1, read_connection_2], weights).and_return(pool_connection)
     
     ActiveRecord::Base.should_receive(:establish_adapter).with('writer')
     ActiveRecord::Base.should_receive(:establish_adapter).with('reader').twice
@@ -72,7 +74,8 @@ describe "SeamlessDatabasePoolAdapter" do
     @read_connection_1 = SeamlessDatabasePool::MockConnection.new("read_1")
     @read_connection_2 = SeamlessDatabasePool::MockConnection.new("read_2")
     weights = {@master_connection => 1, @read_connection_1 => 1, @read_connection_2 => 2}
-    @pool_connection = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.new(nil, mock(:logger), @master_connection, [@read_connection_1, @read_connection_2], weights)
+    connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
+    @pool_connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1, @read_connection_2], weights)
   end
   
   it "should initialize the connection pool" do
@@ -102,7 +105,8 @@ describe "SeamlessDatabasePoolAdapter" do
   end
   
   it "should use the master connection in a block" do
-    connection = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
+    connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
+    connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
     connection.random_read_connection.should == @read_connection_1
     connection.use_master_connection do
       connection.random_read_connection.should == @master_connection
@@ -111,7 +115,8 @@ describe "SeamlessDatabasePoolAdapter" do
   end
   
   it "should use the master connection inside a transaction" do
-    connection = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
+    connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
+    connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
     @master_connection.should_receive(:transaction).with(true).and_yield
     @master_connection.should_receive(:select_one).with('Transaction SQL')
     @read_connection_1.should_receive(:select_one).with('SQL 1')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: seamless_database_pool
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Brian Durand
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-25 00:00:00 -05:00
+date: 2009-05-06 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - rspec 1.0.8 or higher is needed to run the tests
 rubyforge_project: seamlessdbpool
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Support for master/slave database clusters in ActiveRecord