Ticket #2162: connection_pool.rb

require 'monitor'

module ActiveRecord
  class ConnectionPool
    include MonitorMixin
    
    def initialize(prc)
      super()
      @prc = prc
      startup
    end
    
    def startup
      @min_size,@max_size = ActiveRecord::Base.pool_connections_min,ActiveRecord::Base.pool_connections_max
      @available_connections = []
      @acquired_connections = []
      @min_size.times { @available_connections << @prc.call }
      @cond_var ||= new_cond
      @use_check = 0
      @use_thread = Thread.new { reap_connections }
    end
    
    def shutdown
      synchronize do
        @cond_var.wait_until { @acquired_connections.size==0 }
        @available_connections.each do |c|
          c.close          
        end
        @available_connections = nil        
      end
      @use_thread.terminate
    end    
    private :startup, :shutdown
    
    def reset
      shutdown
      startup
    end
    
    def current_size
      return @available_connections.size + @acquired_connections.size
    end
    
    def reap_connections
      Base.logger.debug("starting reaper thread")
      loop do
        sleep(ActiveRecord::Base.pool_connections_reaper_period)
        synchronize do
          Base.logger.debug("use_check is #{@use_check}")
          if @use_check < current_size
            num_to_free = current_size - @use_check
            max_to_free = current_size-@min_size
            num_to_free = max_to_free if num_to_free > max_to_free
            Base.logger.debug("freeing #{num_to_free} connections")
            @available_connections[0...num_to_free].each do |conn|
              conn.close
              @available_connections.delete(conn)
            end
          end
        end
        @use_check=0
      end
    end
        
    def acquire_connection
      conn = nil
      synchronize do
        loop do
          if @available_connections.size > 0
            conn = @available_connections.shift
            break
          elsif (@max_size > 0 and current_size < @max_size) or @max_size==0
            conn = @prc.call
            break
          else
            if ActiveRecord::Base.pool_connections_wait
              @cond_var.wait
            else
              raise ActiveRecord::ConnectionNotEstablished
            end
          end  
        end
        @acquired_connections << conn
        @use_check=@acquired_connections.size if @acquired_connections.size > @use_check
        Base.logger.debug("current_size=" + current_size.to_s + " max_size=" + @max_size.to_s)
      end
      conn
    end
    
    def release_connection(conn)
      synchronize do
        @acquired_connections.delete(conn)
        @available_connections << conn
        @cond_var.signal
      end
    end
  end
end