seamless_database_pool 1.0.9 → 1.0.10

data/README.rdoc

@@ -66,6 +66,8 @@ In this configuration, the master connection will be a mysql connection to maste
 
 The read pool will use three mysql connections to master-db, read-db-1, and read-db-2. The master connection will use a different port, username, password for the connection. The read connections will use the same values. Further, the connection read-db-1 will get half the traffic as the other two connections, so presumably it's on a more powerful box.
 
+You must use compatible database adapters for both the master and the read connections. For example, you cannot use an Oracle server as your master and PostgreSQL servers as you read slaves.
+
 = Using the read pool
 
 By default, the master connection will be used for everything. This is not terribly useful, so you should really specify a method of using the read pool for the actions that need it. Read connections will only be used for select statements against the database.

data/Rakefile

@@ -75,6 +75,9 @@ begin
     gem.add_dependency('activerecord', '>= 2.2.2')
     gem.add_development_dependency('rspec', '>= 2.0')
     gem.add_development_dependency('jeweler')
+    gem.add_development_dependency('sqlite3')
+    gem.add_development_dependency('mysql')
+    gem.add_development_dependency('pg')
   end
 
   Jeweler::GemcutterTasks.new

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -16,7 +16,7 @@ module ActiveRecord
         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 = []
         config[:read_pool].each do |read_config|
           read_config = default_config.merge(read_config).with_indifferent_access
@@ -30,6 +30,7 @@ module ActiveRecord
               read_connections << conn
               pool_weights[conn] = read_config[:pool_weight]
             rescue Exception => e
+              raise e # TODO remove
               if logger
                 logger.error("Error connecting to read connection #{read_config.inspect}")
                 logger.error(e)
@@ -48,7 +49,7 @@ module ActiveRecord
         return klass.new(nil, logger, master_connection, read_connections, pool_weights)
       end
 
-      def establish_adapter (adapter)
+      def establish_adapter(adapter)
         raise AdapterNotSpecified.new("database configuration does not specify adapter") unless adapter
         raise AdapterNotFound.new("database pool must specify adapters") if adapter == 'seamless_database_pool'
       
@@ -77,7 +78,7 @@ module ActiveRecord
       end
       
       # Force reload to use the master connection since it's probably being called for a reason.
-      def reload_with_seamless_database_pool (*args)
+      def reload_with_seamless_database_pool(*args)
         SeamlessDatabasePool.use_master_connection do
           reload_without_seamless_database_pool(*args)
         end
@@ -92,50 +93,60 @@ module ActiveRecord
       
       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, :select_rows, :execute, :tables, :columns]
-        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|
-          master_methods.concat(connection_class.public_instance_methods(false))
-          master_methods.concat(connection_class.protected_instance_methods(false))
-          #master_methods.concat(connection_class.private_instance_methods(false))
-        end
-        master_methods.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
+      class << self
+        # Create an anonymous class that extends this one and proxies methods to the pool connections.
+        def adapter_class(master_connection)
+          # 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]
+          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|
+            master_methods.concat(connection_class.public_instance_methods(false))
+            master_methods.concat(connection_class.protected_instance_methods(false))
+          end
+          master_methods.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
 
-        klass = Class.new(self)
-        master_methods.each do |method_name|
-          klass.class_eval %Q(
-            def #{method_name}(*args, &block)
-              use_master_connection do
-                return proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
+          klass = Class.new(self)
+          master_methods.each do |method_name|
+            klass.class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{method_name}(*args, &block)
+                use_master_connection do
+                  return proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
+                end
               end
-            end
-          )
-        end
+            EOS
+          end
         
-        read_only_methods.each do |method_name|
-          klass.class_eval %Q(
-            def #{method_name}(*args, &block)
-              connection = @use_master ? master_connection : current_read_connection
-              proxy_connection_method(connection, :#{method_name}, :read, *args, &block)
-            end
-          )
-        end
-        klass.send :protected, :select
+          read_only_methods.each do |method_name|
+            klass.class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{method_name}(*args, &block)
+                connection = @use_master ? master_connection : current_read_connection
+                proxy_connection_method(connection, :#{method_name}, :read, *args, &block)
+              end
+            EOS
+          end
+          klass.send :protected, :select
         
-        return klass
+          return klass
+        end
+      
+        # Set the arel visitor on the connections.
+        def visitor_for(pool)
+          # This is ugly, but then again, so is the code in ActiveRecord for setting the arel
+          # visitor. There is a note in the code indicating the method signatures should be updated.
+          config = pool.spec.config.with_indifferent_access
+          adapter = config[:master][:adapter] || config[:pool_adapter]
+          SeamlessDatabasePool.adapter_class_for(adapter).visitor_for(pool)
+        end
       end
       
       def initialize(connection, logger, master_connection, read_connections, pool_weights)
@@ -161,7 +172,7 @@ module ActiveRecord
       end
       
       # Get the pool weight of a connection
-      def pool_weight (connection)
+      def pool_weight(connection)
         return @weighted_read_connections.select{|conn| conn == connection}.size
       end
       
@@ -169,6 +180,14 @@ module ActiveRecord
         false
       end
       
+      def visitor=(visitor)
+        all_connections.each{|conn| conn.visitor = visitor}
+      end
+      
+      def visitor
+        master_connection.visitor
+      end
+      
       def active?
         active = true
         do_to_connections {|conn| active &= conn.active?}
@@ -237,7 +256,7 @@ module ActiveRecord
         attr_reader :connections, :failed_connection
         attr_writer :expires
         
-        def initialize (connections, failed_connection = nil, expires = nil)
+        def initialize(connections, failed_connection = nil, expires = nil)
           @connections = connections
           @failed_connection = failed_connection
           @expires = expires

data/lib/seamless_database_pool.rb

@@ -1,7 +1,7 @@
-require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'connect_timeout')
-require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'connection_statistics')
-require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'controller_filter')
-require File.join(File.dirname(__FILE__), 'active_record', 'connection_adapters', 'seamless_database_pool_adapter')
+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')
 $LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
 
 # This module allows setting the read pool connection type. Generally you will use one of
