seamless_database_pool 1.0.6 → 1.0.7

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -7,11 +7,10 @@ desc 'Default: run unit tests.'
 task :default => :test
 
 begin
-  require 'spec/rake/spectask'
-  desc 'Test seamless_database_pool.'
-  Spec::Rake::SpecTask.new(:test) do |t|
-    t.spec_files = FileList.new('spec/**/*_spec.rb')
-  end
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
   
   namespace :test do
     desc "Run all tests including for all database adapters"
@@ -38,8 +37,8 @@ begin
     
     namespace :adapters do
       desc "Internal task to run database adapter tests"
-      Spec::Rake::SpecTask.new(:specified) do |t|
-        t.spec_files = FileList.new('spec/connection_adapters_spec.rb')
+      RSpec::Core::RakeTask.new(:specified) do |t|
+        t.pattern = FileList.new('spec/connection_adapters_spec.rb')
       end
       
       YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.each do |adapter_name|
@@ -58,7 +57,7 @@ begin
   end
 rescue LoadError
   task :test do
-    STDERR.puts "You must have rspec >= 1.3.0 to run the tests"
+    STDERR.puts "You must have rspec >= 2.0 to run the tests"
   end
 end
 
@@ -80,10 +79,10 @@ begin
     gem.authors = ["Brian Durand"]
     gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile"].to_a
     gem.has_rdoc = true
-    gem.extra_rdoc_files = ["README.rdoc"]
+    gem.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
   
     gem.add_dependency('activerecord', '>= 2.2.2')
-    gem.add_development_dependency('rspec', '>= 1.2.9')
+    gem.add_development_dependency('rspec', '>= 2.0')
     gem.add_development_dependency('jeweler')
   end
 

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -1,46 +1,53 @@
 module ActiveRecord
   class Base
     class << self
-      def seamless_database_pool_connection (config)
+      def seamless_database_pool_connection(config)
         pool_weights = {}
-      
+
         config = config.with_indifferent_access
         default_config = {:pool_weight => 1}.merge(config.merge(:adapter => config[:pool_adapter])).with_indifferent_access
         default_config.delete(:master)
         default_config.delete(:read_pool)
         default_config.delete(:pool_adapter)
-      
+
         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 = []
         config[:read_pool].each do |read_config|
           read_config = default_config.merge(read_config).with_indifferent_access
           read_config[:pool_weight] = read_config[:pool_weight].to_i
           if read_config[:pool_weight] > 0
-            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]
+            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
+              if logger
+                logger.error("Error connecting to read connection #{read_config.inspect}")
+                logger.error(e)
+              end
+            end
           end
         end if config[:read_pool]
-      
+
         @seamless_database_pool_classes ||= {}
         klass = @seamless_database_pool_classes[master_connection.class]
         unless klass
           klass = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
           @seamless_database_pool_classes[master_connection.class] = klass
         end
-      
+
         return klass.new(nil, logger, master_connection, read_connections, pool_weights)
       end
-    
+
       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'
@@ -65,7 +72,7 @@ module ActiveRecord
     end
     
     module SeamlessDatabasePoolBehavior
-      def self.included (base)
+      def self.included(base)
         base.alias_method_chain(:reload, :seamless_database_pool)
       end
       
@@ -86,7 +93,7 @@ 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)
+      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 = []
@@ -131,7 +138,7 @@ module ActiveRecord
         return klass
       end
       
-      def initialize (connection, logger, master_connection, read_connections, pool_weights)
+      def initialize(connection, logger, master_connection, read_connections, pool_weights)
         super(connection, logger)
         
         @master_connection = master_connection
@@ -164,35 +171,37 @@ module ActiveRecord
       
       def active?
         active = true
-        all_connections.each{|conn| active &= conn.active?}
+        do_to_connections {|conn| active &= conn.active?}
         return active
       end
-      
+
       def reconnect!
-        all_connections.each{|conn| conn.reconnect!}
+        do_to_connections {|conn| conn.reconnect!}
       end
-      
+
       def disconnect!
-        all_connections.each{|conn| conn.disconnect!}
+        do_to_connections {|conn| conn.disconnect!}
       end
-      
+
       def reset!
-        all_connections.each{|conn| conn.reset!}
+        do_to_connections {|conn| conn.reset!}
       end
-      
+
       def verify!(*ignored)
-        all_connections.each{|conn| conn.verify!(*ignored)}
+        do_to_connections {|conn| conn.verify!(*ignored)}
       end
-      
+
       def reset_runtime
-        all_connections.inject(0.0){|total, conn| total += conn.reset_runtime}
+        total = 0.0
+        do_to_connections {|conn| total += conn.reset_runtime}
+        total
       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.
       def random_read_connection
         weighted_read_connections = available_read_connections
-        if @use_master or weighted_read_connections.empty?
+        if @use_master || weighted_read_connections.empty?
           return master_connection
         else
           weighted_read_connections[rand(weighted_read_connections.length)]
