class Net::HTTP::ConnectionPool

def _clean
  now = Time.now
  @pool.delete_if do |idle_session|
    if 
      idle_session.last_used_at.nil? or
      now - idle_session.last_used_at > idle_timeout
    then
      idle_session.finish
      true
    end
  end
end

def clean!
  @pool_mutex.synchronize { _clean }
end

def connection_for host, options = {}, &block
  connection = Connection.new(self, host, options)
  yield(connection) if block_given?
  connection
end

def empty!
  @pool_mutex.synchronize do
    @pool.each(&:finish)
    @pool = []
  end
end

def initialize options = {}
  @pool = []
  @pool_mutex = Mutex.new
  @open_timeout = options[:http_open_timeout] || 15
  @idle_timeout = options[:http_idle_timeout] || 60
  @log_wire_trace = !!options[:http_wire_trace]
  @logger = options[:logger] || Logger.new($stdout)
end

def request connection, *request_args, &block
  session = nil
  response = nil
  retried = false
  begin
    session = session_for(connection, retried)
    session.http_session.read_timeout = connection.read_timeout
    response = session.request(*request_args, &block)
  rescue Exception => error
    # close the http session to prevent the connection from being
    # left open and risk the other side sending data
    session.finish if session
    # retry socket errors once on a new session
    if SOCKET_ERRORS.include?(error.class) and !retried
      retried = true
      retry
    end
    raise error
  else
    @pool_mutex.synchronize { @pool << session }
  end
  response
end

def session_for connection, force_new = false
  session = nil
  unless force_new
    @pool_mutex.synchronize do
      _clean
      session = @pool.find{|idle_session| idle_session.key == connection.key }
      @pool.delete(session) if session
    end
  end
  if session.nil?
    logger = log_wire_trace? ? self.logger : nil 
    session = Session.for(connection, open_timeout, logger)
  end
  session
end

def size
  @pool_mutex.synchronize { @pool.size }  
end