seamless_database_pool 1.0.13 → 1.0.14

data/Rakefile

@@ -72,7 +72,7 @@ begin
     gem.has_rdoc = true
     gem.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
   
-    gem.add_dependency('activerecord', '>= 2.2.2')
+    gem.add_dependency('activerecord', '>= 3.0.20')
     gem.add_development_dependency('rspec', '>= 2.0')
     gem.add_development_dependency('jeweler')
     gem.add_development_dependency('sqlite3')

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -13,8 +13,6 @@ module ActiveRecord
         master_config = default_config.merge(config[:master]).with_indifferent_access
         establish_adapter(master_config[:adapter])
         master_connection = send("#{master_config[:adapter]}_connection".to_sym, master_config)
-        master_connection.class.send(:include, SeamlessDatabasePool::ConnectTimeout) unless master_connection.class.include?(SeamlessDatabasePool::ConnectTimeout)
-        master_connection.connect_timeout = master_config[:connect_timeout]
         pool_weights[master_connection] = master_config[:pool_weight].to_i if master_config[:pool_weight].to_i > 0
         
         read_connections = []
@@ -25,8 +23,6 @@ module ActiveRecord
             begin
               establish_adapter(read_config[:adapter])
               conn = send("#{read_config[:adapter]}_connection".to_sym, read_config)
-              conn.class.send(:include, SeamlessDatabasePool::ConnectTimeout) unless conn.class.include?(SeamlessDatabasePool::ConnectTimeout)
-              conn.connect_timeout = read_config[:connect_timeout]
               read_connections << conn
               pool_weights[conn] = read_config[:pool_weight]
             rescue Exception => e
@@ -93,23 +89,22 @@ module ActiveRecord
           return const_get(adapter_class_name) if const_defined?(adapter_class_name, false)
           
           # Define methods to proxy to the appropriate pool
-          read_only_methods = [:select_one, :select_all, :select_value, :select_values, :select, :select_rows, :execute, :tables, :columns]
+          read_only_methods = [:select, :select_rows, :execute, :tables, :columns]
+          clear_cache_methods = [:insert, :update, :delete]
+          
+          # Get a list of all methods redefined by the underlying adapter. These will be
+          # proxied to the master connection.
           master_methods = []
-          master_connection_classes = [AbstractAdapter, Quoting, DatabaseStatements, SchemaStatements]
-          master_connection_classes << DatabaseLimits if const_defined?(:DatabaseLimits)
-          master_connection_class = master_connection.class
-          while ![Object, AbstractAdapter].include?(master_connection_class) do
-            master_connection_classes << master_connection_class
-            master_connection_class = master_connection_class.superclass
-          end
-          master_connection_classes.each do |connection_class|
+          override_classes = (master_connection.class.ancestors - AbstractAdapter.ancestors)
+          override_classes.each do |connection_class|
             master_methods.concat(connection_class.public_instance_methods(false))
             master_methods.concat(connection_class.protected_instance_methods(false))
           end
-          master_methods.uniq!
+          master_methods = master_methods.collect{|m| m.to_sym}.uniq
           master_methods -= public_instance_methods(false) + protected_instance_methods(false) + private_instance_methods(false)
-          master_methods = master_methods.collect{|m| m.to_sym}
           master_methods -= read_only_methods
+          master_methods -= [:select_all, :select_one, :select_value, :select_values]
+          master_methods -= clear_cache_methods
 
           klass = Class.new(self)
           master_methods.each do |method_name|
@@ -121,7 +116,18 @@ module ActiveRecord
               end
             EOS
           end
-        
+          
+          clear_cache_methods.each do |method_name|
+            klass.class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{method_name}(*args, &block)
+                clear_query_cache if query_cache_enabled
+                use_master_connection do
+                  return proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
+                end
+              end
+            EOS
+          end
+          
           read_only_methods.each do |method_name|
             klass.class_eval <<-EOS, __FILE__, __LINE__ + 1
               def #{method_name}(*args, &block)
@@ -178,6 +184,12 @@ module ActiveRecord
         false
       end
       
+      def transaction(options = {})
+        use_master_connection do
+          super
+        end
+      end
+      
       def visitor=(visitor)
         all_connections.each{|conn| conn.visitor = visitor}
       end
