class Net::HTTP::ConnectionPool::Connection

Represents a HTTP connection. Call {request} on a connection like you would with a Net::HTTPSession object.

Getting a Connection object

To get a connection object, you start with a connection pool:

pool = Net::HTTP::ConnectionPool.new
connection = pool.connection_for('domain.com')

{Net::HTTP::ConnectionPool#connection_for} accepts a number of options to control the connection settings (SSL, proxy, timeouts, etc).

Making Requests

Given a connection object, you call request. {#request} yields Net::HTTPResponse objects (when given a block). You should read the response (via body or read_body) before the end of the block.

connection.request(Net::HTTP::Get.new('/')) do |resp|
  puts resp.body
end

Attributes

host[R]

@return [String]

pool[R]

@return [ConnectionPool]

port[R]

@return [Integer]

proxy_address[R]

@return [String,nil]

proxy_password[R]

@return [String,nil]

proxy_port[R]

@return [Integer,nil]

proxy_user[R]

@return [String,nil]

read_timeout[RW]

@return [Numeric,nil]

ssl[R]

@return [Boolean]

ssl_ca_file[R]

@return [String,nil]

ssl_ca_path[R]

@return [String,nil]

ssl_verify_peer[R]

@return [Boolean]

Public Class Methods

new(pool, host, options = {}) click to toggle source

Use {Net::HTTP::ConnectionPool#connection_for} to construct {Connection} objects. @private

# File lib/net/http/connection_pool/connection.rb, line 46
def initialize pool, host, options = {}

  @pool = pool

  @host = host

  @port = options.key?(:port) ? options[:port] : (options[:ssl] ? 443 : 80)

  @ssl = options.key?(:ssl) ? options[:ssl] : (port == 443) 

  @ssl_verify_peer = options.key?(:ssl_verify_peer) ?
    options[:ssl_verify_peer] : true

  @ssl_ca_file = options[:ssl_ca_file]

  @ssl_ca_path = options[:ssl_ca_path]

  if uri = options[:proxy_uri]
    uri = URI.parse(uri) if uri.is_a?(String)
    @proxy_address = uri.host
    @proxy_port = uri.port
    @proxy_user = uri.user
    @proxy_password = uri.password
  else
    @proxy_address = options[:proxy_address]
    @proxy_port = options[:proxy_port]
    @proxy_user = options[:proxy_user]
    @proxy_password = options[:proxy_password]
  end

  @read_timeout = options[:read_timeout] || 60

end

Public Instance Methods

key() click to toggle source

@return [String] Returns a key that can be used to group connections

that may share the same HTTP sessions.
# File lib/net/http/connection_pool/connection.rb, line 178
def key
  @key ||= begin
    %w(
      host port
      ssl ssl_verify_peer ssl_ca_file ssl_ca_path
      proxy_address proxy_port proxy_user proxy_password
    ).map{|part| send(part).to_s }.join(":")
  end
end
proxy?() click to toggle source

@return [Boolean] Returns true if this connection proxies requests.

# File lib/net/http/connection_pool/connection.rb, line 128
def proxy?
  !!proxy_address
end
request(*args, &block) click to toggle source

Makes a single HTTP request. The Net::HTTPResponse is yielded to the given block.

pool = Net::HTTP::ConnectionPool.new
connection = pool.connection_for('www.google.com')

connection.request(Net::HTTP::Get.new('/')) do |response|
  # yeilds a Net::HTTPResponse object
  puts "STATUS CODE: #{response.code}"
  puts "HEADERS: #{response.to_hash.inspect}"
  puts "BODY:\n#{response.body}"
end

If you want to read the HTTP response body in chunks (useful for large responses you do not want to load into memory), you should pass a block to the read_body method of the yielded response.

File.open('output.txt', 'w') do |file|
  connection.request(Net::HTTP::Get.new('/')) do |response|
    response.read_body do |chunk|
      file.write(chunk)
    end
  end
end

If you omit the block when calling request, you will not be able to read the response. This method never returns the Net::HTTPResponse generated.

This method passes *args to Net::HTTPSession#request. See the Ruby standard lib documentation for more documentation about accepted arguments.

@note You should read the yielded response object before the end

of the passed block. Do no save a reference to yielded response
objects.

@yield [response] @yieldparam [Net::HTTPResponse] response @return [nil]

# File lib/net/http/connection_pool/connection.rb, line 172
def request *args, &block
  pool.request(self, *args, &block)
end
ssl?() click to toggle source

@return [Boolean] Returns true if this connection requires SSL.

# File lib/net/http/connection_pool/connection.rb, line 117
def ssl?
  @ssl
end
ssl_verify_peer?() click to toggle source

@return [Boolean] Returns true if ssl connections should verify the

peer certificate.
# File lib/net/http/connection_pool/connection.rb, line 123
def ssl_verify_peer?
  @ssl_verify_peer
end