@@ -15,7 +15,12 @@ $LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__F
 # read connection type. If none is ever called, the read connection type will be :master.
 
 module SeamlessDatabasePool
-
+    
+  # Adapter name to class name map. This exists because there isn't an obvious way to translate things like
+  # sqlite3 to SQLite3. The adapters that ship with ActiveRecord are defined here. If you use
+  # an adapter that doesn't translate directly to camel case, then add the mapping here in an initializer.
+  ADAPTER_TO_CLASS_NAME_MAP = {"sqlite" => "SQLite", "sqlite3" => "SQLite3", "postgresql" => "PostgreSQL"}
+  
   READ_CONNECTION_METHODS = [:master, :persistent, :random]
 
   class << self
@@ -111,6 +116,16 @@ module SeamlessDatabasePool
     def clear_read_only_connection
       Thread.current[:read_only_connection] = nil
     end
+    
+    # Get the connection adapter class for an adapter name. The class will be loaded from
+    # ActiveRecord::ConnectionAdapters::NameAdapter where Name is the camelized version of the name.
+    # If the adapter class does not fit this pattern (i.e. sqlite3 => SQLite3Adapter), then add
+    # the mapping to the +ADAPTER_TO_CLASS_NAME_MAP+ Hash.
+    def adapter_class_for(name)
+      name = name.to_s
+      class_name = ADAPTER_TO_CLASS_NAME_MAP[name] || name.camelize
+      "ActiveRecord::ConnectionAdapters::#{class_name}Adapter".constantize
+    end
   end
   
 end

data/spec/connection_adapters_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'active_record/connection_adapters/read_only_adapter'
 
 describe "Test connection adapters" do
   if SeamlessDatabasePool::TestModel.database_configs.empty?
@@ -41,32 +42,32 @@ describe "Test connection adapters" do
         it "should quote table names properly" do
           connection.quote_table_name("foo").should == master_connection.quote_table_name("foo")
         end
-      
+              
         it "should quote column names properly" do
           connection.quote_column_name("foo").should == master_connection.quote_column_name("foo")
         end
-      
+              
         it "should quote string properly" do
           connection.quote_string("foo").should == master_connection.quote_string("foo")
         end
-      
+              
         it "should quote booleans properly" do
           connection.quoted_true.should == master_connection.quoted_true
           connection.quoted_false.should == master_connection.quoted_false
         end
-      
+              
         it "should quote dates properly" do
           date = Date.today
           time = Time.now
           connection.quoted_date(date).should == master_connection.quoted_date(date)
           connection.quoted_date(time).should == master_connection.quoted_date(time)
         end
-  
+          
         it "should query for records" 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
@@ -76,62 +77,62 @@ 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)}"}
-    
+            
           it "should not include the master connection in the read pool for these tests" do
             connection.available_read_connections.should_not include(master_connection)
             connection.current_read_connection.should_not == master_connection
           end
-    
+            
           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.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.should be_read_only
           end
-  
+          
           it "should send execute to the read connection" do
             results = connection.execute(sample_sql)
             results.should be_read_only
           end
-  
+          
           it "should send columns to the read connection" do
             results = connection.columns(model.table_name)
             columns = results.collect{|c| c.name}.sort.should
@@ -139,14 +140,14 @@ describe "Test connection adapters" do
             columns.should == master_connection.columns(model.table_name).collect{|c| c.name}.sort
             results.should be_read_only
           end
-  
+          
           it "should send tables to the read connection" do
             results = connection.tables
             results.should == ["test_models"]
             results.should == master_connection.tables
             results.should be_read_only
           end
-
+        
           it "should reconnect dead connections in the read pool" do
             read_connection.disconnect!
             read_connection.should_not be_active