@@ -235,9 +244,9 @@ module ActiveRecord
         end
         
         def expired?
-          @expires <= Time.now if @expires
+          @expires ? @expires <= Time.now : false
         end
-        
+
         def reconnect!
           failed_connection.reconnect!
           raise DatabaseConnectionError.new unless failed_connection.active?
@@ -251,13 +260,23 @@ module ActiveRecord
         available = @available_read_connections.last
         if available.expired?
           begin
-            available.reconnect!# unless available.active?
-          rescue
+            @logger.info("Adding dead database connection back to the pool: #{available.inspect}") if @logger
+            available.reconnect!
+          rescue => e
             # Couldn't reconnect so try again in a little bit
+            if @logger
+              @logger.warn("Failed to reconnect with: #{available.inspect}")
+              @logger.warn(e)
+            end
             available.expires = 30.seconds.from_now
             return available.connections
           end
+          
+          # If reconnect is successful, the connection will have been re-added to @available_read_connections list,
+          # so let's pop this old version of the connection
           @available_read_connections.pop
+          
+          # Now we'll try again after either expiring our bad connection or re-adding our good one
           return available_read_connections
         else
           return available.connections
@@ -274,17 +293,19 @@ module ActiveRecord
       end
       
       # Temporarily remove a connection from the read pool.
-      def suppress_read_connection (conn, expire)
+      def suppress_read_connection(conn, expire)
         available = available_read_connections
         connections = available.reject{|c| c == conn}
-        
+
         # This wasn't a read connection so don't suppress it
         return if connections.length == available.length
-        
+
         if connections.empty?
+          @logger.warn("All read connections are marked dead; trying them all again.") if @logger
           # No connections available so we might as well try them all again
           reset_available_read_connections
         else
+          @logger.warn("Removing #{conn.inspect} from the connection pool for #{expire} seconds") if @logger
           # Available connections will now not include the suppressed connection for a while
           @available_read_connections.push(AvailableConnections.new(connections, conn, expire.seconds.from_now))
         end
@@ -292,13 +313,13 @@ module ActiveRecord
       
       private
       
-      def proxy_connection_method (connection, method, proxy_type, *args, &block)
+      def proxy_connection_method(connection, method, proxy_type, *args, &block)
         begin
           connection.send(method, *args, &block)
         rescue => e
           # If the statement was a read statement and it wasn't forced against the master connection
           # try to reconnect if the connection is dead and then re-run the statement.
-          if proxy_type == :read and !using_master_connection?
+          if proxy_type == :read && !using_master_connection?
             unless connection.active?
               suppress_read_connection(connection, 30)
               connection = current_read_connection
@@ -310,7 +331,18 @@ module ActiveRecord
           end
         end
       end
-      
+
+      # Yield a block to each connection in the pool. If the connection is dead, ignore the error
+      # unless it is the master connection
+      def do_to_connections
+        all_connections.each do |conn|
+          begin
+            yield(conn)
+          rescue => e
+            raise e if conn == master_connection
+          end
+        end
+      end
     end
   end
 end

data/lib/seamless_database_pool/arel_compiler.rb

@@ -2,7 +2,7 @@ module Arel
   module SqlCompiler
     # Hook into arel to use the compiler used by the master connection.
     class Seamless_Database_PoolCompiler < GenericCompiler
-      def self.new (relation)
+      def self.new(relation)
         @compiler_classes ||= {}
         master_adapter = relation.engine.connection.master_connection.adapter_name
         compiler_class = @compiler_classes[master_adapter]

data/lib/seamless_database_pool/connect_timeout.rb

@@ -1,3 +1,5 @@
+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
@@ -5,7 +7,7 @@ module SeamlessDatabasePool
   module ConnectTimeout
     attr_accessor :connect_timeout
     
-    def self.included (base)
+    def self.included(base)
       base.alias_method_chain :reconnect!, :connect_timeout
     end
     
@@ -14,8 +16,8 @@ module SeamlessDatabasePool
         timeout(connect_timeout || 1) do
           reconnect_without_connect_timeout!
         end
-      rescue TimeoutError
-        raise "reconnect timed out"
+      rescue Timeout::Error
+        raise ActiveRecord::ConnectionTimeoutError.new("reconnect timed out")
       end
     end
   end

data/lib/seamless_database_pool/connection_statistics.rb

@@ -3,7 +3,7 @@ module SeamlessDatabasePool
   # and it will keep track of how often each connection calls update, insert, execute,
   # or select.
   module ConnectionStatistics
-    def self.included (base)
+    def self.included(base)
       base.alias_method_chain(:update, :connection_statistics)
       base.alias_method_chain(:insert, :connection_statistics)
       base.alias_method_chain(:execute, :connection_statistics)
@@ -19,19 +19,19 @@ module SeamlessDatabasePool
       @connection_statistics = {}
     end
   
-    def update_with_connection_statistics (sql, name = nil)
+    def update_with_connection_statistics(sql, name = nil)
       increment_connection_statistic(:update) do
         update_without_connection_statistics(sql, name)
       end
     end
   