@@ -213,23 +225,6 @@ module ActiveRecord
         do_to_connections {|conn| total += conn.reset_runtime}
         total
       end
-
-      def lease
-        synchronize do
-          unless @in_use
-            @in_use   = true
-            @last_use = Time.now
-          end
-        end
-      end
-
-      def expire
-        @in_use = false
-      end
-
-      def close
-        pool.checkin self
-      end
       
       # Get a random read connection from the pool. If the connection is not active, it will attempt to reconnect
       # to the database. If that fails, it will be removed from the pool for one minute.

data/lib/seamless_database_pool.rb

@@ -1,4 +1,3 @@
-require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'connect_timeout.rb')
 require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'connection_statistics.rb')
 require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'controller_filter.rb')
 require File.join(File.dirname(__FILE__), 'active_record', 'connection_adapters', 'seamless_database_pool_adapter.rb')

data/spec/connection_adapters_spec.rb

@@ -13,7 +13,9 @@ describe "Test connection adapters" do
         let(:master_connection){ connection.master_connection }
   
         before(:all) do
+          ActiveRecord::Base.configurations = {'adapter' => "sqlite3", 'database' => ":memory:"}
           ActiveRecord::Base.establish_connection('adapter' => "sqlite3", 'database' => ":memory:")
+          ActiveRecord::Base.connection
           SeamlessDatabasePool::TestModel.db_model(adapter).create_tables
         end
   
@@ -66,8 +68,18 @@ describe "Test connection adapters" do
           record = model.find_by_name("test")
           record.name.should == "test"
         end
-          
+
         it "should work with query caching" do
+          record_id =  model.first.id
+          model.cache do
+            found = model.find(record_id)
+            found.value.should == 1
+            connection.master_connection.update("UPDATE #{model.table_name} SET value = 0 WHERE id = #{record_id}")
+            model.find(record_id).value.should == 1
+          end
+        end
+        
+        it "should work bust the query cache on update" do
           record_id =  model.first.id
           model.cache do
             found = model.find(record_id)
@@ -76,7 +88,7 @@ describe "Test connection adapters" do
             model.find(record_id).name.should == "new value"
           end
         end
-          
+        
         context "read connection" do
           let(:sample_sql){"SELECT #{connection.quote_column_name('name')} FROM #{connection.quote_table_name(model.table_name)}"}
             
@@ -87,43 +99,15 @@ describe "Test connection adapters" do
             
           it "should send select to the read connection" do
             results = connection.send(:select, sample_sql)
-            results.should == [{"name" => "test"}]
-            results.should == master_connection.send(:select, sample_sql)
-            results.should be_read_only
-          end
-          
-          it "should send select_all to the read connection" do
-            results = connection.select_all(sample_sql)
-            results.should == [{"name" => "test"}]
-            results.should == master_connection.select_all(sample_sql)
-            results.should be_read_only
-          end
-          
-          it "should send select_one to the read connection" do
-            results = connection.select_one(sample_sql)
-            results.should == {"name" => "test"}
-            results.should == master_connection.select_one(sample_sql)
-            results.should be_read_only
-          end
-          
-          it "should send select_values to the read connection" do
-            results = connection.select_values(sample_sql)
-            results.should == ["test"]
-            results.should == master_connection.select_values(sample_sql)
-            results.should be_read_only
-          end
-          
-          it "should send select_value to the read connection" do
-            results = connection.select_value(sample_sql)
-            results.should == "test"
-            results.should == master_connection.select_value(sample_sql)
+            results.to_a.should == [{"name" => "test"}]
+            results.to_a.should == master_connection.send(:select, sample_sql).to_a
             results.should be_read_only
           end
           
           it "should send select_rows to the read connection" do
-            results = connection.select_all(sample_sql)
-            results.should == [{"name" => "test"}]
-            results.should == master_connection.select_all(sample_sql)
+            results = connection.select_rows(sample_sql)
+            results.should == [["test"]]
+            results.should == master_connection.select_rows(sample_sql)
             results.should be_read_only
           end
           
@@ -155,6 +139,34 @@ describe "Test connection adapters" do
             read_connection.should be_active
           end
         end