@@ -155,12 +156,12 @@ describe "Test connection adapters" do
             read_connection.should be_active
           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')" }
           let(:update_sql){ "UPDATE #{connection.quote_table_name(model.table_name)} SET #{connection.quote_column_name('value')} = 2" }
           let(:delete_sql){ "DELETE FROM #{connection.quote_table_name(model.table_name)}" }
-    
+            
           it "should blow up if a master connection method is sent to the read only connection" do
             lambda{read_connection.update(update_sql)}.should raise_error(NotImplementedError)
             lambda{read_connection.update(insert_sql)}.should raise_error(NotImplementedError)
@@ -168,29 +169,29 @@ describe "Test connection adapters" do
             lambda{read_connection.transaction{}}.should raise_error(NotImplementedError)
             lambda{read_connection.create_table(:test)}.should raise_error(NotImplementedError)
           end
-    
+            
           it "should send update to the master connection" do
             connection.update(update_sql)
             model.first.value.should == 2
           end
-  
+          
           it "should send insert to the master connection" do
             connection.update(insert_sql)
             model.find_by_name("new").should_not == nil
           end
-  
+          
           it "should send delete to the master connection" do
             connection.update(delete_sql)
             model.first.should == nil
           end
-  
+          
           it "should send transaction to the master connection" do
             connection.transaction do
               connection.update(update_sql)
             end
             model.first.value.should == 2
           end
-  
+          
           it "should send schema altering statements to the master connection" do
             SeamlessDatabasePool.use_master_connection do
               begin

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

@@ -1,6 +1,6 @@
 module ActiveRecord
   class Base
-    def self.read_only_connection (config)
+    def self.read_only_connection(config)
       real_adapter = config.delete("real_adapter")
       connection = send("#{real_adapter}_connection", config.merge("adapter" => real_adapter))
       ConnectionAdapters::ReadOnlyAdapter.new(connection)
@@ -10,7 +10,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|
-        class_eval <<-EOS
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
           def #{read_method} (*args, &block)
             raise "Not Connected" unless @connected
             result = @connection.send(:#{read_method}, *args, &block)
@@ -22,7 +22,7 @@ module ActiveRecord
         EOS
         
         %w(update insert delete reload create_table drop_table add_index remove_index transaction).each do |write_method|
-          class_eval <<-EOS
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{write_method} (*args, &block)
               raise NotImplementedError.new("Master method '#{write_method}' called on read only connection")
             end
@@ -30,11 +30,24 @@ module ActiveRecord
         end
       end
     
-      def initialize (connection)
+      def initialize(connection)
         @connection = connection
         @connected = true
+        super
       end
-    
+      
+      def test_select
+        @connection.select_all('SELECT  "test_models".* FROM "test_models"  LIMIT 1')
+      end
+      
+      def visitor
+        @connection.visitor
+      end
+      
+      def visitor=(v)
+        @connection.visitor = v
+      end
+      
       def reconnect!
         @connected = true
       end

data/spec/test_model.rb

@@ -5,16 +5,16 @@ module SeamlessDatabasePool
         adapters = ENV['TEST_ADAPTERS'].blank? ? [] : ENV['TEST_ADAPTERS'].split(/\s+/)
         configs = {}
         YAML.load_file(File.expand_path("../database.yml", __FILE__)).each do |adapter_name, adapter_config|
-          configs[adapter_name] = adapter_config if adapters.include?(adapter_name)
+          configs[adapter_name] = adapter_config if adapters.include?(adapter_name.downcase)
         end
         configs
       end
       
-      def use_database_connection (db_name)
+      def use_database_connection(db_name)
         establish_connection(database_configs[db_name.to_s])
       end
       
-      def db_model (db_name)
+      def db_model(db_name)
         model_class_name = db_name.classify
         unless const_defined?(model_class_name)
           klass = Class.new(self)

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: seamless_database_pool
 version: !ruby/object:Gem::Version 
-  hash: 5
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 9
-  version: 1.0.9
+  version: 1.0.10
 platform: ruby
 authors: 
 - Brian Durand
@@ -15,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-20 00:00:00 -05:00
+date: 2011-10-06 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,11 +21,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 2
-        - 2
         version: 2.2.2
   type: :runtime
   version_requirements: *id001
@@ -42,10 +32,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 0
         version: "2.0"
   type: :development
   version_requirements: *id002
@@ -57,12 +43,42 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
 description: 
 email: brian@embellishedvisions.com
 executables: []
@@ -105,25 +121,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Add support for master/slave database clusters in ActiveRecord to improve performance.
-test_files: []
-
+test_files: 
+- spec/connection_adapters_spec.rb
+- spec/connection_statistics_spec.rb
+- spec/controller_filter_spec.rb
+- spec/seamless_database_pool_adapter_spec.rb
+- spec/seamless_database_pool_spec.rb
+- spec/spec_helper.rb
+- spec/test_adapter/active_record/connection_adapters/read_only_adapter.rb
+- spec/test_model.rb