-    def insert_with_connection_statistics (sql, name = nil)
+    def insert_with_connection_statistics(sql, name = nil)
       increment_connection_statistic(:insert) do
         insert_without_connection_statistics(sql, name)
       end
     end
   
-    def execute_with_connection_statistics (sql, name = nil)
+    def execute_with_connection_statistics(sql, name = nil)
       increment_connection_statistic(:execute) do
         execute_without_connection_statistics(sql, name)
       end
@@ -39,13 +39,13 @@ module SeamlessDatabasePool
   
     protected
   
-    def select_with_connection_statistics (sql, name = nil)
+    def select_with_connection_statistics(sql, name = nil)
       increment_connection_statistic(:select) do
         select_without_connection_statistics(sql, name)
       end
     end
   
-    def increment_connection_statistic (method)
+    def increment_connection_statistic(method)
       if @counting_pool_statistics
         yield
       else

data/lib/seamless_database_pool/controller_filter.rb

@@ -13,11 +13,15 @@ module SeamlessDatabasePool
   #     ...
   
   module ControllerFilter    
-    def self.included (base)
+    def self.included(base)
       unless base.respond_to?(:use_database_pool)
         base.extend(ClassMethods)
         base.class_eval do
-          alias_method_chain :perform_action, :seamless_database_pool
+          if base.method_defined?(:perform_action) || base.private_method_defined?(:perform_action)
+            alias_method_chain :perform_action, :seamless_database_pool
+          else
+            alias_method_chain :process, :seamless_database_pool
+          end
           alias_method_chain :redirect_to, :seamless_database_pool
         end
       end
@@ -40,7 +44,7 @@ module SeamlessDatabasePool
       # The configuration is inherited from parent controller classes, so if you have default
       # behavior, you should simply specify it in ApplicationController to have it available
       # globally.
-      def use_database_pool (options)
+      def use_database_pool(options)
         remapped_options = seamless_database_pool_options
         options.each_pair do |actions, connection_method|
           unless SeamlessDatabasePool::READ_CONNECTION_METHODS.include?(connection_method)
@@ -69,28 +73,45 @@ module SeamlessDatabasePool
       self.class.seamless_database_pool_options
     end
     
-    def perform_action_with_seamless_database_pool
+    # Rails 3.x hook for setting the read connection for the request.
+    def process_with_seamless_database_pool(action, *args)
+      set_read_only_connection_for_block(action) do
+        process_without_seamless_database_pool(action, *args)
+      end
+    end
+    
+    def redirect_to_with_seamless_database_pool(options = {}, response_status = {})
+      if SeamlessDatabasePool.read_only_connection_type(nil) == :master
+        use_master_db_connection_on_next_request
+      end
+      redirect_to_without_seamless_database_pool(options, response_status)
+    end
+    
+    private
+    
+    # Rails 2.x hook for setting the read connection for the request.
+    def perform_action_with_seamless_database_pool(*args)
+      set_read_only_connection_for_block(action_name) do
+        perform_action_without_seamless_database_pool(*args)
+      end
+    end
+    
+    # Set the read only connection for a block. Used to set the connection for a controller action.
+    def set_read_only_connection_for_block(action)
       read_pool_method = nil
       if session
         read_pool_method = session[:next_request_db_connection]
         session[:next_request_db_connection] = nil
       end
       
-      read_pool_method ||= seamless_database_pool_options[action_name.to_sym] || seamless_database_pool_options[:all]
+      read_pool_method ||= seamless_database_pool_options[action.to_sym] || seamless_database_pool_options[:all]
       if read_pool_method
         SeamlessDatabasePool.set_read_only_connection_type(read_pool_method) do
-          perform_action_without_seamless_database_pool
+          yield
         end
       else
-        perform_action_without_seamless_database_pool
-      end
-    end
-    
-    def redirect_to_with_seamless_database_pool (options = {}, response_status = {})
-      if SeamlessDatabasePool.read_only_connection_type(nil) == :master
-        use_master_db_connection_on_next_request
+        yield
       end
-      redirect_to_without_seamless_database_pool(options, response_status)
     end
   end
 end

data/lib/seamless_database_pool.rb

@@ -63,7 +63,7 @@ module SeamlessDatabasePool
     end
   
     # Set the read only connection type to either :master, :random, or :persistent.
-    def set_read_only_connection_type (connection_type)
+    def set_read_only_connection_type(connection_type)
       saved_connection = Thread.current[:read_only_connection]
       retval = nil
       begin
@@ -77,14 +77,14 @@ module SeamlessDatabasePool
     end
   
     # Get the read only connection type currently in use. Will be one of :master, :random, or :persistent.
-    def read_only_connection_type (default = :master)
+    def read_only_connection_type(default = :master)
       connection_type = Thread.current[:read_only_connection] || default
       connection_type = :persistent if connection_type.kind_of?(Hash)
       return connection_type
     end
   
     # Get a read only connection from a connection pool.