+        
+        context "methods not overridden" do
+          let(:sample_sql){"SELECT #{connection.quote_column_name('name')} FROM #{connection.quote_table_name(model.table_name)}"}
+          
+          it "should use select_all" do
+            results = connection.select_all(sample_sql)
+            results.to_a.should == [{"name" => "test"}].to_a
+            results.to_a.should == master_connection.select_all(sample_sql).to_a
+          end
+          
+          it "should use select_one" do
+            results = connection.select_one(sample_sql)
+            results.should == {"name" => "test"}
+            results.should == master_connection.select_one(sample_sql)
+          end
+          
+          it "should use select_values" do
+            results = connection.select_values(sample_sql)
+            results.should == ["test"]
+            results.should == master_connection.select_values(sample_sql)
+          end
+          
+          it "should use select_value" do
+            results = connection.select_value(sample_sql)
+            results.should == "test"
+            results.should == master_connection.select_value(sample_sql)
+          end
+        end
           
         context "master connection" do
           let(:insert_sql){ "INSERT INTO #{connection.quote_table_name(model.table_name)} (#{connection.quote_column_name('name')}) VALUES ('new')" }
@@ -206,20 +218,13 @@ describe "Test connection adapters" do
           end
           
           it "should properly dump the schema" do
-            schema = <<-EOS
-              ActiveRecord::Schema.define(:version => 0) do
-                create_table "#{model.table_name}", :force => true do |t|
-                  t.string  "name"
-                  t.integer "value"
-                end
-              end
-            EOS
-            schema = schema.gsub(/^ +/, '').gsub(/ +/, ' ').strip
+            with_driver = StringIO.new
+            ActiveRecord::SchemaDumper.dump(connection, with_driver)
+            
+            without_driver = StringIO.new
+            ActiveRecord::SchemaDumper.dump(master_connection, without_driver)
             
-            io = StringIO.new
-            ActiveRecord::SchemaDumper.dump(connection, io)
-            generated_schema = io.string.gsub(/^#.*$/, '').gsub(/\n+/, "\n").gsub(/^ +/, '').gsub(/ +/, ' ').strip
-            generated_schema.should == schema
+            with_driver.string.should == without_driver.string
           end
         end
       end

data/spec/seamless_database_pool_adapter_spec.rb

@@ -13,6 +13,16 @@ module SeamlessDatabasePool
     def reconnect!
       sleep(0.1)
     end
+    
+    def active?
+      true
+    end
+    
+    def begin_db_transaction
+    end
+    
+    def commit_db_transaction
+    end
   end
   
   class MockMasterConnection < MockConnection
@@ -118,7 +128,8 @@ describe "SeamlessDatabasePoolAdapter" do
     it "should use the master connection inside a transaction" do
       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).and_yield
+      master_connection.should_receive(:begin_db_transaction)
+      master_connection.should_receive(:commit_db_transaction)
       master_connection.should_receive(:select).with('Transaction SQL', nil)
       read_connection_1.should_receive(:select).with('SQL 1', nil)
       read_connection_1.should_receive(:select).with('SQL 2', nil)
@@ -205,12 +216,7 @@ describe "SeamlessDatabasePoolAdapter" do
       read_connection_2.should_receive(:reconnect!)
       pool_connection.reconnect!
     end
-  
-    it "should timeout reconnect! calls to dead servers" do
-      read_connection_1.connect_timeout = 0.01
-      lambda{read_connection_1.reconnect!}.should raise_error("reconnect timed out")
-    end
-  
+    
     it "should fork reset_runtime to all connections" do
       master_connection.should_receive(:reset_runtime).and_return(1)
       read_connection_1.should_receive(:reset_runtime).and_return(2)
@@ -230,7 +236,7 @@ describe "SeamlessDatabasePoolAdapter" do
     end
   
     it "should try to reconnect dead connections when they become available again" do
-      master_connection.stub!(:select_value).and_raise("SQL ERROR")
+      master_connection.stub!(:select).and_raise("SQL ERROR")
       master_connection.should_receive(:active?).and_return(false, false, true)
       master_connection.should_receive(:reconnect!)
       now = Time.now
@@ -242,19 +248,19 @@ describe "SeamlessDatabasePoolAdapter" do
     it "should not try to reconnect live connections" do
       args = [:arg1, :arg2]
       block = Proc.new{}