-    def read_only_connection (pool_connection)
+    def read_only_connection(pool_connection)
       return pool_connection.master_connection if pool_connection.using_master_connection?
       connection_type = Thread.current[:read_only_connection]
     
@@ -103,7 +103,7 @@ module SeamlessDatabasePool
     end
   
     # This method is provided as a way to change the persistent connection when it fails and a new one is substituted.
-    def set_persistent_read_connection (pool_connection, read_connection)
+    def set_persistent_read_connection(pool_connection, read_connection)
       connection_type = Thread.current[:read_only_connection]
       connection_type[pool_connection] = read_connection if connection_type.kind_of?(Hash)
     end

data/spec/{filter_spec.rb → controller_filter_spec.rb}

@@ -1,20 +1,17 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-require 'cgi'
 
 describe "SeamlessDatabasePool::ControllerFilter" do
   
   module SeamlessDatabasePool
     class TestApplicationController
-      attr_reader :action_name, :session
+      attr_reader :session
       
-      def initialize(action, session = nil)
-        @action_name = action
-        session ||= {}
+      def initialize(session)
         @session = session
       end
       
-      def perform_action
-        send action_name
+      def process(action, *args)
+        send action
       end
       
       def redirect_to (options = {}, response_status = {})
@@ -59,78 +56,95 @@ describe "SeamlessDatabasePool::ControllerFilter" do
         redirect_to(:action => :read)
       end
     end
+  
+    class TestRails2ApplicationController < TestApplicationController
+      attr_reader :action_name
+    
+      def process(action, *args)
+        @action_name = action
+        perform_action
+      end
+    
+      private
+    
+      def perform_action
+        send action_name
+      end
+    end
+  
+    class TestRails2BaseController < TestRails2ApplicationController
+      include ::SeamlessDatabasePool::ControllerFilter
+
+      use_database_pool :read => :persistent
+    
+      def read
+        ::SeamlessDatabasePool.read_only_connection_type
+      end
+    end
   end
   
+  let(:session){Hash.new}
+  let(:controller){SeamlessDatabasePool::TestOtherController.new(session)}
+  
   it "should work with nothing set" do
-    controller = SeamlessDatabasePool::TestApplicationController.new('base_action')
-    controller.perform_action.should == :master
+    controller = SeamlessDatabasePool::TestApplicationController.new(session)
+    controller.process('base_action').should == :master
   end
   
   it "should allow setting a connection type for a single action" do
-    controller = SeamlessDatabasePool::TestBaseController.new('read')
-    controller.perform_action.should == :persistent
+    controller = SeamlessDatabasePool::TestBaseController.new(session)
+    controller.process('read').should == :persistent
   end
   
   it "should allow setting a connection type for actions" do
-    controller = SeamlessDatabasePool::TestOtherController.new('edit')
-    controller.perform_action.should == :master
-    controller = SeamlessDatabasePool::TestOtherController.new('save')
-    controller.perform_action.should == :master
+    controller.process('edit').should == :master
+    controller.process('save').should == :master
   end
   
   it "should allow setting a connection type for all actions" do
-    controller = SeamlessDatabasePool::TestOtherController.new('other')
-    controller.perform_action.should == :random
+    controller.process('other').should == :random
   end
   
   it "should inherit the superclass' options" do
-    controller = SeamlessDatabasePool::TestOtherController.new('read')
-    controller.perform_action.should == :persistent
+    controller.process('read').should == :persistent
   end
   
   it "should be able to force using the master connection on the next request" do
-    session = {}
-    
     # First request
-    controller = SeamlessDatabasePool::TestOtherController.new('read', session)
-    controller.perform_action.should == :persistent
+    controller.process('read').should == :persistent
     controller.use_master_db_connection_on_next_request
     
     # Second request
-    controller = SeamlessDatabasePool::TestOtherController.new('read', session)
-    controller.perform_action.should == :master
+    controller.process('read').should == :master
     
     # Third request
-    controller = SeamlessDatabasePool::TestOtherController.new('read', session)
-    controller.perform_action.should == :persistent
+    controller.process('read').should == :persistent
   end
   
   it "should not break trying to force the master connection if sessions are not enabled" do
-    controller = SeamlessDatabasePool::TestOtherController.new('read', nil)
-    controller.perform_action.should == :persistent
+    controller.process('read').should == :persistent
     controller.use_master_db_connection_on_next_request
     
     # Second request
-    controller = SeamlessDatabasePool::TestOtherController.new('read', nil)
-    controller.perform_action.should == :persistent
+    session.clear
+    controller.process('read').should == :persistent
   end
   
   it "should force the master connection on the next request for a redirect in master connection block" do
-    session = {}
-    controller = SeamlessDatabasePool::TestOtherController.new('redirect_master_action', session)
-    controller.perform_action.should == {:action => :read}
+    controller = SeamlessDatabasePool::TestOtherController.new(session)
+    controller.process('redirect_master_action').should == {:action => :read}
     
-    controller = SeamlessDatabasePool::TestOtherController.new('read', session)
-    controller.perform_action.should == :master
+    controller.process('read').should == :master
   end
 
   it "should not force the master connection on the next request for a redirect not in master connection block" do
-    session = {}
-    controller = SeamlessDatabasePool::TestOtherController.new('redirect_read_action', session)
-    controller.perform_action.should == {:action => :read}
+    controller.process('redirect_read_action').should == {:action => :read}
     
-    controller = SeamlessDatabasePool::TestOtherController.new('read', session)
-    controller.perform_action.should == :persistent
+    controller.process('read').should == :persistent
   end
   
+  it "should work with a Rails 2 controller" do
+    controller = SeamlessDatabasePool::TestRails2BaseController.new(session)
+    controller.process('read').should == :persistent
+  end
 end

data/spec/seamless_database_pool_adapter_spec.rb

@@ -11,7 +11,7 @@ module SeamlessDatabasePool
     end
     
     def reconnect!
-      sleep(0.25)
+      sleep(0.1)
     end
   end
   
@@ -68,60 +68,60 @@ describe "SeamlessDatabasePoolAdapter ActiveRecord::Base extension" do
 end
 
 describe "SeamlessDatabasePoolAdapter" do
-    
-  before(:each) do
-    @master_connection = SeamlessDatabasePool::MockMasterConnection.new("master")
-    @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}
-    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)
+  
+  let(:master_connection){ SeamlessDatabasePool::MockMasterConnection.new("master") }
+  let(:read_connection_1){ SeamlessDatabasePool::MockConnection.new("read_1") }
+  let(:read_connection_2){ SeamlessDatabasePool::MockConnection.new("read_2") }
+  let(:pool_connection) do
+    weights = {master_connection => 1, read_connection_1 => 1, read_connection_2 => 2}
+    connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
+    connection_class.new(nil, nil, master_connection, [read_connection_1, read_connection_2], weights)
   end
   
   context "selecting a connection from the pool" do
     it "should initialize the connection pool" do
-      @pool_connection.master_connection.should == @master_connection
-      @pool_connection.read_connections.should == [@read_connection_1, @read_connection_2]
-      @pool_connection.all_connections.should == [@master_connection, @read_connection_1, @read_connection_2]
-      @pool_connection.pool_weight(@master_connection).should == 1
-      @pool_connection.pool_weight(@read_connection_1).should == 1
-      @pool_connection.pool_weight(@read_connection_2).should == 2
+      pool_connection.master_connection.should == master_connection
+      pool_connection.read_connections.should == [read_connection_1, read_connection_2]
+      pool_connection.all_connections.should == [master_connection, read_connection_1, read_connection_2]
+      pool_connection.pool_weight(master_connection).should == 1
+      pool_connection.pool_weight(read_connection_1).should == 1
+      pool_connection.pool_weight(read_connection_2).should == 2
     end
   
     it "should return the current read connection" do
-      SeamlessDatabasePool.should_receive(:read_only_connection).with(@pool_connection).and_return(:current)
-      @pool_connection.current_read_connection.should == :current
+      SeamlessDatabasePool.should_receive(:read_only_connection).with(pool_connection).and_return(:current)
+      pool_connection.current_read_connection.should == :current
     end
   
     it "should select a random read connection" do
       mock_connection = stub(:connection, :active? => true)
-      @pool_connection.should_receive(:available_read_connections).and_return([:fake1, :fake2, mock_connection])
-      @pool_connection.should_receive(:rand).with(3).and_return(2)
-      @pool_connection.random_read_connection.should == mock_connection
+      pool_connection.should_receive(:available_read_connections).and_return([:fake1, :fake2, mock_connection])
+      pool_connection.should_receive(:rand).with(3).and_return(2)
+      pool_connection.random_read_connection.should == mock_connection
     end
   
     it "should select the master connection if the read pool is empty" do
-      @pool_connection.should_receive(:available_read_connections).and_return([])
-      @pool_connection.random_read_connection.should == @master_connection
+      pool_connection.should_receive(:available_read_connections).and_return([])
+      pool_connection.random_read_connection.should == master_connection
     end
   
     it "should use the master connection in a block" 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})
-      connection.random_read_connection.should == @read_connection_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
+        connection.random_read_connection.should == master_connection
       end
-      connection.random_read_connection.should == @read_connection_1
+      connection.random_read_connection.should == read_connection_1
     end
   
     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(: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)
+      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(: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)
     
       SeamlessDatabasePool.use_persistent_read_connection do
         connection.send(:select, 'SQL 1', nil)
@@ -135,87 +135,87 @@ describe "SeamlessDatabasePoolAdapter" do
   
   context "read connection methods" do
     it "should proxy select methods to a read connection" do