-      master_connection.should_receive(:select_value).with(*args, &block).twice.and_raise("SQL ERROR")
+      master_connection.should_receive(:select).with(*args, &block).twice.and_raise("SQL ERROR")
       master_connection.should_receive(:active?).and_return(true)
       master_connection.should_not_receive(:reconnect!)
-      lambda{pool_connection.send(:proxy_connection_method, master_connection, :select_value, :read, *args, &block)}.should raise_error("SQL ERROR")
+      lambda{pool_connection.send(:proxy_connection_method, master_connection, :select, :read, *args, &block)}.should raise_error("SQL ERROR")
     end
   
     it "should not try to reconnect a connection during a retry" do
       args = [:arg1, :arg2]
       block = Proc.new{}
-      master_connection.should_receive(:select_value).with(*args, &block).and_raise("SQL ERROR")
+      master_connection.should_receive(:select).with(*args, &block).and_raise("SQL ERROR")
       master_connection.should_not_receive(:active?)
       master_connection.should_not_receive(:reconnect!)
-      lambda{pool_connection.send(:proxy_connection_method, master_connection, :select_value, :retry, *args, &block)}.should raise_error("SQL ERROR")
+      lambda{pool_connection.send(:proxy_connection_method, master_connection, :select, :retry, *args, &block)}.should raise_error("SQL ERROR")
     end
   
     it "should try to execute a read statement again after a connection error" do

data/spec/test_adapter/active_record/connection_adapters/read_only_adapter.rb

@@ -9,7 +9,7 @@ module ActiveRecord
   
   module ConnectionAdapters
     class ReadOnlyAdapter < AbstractAdapter
-      %w(select_one select_all select_value select_values select select_rows execute tables columns).each do |read_method|
+      %w(select select_rows execute tables columns).each do |read_method|
         class_eval <<-EOS, __FILE__, __LINE__ + 1
           def #{read_method} (*args, &block)
             raise "Not Connected" unless @connected

data/spec/test_model.rb

@@ -32,14 +32,14 @@ module SeamlessDatabasePool
           t.column :name, :string
           t.column :value, :integer
         end unless table_exists?
-        connection.clear_cache!
-        undefine_attribute_methods
+        connection.clear_cache! if connection.respond_to?(:clear_cache!)
+        undefine_attribute_methods if respond_to?(:undefine_attribute_methods)
       end
  
       def drop_tables
         connection.drop_table(table_name)
-        connection.clear_cache!
-        undefine_attribute_methods
+        connection.clear_cache! if connection.respond_to?(:clear_cache!)
+        undefine_attribute_methods if respond_to?(:undefine_attribute_methods)
       end
       
       def cleanup_database!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seamless_database_pool
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.14
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-11 00:00:00.000000000 Z
+date: 2013-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.2.2
+        version: 3.0.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.2.2
+        version: 3.0.20
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -121,7 +121,6 @@ files:
 - lib/active_record/connection_adapters/seamless_database_pool_adapter.rb
 - lib/seamless_database_pool.rb
 - lib/seamless_database_pool/arel_compiler.rb
-- lib/seamless_database_pool/connect_timeout.rb
 - lib/seamless_database_pool/connection_statistics.rb
 - lib/seamless_database_pool/controller_filter.rb
 - lib/seamless_database_pool/railtie.rb

data/lib/seamless_database_pool/connect_timeout.rb

@@ -1,24 +0,0 @@
-require 'timeout'
-
-module SeamlessDatabasePool
-  # This module is mixed into connection adapters to allow the reconnect! method to timeout if the
-  # IP address becomes unreachable. The default timeout is 1 second, but you can change it by setting
-  # the connect_timeout parameter in the adapter configuration.
-  module ConnectTimeout
-    attr_accessor :connect_timeout
-    
-    def self.included(base)
-      base.alias_method_chain :reconnect!, :connect_timeout
-    end
-    
-    def reconnect_with_connect_timeout!
-      begin
-        timeout(connect_timeout || 1) do
-          reconnect_without_connect_timeout!
-        end
-      rescue Timeout::Error
-        raise ActiveRecord::ConnectionTimeoutError.new("reconnect timed out")
-      end
-    end
-  end
-end