-      @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-      @read_connection_1.should_receive(:select).with('SQL').and_return(:retval)
-      @pool_connection.send(:select, 'SQL').should == :retval
+      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
+      read_connection_1.should_receive(:select).with('SQL').and_return(:retval)
+      pool_connection.send(:select, 'SQL').should == :retval
     end
   
     it "should proxy execute methods to a read connection" do
-      @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-      @read_connection_1.should_receive(:execute).with('SQL').and_return(:retval)
-      @pool_connection.execute('SQL').should == :retval
+      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
+      read_connection_1.should_receive(:execute).with('SQL').and_return(:retval)
+      pool_connection.execute('SQL').should == :retval
     end
   
     it "should proxy select_rows methods to a read connection" do
-      @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-      @read_connection_1.should_receive(:select_rows).with('SQL').and_return(:retval)
-      @pool_connection.select_rows('SQL').should == :retval
+      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
+      read_connection_1.should_receive(:select_rows).with('SQL').and_return(:retval)
+      pool_connection.select_rows('SQL').should == :retval
     end
   end
   
   context "master connection methods" do
     it "should proxy insert method to the master connection" do
-      @master_connection.should_receive(:insert).with('SQL').and_return(:retval)
-      @pool_connection.insert('SQL').should == :retval
+      master_connection.should_receive(:insert).with('SQL').and_return(:retval)
+      pool_connection.insert('SQL').should == :retval
     end
   
     it "should proxy update method to the master connection" do
-      @master_connection.should_receive(:update).with('SQL').and_return(:retval)
-      @pool_connection.update('SQL').should == :retval
+      master_connection.should_receive(:update).with('SQL').and_return(:retval)
+      pool_connection.update('SQL').should == :retval
     end
   
     it "should proxy columns method to the master connection" do
-      @master_connection.should_receive(:columns).with(:table).and_return(:retval)
-      @pool_connection.columns(:table).should == :retval
+      master_connection.should_receive(:columns).with(:table).and_return(:retval)
+      pool_connection.columns(:table).should == :retval
     end
   end
   
   context "fork to all connections" do
     it "should fork active? to all connections and return true if all are up" do
-      @master_connection.should_receive(:active?).and_return(true)
-      @read_connection_1.should_receive(:active?).and_return(true)
-      @read_connection_2.should_receive(:active?).and_return(true)
-      @pool_connection.active?.should == true
+      master_connection.should_receive(:active?).and_return(true)
+      read_connection_1.should_receive(:active?).and_return(true)
+      read_connection_2.should_receive(:active?).and_return(true)
+      pool_connection.active?.should == true
     end
   
     it "should fork active? to all connections and return false if one is down" do
-      @master_connection.should_receive(:active?).and_return(true)
-      @read_connection_1.should_receive(:active?).and_return(true)
-      @read_connection_2.should_receive(:active?).and_return(false)
-      @pool_connection.active?.should == false
+      master_connection.should_receive(:active?).and_return(true)
+      read_connection_1.should_receive(:active?).and_return(true)
+      read_connection_2.should_receive(:active?).and_return(false)
+      pool_connection.active?.should == false
     end
   
     it "should fork verify! to all connections" do
-      @master_connection.should_receive(:verify!).with(5)
-      @read_connection_1.should_receive(:verify!).with(5)
-      @read_connection_2.should_receive(:verify!).with(5)
-      @pool_connection.verify!(5)
+      master_connection.should_receive(:verify!).with(5)
+      read_connection_1.should_receive(:verify!).with(5)
+      read_connection_2.should_receive(:verify!).with(5)
+      pool_connection.verify!(5)
     end
   
     it "should fork disconnect! to all connections" do
-      @master_connection.should_receive(:disconnect!)
-      @read_connection_1.should_receive(:disconnect!)
-      @read_connection_2.should_receive(:disconnect!)
-      @pool_connection.disconnect!
+      master_connection.should_receive(:disconnect!)
+      read_connection_1.should_receive(:disconnect!)
+      read_connection_2.should_receive(:disconnect!)
+      pool_connection.disconnect!
     end
   
     it "should fork reconnect! to all connections" do
-      @master_connection.should_receive(:reconnect!)
-      @read_connection_1.should_receive(:reconnect!)
-      @read_connection_2.should_receive(:reconnect!)
-      @pool_connection.reconnect!
+      master_connection.should_receive(:reconnect!)
+      read_connection_1.should_receive(:reconnect!)
+      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.1
-      lambda{@pool_connection.reconnect!}.should raise_error("reconnect timed out")
+      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)
-      @read_connection_2.should_receive(:reset_runtime).and_return(3)
-      @pool_connection.reset_runtime.should == 6
+      master_connection.should_receive(:reset_runtime).and_return(1)
+      read_connection_1.should_receive(:reset_runtime).and_return(2)
+      read_connection_2.should_receive(:reset_runtime).and_return(3)
+      pool_connection.reset_runtime.should == 6
     end
   end
 
@@ -223,135 +223,135 @@ describe "SeamlessDatabasePoolAdapter" do
     it "should proxy requests to a connection" do
       args = [:arg1, :arg2]
       block = Proc.new{}
-      @master_connection.should_receive(:select_value).with(*args, &block)
-      @master_connection.should_not_receive(:active?)
-      @master_connection.should_not_receive(:reconnect!)
-      @pool_connection.send(:proxy_connection_method, @master_connection, :select_value, :master, *args, &block)
+      master_connection.should_receive(:select_value).with(*args, &block)
+      master_connection.should_not_receive(:active?)
+      master_connection.should_not_receive(:reconnect!)
+      pool_connection.send(:proxy_connection_method, master_connection, :select_value, :master, *args, &block)
     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.should_receive(:active?).and_return(false, false, true)
-      @master_connection.should_receive(:reconnect!)
+      master_connection.stub!(:select_value).and_raise("SQL ERROR")
+      master_connection.should_receive(:active?).and_return(false, false, true)
+      master_connection.should_receive(:reconnect!)
       now = Time.now
-      lambda{@pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
+      lambda{pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
       Time.stub!(:now).and_return(now + 31)
-      lambda{@pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
+      lambda{pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
     end
   
     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(: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")
+      master_connection.should_receive(:select_value).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")
     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_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")
+      master_connection.should_receive(:select_value).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")
     end
   
     it "should try to execute a read statement again after a connection error" do
       connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
-      @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-      @read_connection_1.should_receive(:select).with('SQL').and_raise(connection_error)
-      @read_connection_1.should_receive(:active?).and_return(true)
-      @pool_connection.should_not_receive(:suppress_read_connection)
+      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
+      read_connection_1.should_receive(:select).with('SQL').and_raise(connection_error)
+      read_connection_1.should_receive(:active?).and_return(true)
+      pool_connection.should_not_receive(:suppress_read_connection)
       SeamlessDatabasePool.should_not_receive(:set_persistent_read_connection)
-      @read_connection_1.should_receive(:select).with('SQL').and_return(:results)
-      @pool_connection.send(:select, 'SQL').should == :results
+      read_connection_1.should_receive(:select).with('SQL').and_return(:results)
+      pool_connection.send(:select, 'SQL').should == :results
     end
   
     it "should not try to execute a read statement again after a connection error if the master connection must be used" do
-      @master_connection.should_receive(:select).with('SQL').and_raise("Fail")
-      @pool_connection.use_master_connection do
-        lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("Fail")
+      master_connection.should_receive(:select).with('SQL').and_raise("Fail")
+      pool_connection.use_master_connection do
+        lambda{pool_connection.send(:select, 'SQL')}.should raise_error("Fail")
       end
     end
   
     it "should not try to execute a read statement again after a non-connection error" do
-      @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-      @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :read, 'SQL').and_raise("SQL Error")
-      lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("SQL Error")
+      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
+      pool_connection.should_receive(:proxy_connection_method).with(read_connection_1, :select, :read, 'SQL').and_raise("SQL Error")
+      lambda{pool_connection.send(:select, 'SQL')}.should raise_error("SQL Error")
     end
   
     it "should use a different connection on a retry if the original connection could not be reconnected" do
-      @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1, @read_connection_2)
-      @read_connection_1.should_receive(:select).with('SQL').and_raise("Fail")
-      @read_connection_1.should_receive(:active?).and_return(false)
-      @pool_connection.should_receive(:suppress_read_connection).with(@read_connection_1, 30)
-      SeamlessDatabasePool.should_receive(:set_persistent_read_connection).with(@pool_connection, @read_connection_2)
-      @read_connection_2.should_receive(:select).with('SQL').and_return(:results)
-      @pool_connection.send(:select, 'SQL').should == :results
+      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1, read_connection_2)
+      read_connection_1.should_receive(:select).with('SQL').and_raise("Fail")
+      read_connection_1.should_receive(:active?).and_return(false)
+      pool_connection.should_receive(:suppress_read_connection).with(read_connection_1, 30)
+      SeamlessDatabasePool.should_receive(:set_persistent_read_connection).with(pool_connection, read_connection_2)
+      read_connection_2.should_receive(:select).with('SQL').and_return(:results)
+      pool_connection.send(:select, 'SQL').should == :results
     end
   
     it "should keep track of read connections that can't be reconnected for a set period" do
-      @pool_connection.available_read_connections.should include(@read_connection_1)
-      @pool_connection.suppress_read_connection(@read_connection_1, 30)
-      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+      pool_connection.available_read_connections.should include(read_connection_1)
+      pool_connection.suppress_read_connection(read_connection_1, 30)
+      pool_connection.available_read_connections.should_not include(read_connection_1)
     end
   
     it "should return dead connections to the pool after the timeout has expired" do
-      @pool_connection.available_read_connections.should include(@read_connection_1)
-      @pool_connection.suppress_read_connection(@read_connection_1, 0.2)
-      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+      pool_connection.available_read_connections.should include(read_connection_1)
+      pool_connection.suppress_read_connection(read_connection_1, 0.2)
+      pool_connection.available_read_connections.should_not include(read_connection_1)
       sleep(0.3)
-      @pool_connection.available_read_connections.should include(@read_connection_1)
+      pool_connection.available_read_connections.should include(read_connection_1)
     end
   
     it "should not return a connection to the pool until it can be reconnected" do
-      @pool_connection.available_read_connections.should include(@read_connection_1)
-      @pool_connection.suppress_read_connection(@read_connection_1, 0.2)
-      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+      pool_connection.available_read_connections.should include(read_connection_1)
+      pool_connection.suppress_read_connection(read_connection_1, 0.2)
+      pool_connection.available_read_connections.should_not include(read_connection_1)
       sleep(0.3)
-      @read_connection_1.should_receive(:reconnect!)
-      @read_connection_1.should_receive(:active?).and_return(false)
-      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+      read_connection_1.should_receive(:reconnect!)
+      read_connection_1.should_receive(:active?).and_return(false)
+      pool_connection.available_read_connections.should_not include(read_connection_1)
     end
   
     it "should try all connections again if none of them can be reconnected" do
-      stack = @pool_connection.instance_variable_get(:@available_read_connections)
+      stack = pool_connection.instance_variable_get(:@available_read_connections)
     
-      available = @pool_connection.available_read_connections
-      available.should include(@read_connection_1)
-      available.should include(@read_connection_2)
-      available.should include(@master_connection)
+      available = pool_connection.available_read_connections
+      available.should include(read_connection_1)
+      available.should include(read_connection_2)
+      available.should include(master_connection)
       stack.size.should == 1
     
-      @pool_connection.suppress_read_connection(@read_connection_1, 30)
-      available = @pool_connection.available_read_connections
-      available.should_not include(@read_connection_1)
-      available.should include(@read_connection_2)
-      available.should include(@master_connection)
+      pool_connection.suppress_read_connection(read_connection_1, 30)
+      available = pool_connection.available_read_connections
+      available.should_not include(read_connection_1)
+      available.should include(read_connection_2)
+      available.should include(master_connection)
       stack.size.should == 2
     
-      @pool_connection.suppress_read_connection(@master_connection, 30)
-      available = @pool_connection.available_read_connections
-      available.should_not include(@read_connection_1)
-      available.should include(@read_connection_2)
-      available.should_not include(@master_connection)
+      pool_connection.suppress_read_connection(master_connection, 30)
+      available = pool_connection.available_read_connections
+      available.should_not include(read_connection_1)
+      available.should include(read_connection_2)
+      available.should_not include(master_connection)
       stack.size.should == 3
     
-      @pool_connection.suppress_read_connection(@read_connection_2, 30)
-      available = @pool_connection.available_read_connections
-      available.should include(@read_connection_1)
-      available.should include(@read_connection_2)
-      available.should include(@master_connection)
+      pool_connection.suppress_read_connection(read_connection_2, 30)
+      available = pool_connection.available_read_connections
+      available.should include(read_connection_1)
+      available.should include(read_connection_2)
+      available.should include(master_connection)
       stack.size.should == 1
     end
   
     it "should not try to suppress a read connection that wasn't available in the read pool" do
-      stack = @pool_connection.instance_variable_get(:@available_read_connections)
+      stack = pool_connection.instance_variable_get(:@available_read_connections)
       stack.size.should == 1
-      @pool_connection.suppress_read_connection(@read_connection_1, 30)
+      pool_connection.suppress_read_connection(read_connection_1, 30)
       stack.size.should == 2
-      @pool_connection.suppress_read_connection(@read_connection_1, 30)
+      pool_connection.suppress_read_connection(read_connection_1, 30)
       stack.size.should == 2
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: seamless_database_pool
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
+  hash: 25
+  prerelease: 
   segments: 
   - 1
   - 0
-  - 6
-  version: 1.0.6
+  - 7
+  version: 1.0.7
 platform: ruby
 authors: 
 - Brian Durand
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-20 00:00:00 -05:00
+date: 2011-06-23 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 13
+        hash: 3
         segments: 
-        - 1
         - 2
-        - 9
-        version: 1.2.9
+        - 0
+        version: "2.0"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -71,6 +70,7 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- MIT-LICENSE
 - README.rdoc
 files: 
 - README.rdoc
@@ -83,20 +83,21 @@ files:
 - lib/seamless_database_pool/controller_filter.rb
 - spec/connection_adapters_spec.rb
 - spec/connection_statistics_spec.rb
+- spec/controller_filter_spec.rb
 - spec/database.yml
-- spec/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
+- MIT-LICENSE
 has_rdoc: true
 homepage: http://github.com/bdurand/seamless_database_pool
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -120,16 +121,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Add support for master/slave database clusters in ActiveRecord to improve performance.
-test_files: 
-- spec/connection_adapters_spec.rb
-- spec/connection_statistics_spec.rb
-- spec/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
+test_files: []
+