class Net::HTTP

Class Net::HTTP provides a rich library that implements the client in a client-server model that uses the HTTP request-response protocol. For information about HTTP, see:

About the Examples

Examples here assume that net/http has been required (which also requires uri):

require 'net/http'

Many code examples here use these example websites:

Some examples also assume these variables:

uri = URI('https://jsonplaceholder.typicode.com/')
uri.freeze # Examples may not modify.
hostname = uri.hostname # => "jsonplaceholder.typicode.com"
path = uri.path         # => "/"
port = uri.port         # => 443

So that example requests may be written as:

Net::HTTP.get(uri)
Net::HTTP.get(hostname, '/index.html')
Net::HTTP.start(hostname) do |http|
  http.get('/todos/1')
  http.get('/todos/2')
end

An example that needs a modified URI first duplicates uri, then modifies the duplicate:

_uri = uri.dup
_uri.path = '/todos/1'

Strategies

The methods cited above are convenience methods that, via their few arguments, allow minimal control over the requests. For greater control, consider using request objects.

URIs

On the internet, a URI (Universal Resource Identifier) is a string that identifies a particular resource. It consists of some or all of: scheme, hostname, path, query, and fragment; see URI syntax.

A Ruby URI::Generic object represents an internet URI. It provides, among others, methods scheme, hostname, path, query, and fragment.

Schemes

An internet URI has a scheme.

The two schemes supported in Net::HTTP are 'https' and 'http':

uri.scheme                       # => "https"
URI('http://example.com').scheme # => "http"

Hostnames

A hostname identifies a server (host) to which requests may be sent:

hostname = uri.hostname # => "jsonplaceholder.typicode.com"
Net::HTTP.start(hostname) do |http|
  # Some HTTP stuff.
end

Paths

A host-specific path identifies a resource on the host:

_uri = uri.dup
_uri.path = '/todos/1'
hostname = _uri.hostname
path = _uri.path
Net::HTTP.get(hostname, path)

Queries

A host-specific query adds name/value pairs to the URI:

_uri = uri.dup
params = {userId: 1, completed: false}
_uri.query = URI.encode_www_form(params)
_uri # => #<URI::HTTPS https://jsonplaceholder.typicode.com?userId=1&completed=false>
Net::HTTP.get(_uri)

Fragments

A URI fragment has no effect in Net::HTTP; the same data is returned, regardless of whether a fragment is included.

Request Headers

Request headers may be used to pass additional information to the host, similar to arguments passed in a method call; each header is a name/value pair.

Each of the Net::HTTP methods that sends a request to the host has optional argument headers, where the headers are expressed as a hash of field-name/value pairs:

headers = {Accept: 'application/json', Connection: 'Keep-Alive'}
Net::HTTP.get(uri, headers)

See lists of both standard request fields and common request fields at Request Fields. A host may also accept other custom fields.

HTTP Sessions

A session is a connection between a server (host) and a client that:

See example sessions at Strategies.

Session Using Net::HTTP.start

If you have many requests to make to a single host (and port), consider using singleton method Net::HTTP.start with a block; the method handles the session automatically by:

In the block, you can use these instance methods, each of which that sends a single request:

Session Using Net::HTTP.start and Net::HTTP.finish

You can manage a session manually using methods start and finish:

http = Net::HTTP.new(hostname)
http.start
http.get('/todos/1')
http.get('/todos/2')
http.delete('/posts/1')
http.finish # Needed to free resources.

Single-Request Session

Certain convenience methods automatically handle a session by:

Such methods that send GET requests:

Such methods that send POST requests:

HTTP Requests and Responses

Many of the methods above are convenience methods, each of which sends a request and returns a string without directly using Net::HTTPRequest and Net::HTTPResponse objects.

You can, however, directly create a request object, send the request, and retrieve the response object; see:

Following Redirection

Each returned response is an instance of a subclass of Net::HTTPResponse. See the response class hierarchy.

In particular, class Net::HTTPRedirection is the parent of all redirection classes. This allows you to craft a case statement to handle redirections properly:

def fetch(uri, limit = 10)
  # You should choose a better exception.
  raise ArgumentError, 'Too many HTTP redirects' if limit == 0

  res = Net::HTTP.get_response(URI(uri))
  case res
  when Net::HTTPSuccess     # Any success class.
    res
  when Net::HTTPRedirection # Any redirection class.
    location = res['Location']
    warn "Redirected to #{location}"
    fetch(location, limit - 1)
  else                      # Any other class.
    res.value
  end
end

fetch(uri)

Basic Authentication

Basic authentication is performed according to RFC2617:

req = Net::HTTP::Get.new(uri)
req.basic_auth('user', 'pass')
res = Net::HTTP.start(hostname) do |http|
  http.request(req)
end

Streaming Response Bodies

By default Net::HTTP reads an entire response into memory. If you are handling large files or wish to implement a progress bar you can instead stream the body directly to an IO.

Net::HTTP.start(hostname) do |http|
  req = Net::HTTP::Get.new(uri)
  http.request(req) do |res|
    open('t.tmp', 'w') do |f|
      res.read_body do |chunk|
        f.write chunk
      end
    end
  end
end

HTTPS

HTTPS is enabled for an HTTP connection by Net::HTTP#use_ssl=:

Net::HTTP.start(hostname, :use_ssl => true) do |http|
  req = Net::HTTP::Get.new(uri)
  res = http.request(req)
end

Or if you simply want to make a GET request, you may pass in a URI object that has an HTTPS URL. Net::HTTP automatically turns on TLS verification if the URI object has a ‘https’ URI scheme:

uri # => #<URI::HTTPS https://jsonplaceholder.typicode.com/>
Net::HTTP.get(uri)

Proxy Server

An HTTP object can have a proxy server.

You can create an HTTP object with a proxy server using method Net::HTTP.new or method Net::HTTP.start.

The proxy may be defined either by argument p_addr or by environment variable 'http_proxy'.

Proxy Using Argument p_addr as a String

When argument p_addr is a string hostname, the returned http has the given host as its proxy:

http = Net::HTTP.new(hostname, nil, 'proxy.example')
http.proxy?          # => true
http.proxy_from_env? # => false
http.proxy_address   # => "proxy.example"
# These use default values.
http.proxy_port      # => 80
http.proxy_user      # => nil
http.proxy_pass      # => nil

The port, username, and password for the proxy may also be given:

http = Net::HTTP.new(hostname, nil, 'proxy.example', 8000, 'pname', 'ppass')
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.proxy?          # => true
http.proxy_from_env? # => false
http.proxy_address   # => "proxy.example"
http.proxy_port      # => 8000
http.proxy_user      # => "pname"
http.proxy_pass      # => "ppass"

Proxy Using ‘ENV['http_proxy']

When environment variable 'http_proxy' is set to a URI string, the returned http will have the server at that URI as its proxy; note that the URI string must have a protocol such as 'http' or 'https':

ENV['http_proxy'] = 'http://example.com'
http = Net::HTTP.new(hostname)
http.proxy?          # => true
http.proxy_from_env? # => true
http.proxy_address   # => "example.com"
# These use default values.
http.proxy_port      # => 80
http.proxy_user      # => nil
http.proxy_pass      # => nil

The URI string may include proxy username, password, and port number:

ENV['http_proxy'] = 'http://pname:ppass@example.com:8000'
http = Net::HTTP.new(hostname)
http.proxy?          # => true
http.proxy_from_env? # => true
http.proxy_address   # => "example.com"
http.proxy_port      # => 8000
http.proxy_user      # => "pname"
http.proxy_pass      # => "ppass"

Filtering Proxies

With method Net::HTTP.new (but not Net::HTTP.start), you can use argument p_no_proxy to filter proxies:

Compression and Decompression

Net::HTTP does not compress the body of a request before sending.

By default, Net::HTTP adds header 'Accept-Encoding' to a new request object:

Net::HTTP::Get.new(uri)['Accept-Encoding']
# => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"

This requests the server to zip-encode the response body if there is one; the server is not required to do so.

Net::HTTP does not automatically decompress a response body if the response has header 'Content-Range'.

Otherwise decompression (or not) depends on the value of header Content-Encoding:

What’s Here

First, what’s elsewhere. Class Net::HTTP:

This is a categorized summary of methods and attributes.

Net::HTTP Objects

Sessions

Connections

Requests

Responses

Proxies

Security

Addresses and Ports

HTTP Version

Debugging

Attributes

default_configuration [RW]

Allows to set the default configuration that will be used when creating a new connection.

Example:

Net::HTTP.default_configuration = {
  read_timeout: 1,
  write_timeout: 1
}
http = Net::HTTP.new(hostname)
http.open_timeout   # => 60
http.read_timeout   # => 1
http.write_timeout  # => 1
proxy_address [R]

Returns the address of the proxy host, or nil if none; see Proxy Server at Net::HTTP.

proxy_pass [R]

Returns the password for accessing the proxy, or nil if none; see Proxy Server at Net::HTTP.

proxy_port [R]

Returns the port number of the proxy host, or nil if none; see Proxy Server at Net::HTTP.

proxy_use_ssl [R]

Use SSL when talking to the proxy. If Net::HTTP does not use a proxy, nil.

proxy_user [R]

Returns the user name for accessing the proxy, or nil if none; see Proxy Server at Net::HTTP.

address [R]

Returns the string host name or host IP given as argument address in ::new.

ca_file [RW]

Sets or returns the path to a CA certification file in PEM format.

ca_path [RW]

Sets or returns the path of to CA directory containing certification files in PEM format.

cert [RW]

Sets or returns the OpenSSL::X509::Certificate object to be used for client certification.

cert_store [RW]

Sets or returns the X509::Store to be used for verifying peer certificate.

ciphers [RW]

Sets or returns the available SSL ciphers. See OpenSSL::SSL::SSLContext#ciphers=.

close_on_empty_response [RW]

Sets or returns whether to close the connection when the response is empty; initially false.

continue_timeout [R]

Returns the continue timeout value; see continue_timeout=.

extra_chain_cert [RW]

Sets or returns the extra X509 certificates to be added to the certificate chain. See OpenSSL::SSL::SSLContext#add_certificate.

ignore_eof [RW]

Sets or returns whether to ignore end-of-file when reading a response body with Content-Length headers; initially true.

keep_alive_timeout [RW]

Sets or returns the numeric (Integer or Float) number of seconds to keep the connection open after a request is sent; initially 2. If a new request is made during the given interval, the still-open connection is used; otherwise the connection will have been closed and a new connection is opened.

key [RW]

Sets or returns the OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.

local_host [RW]

Sets or returns the string local host used to establish the connection; initially nil.

local_port [RW]

Sets or returns the integer local port used to establish the connection; initially nil.

max_retries [R]

Returns the maximum number of times to retry an idempotent request; see max_retries=.

max_version [RW]

Sets or returns the maximum SSL version. See OpenSSL::SSL::SSLContext#max_version=.

min_version [RW]

Sets or returns the minimum SSL version. See OpenSSL::SSL::SSLContext#min_version=.

open_timeout [RW]

Sets or returns the numeric (Integer or Float) number of seconds to wait for a connection to open; initially 60. If the connection is not made in the given interval, an exception is raised.

port [R]

Returns the integer port number given as argument port in ::new.

proxy_address [W]

Sets the proxy address; see Proxy Server.

proxy_from_env [W]

Sets whether to determine the proxy from environment variable ‘ENV['http_proxy']’; see Proxy Using ENV[‘http_proxy’].

proxy_pass [W]

Sets the proxy password; see Proxy Server.

proxy_port [W]

Sets the proxy port; see Proxy Server.

proxy_use_ssl [W]
proxy_user [W]

Sets the proxy user; see Proxy Server.

read_timeout [R]

Returns the numeric (Integer or Float) number of seconds to wait for one block to be read (via one read(2) call); see read_timeout=.

response_body_encoding [R]

Returns the encoding to use for the response body; see response_body_encoding=.

ssl_timeout [RW]

Sets or returns the SSL timeout seconds.

ssl_version [RW]

Sets or returns the SSL version. See OpenSSL::SSL::SSLContext#ssl_version=.

verify_callback [RW]

Sets or returns the callback for the server certification verification.

verify_depth [RW]

Sets or returns the maximum depth for the certificate chain verification.

verify_hostname [RW]

Sets or returns whether to verify that the server certificate is valid for the hostname. See OpenSSL::SSL::SSLContext#verify_hostname=.

verify_mode [RW]

Sets or returns the flags for server the certification verification at the beginning of the SSL/TLS session. OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER are acceptable.

write_timeout [R]

Returns the numeric (Integer or Float) number of seconds to wait for one block to be written (via one write(2) call); see write_timeout=.

Public Class Methods

default_port ()

Returns integer 80, the default port to use for HTTP requests:

Net::HTTP.default_port # => 80
# File lib/net/http.rb, line 941
def HTTP.default_port
  http_default_port()
end
Net::HTTP.get(hostname, path, port = 80) → body
Net::HTTP:get(uri, headers = {}, port = uri.port) → body

Sends a GET request and returns the HTTP response body as a string.

With string arguments hostname and path:

hostname = 'jsonplaceholder.typicode.com'
path = '/todos/1'
puts Net::HTTP.get(hostname, path)

Output:

{
  "userId": 1,
  "id": 1,
  "title": "delectus aut autem",
  "completed": false
}

With URI object uri and optional hash argument headers:

uri = URI('https://jsonplaceholder.typicode.com/todos/1')
headers = {'Content-type' => 'application/json; charset=UTF-8'}
Net::HTTP.get(uri, headers)

Related:

# File lib/net/http.rb, line 810
def HTTP.get(uri_or_host, path_or_headers = nil, port = nil)
  get_response(uri_or_host, path_or_headers, port).body
end
Net::HTTP.get_print(hostname, path, port = 80) → nil
Net::HTTP:get_print(uri, headers = {}, port = uri.port) → nil

Like Net::HTTP.get, but writes the returned body to $stdout; returns nil.

# File lib/net/http.rb, line 769
def HTTP.get_print(uri_or_host, path_or_headers = nil, port = nil)
  get_response(uri_or_host, path_or_headers, port) {|res|
    res.read_body do |chunk|
      $stdout.print chunk
    end
  }
  nil
end
Net::HTTP.get_response(hostname, path, port = 80) → http_response
Net::HTTP:get_response(uri, headers = {}, port = uri.port) → http_response

Like Net::HTTP.get, but returns a Net::HTTPResponse object instead of the body string.

# File lib/net/http.rb, line 820
def HTTP.get_response(uri_or_host, path_or_headers = nil, port = nil, &block)
  if path_or_headers && !path_or_headers.is_a?(Hash)
    host = uri_or_host
    path = path_or_headers
    new(host, port || HTTP.default_port).start {|http|
      return http.request_get(path, &block)
    }
  else
    uri = uri_or_host
    headers = path_or_headers
    start(uri.hostname, uri.port,
          :use_ssl => uri.scheme == 'https') {|http|
      return http.request_get(uri, headers, &block)
    }
  end
end
http_default_port ()

Returns integer 80, the default port to use for HTTP requests:

Net::HTTP.http_default_port # => 80
# File lib/net/http.rb, line 949
def HTTP.http_default_port
  80
end
https_default_port ()

Returns integer 443, the default port to use for HTTPS requests:

Net::HTTP.https_default_port # => 443
# File lib/net/http.rb, line 957
def HTTP.https_default_port
  443
end
new (address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, p_no_proxy = nil, p_use_ssl = nil)

Returns a new Net::HTTP object http (but does not open a TCP connection or HTTP session).

With only string argument address given (and ENV['http_proxy'] undefined or nil), the returned http:

Example:

http = Net::HTTP.new(hostname)
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.address # => "jsonplaceholder.typicode.com"
http.port    # => 80
http.proxy?  # => false

With integer argument port also given, the returned http has the given port:

http = Net::HTTP.new(hostname, 8000)
# => #<Net::HTTP jsonplaceholder.typicode.com:8000 open=false>
http.port # => 8000

For proxy-defining arguments p_addr through p_no_proxy, see Proxy Server.

Calls superclass method
# File lib/net/http.rb, line 1106
def HTTP.new(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, p_no_proxy = nil, p_use_ssl = nil)
  http = super address, port

  if proxy_class? then # from Net::HTTP::Proxy()
    http.proxy_from_env = @proxy_from_env
    http.proxy_address  = @proxy_address
    http.proxy_port     = @proxy_port
    http.proxy_user     = @proxy_user
    http.proxy_pass     = @proxy_pass
    http.proxy_use_ssl  = @proxy_use_ssl
  elsif p_addr == :ENV then
    http.proxy_from_env = true
  else
    if p_addr && p_no_proxy && !URI::Generic.use_proxy?(address, address, port, p_no_proxy)
      p_addr = nil
      p_port = nil
    end
    http.proxy_address = p_addr
    http.proxy_port    = p_port || default_port
    http.proxy_user    = p_user
    http.proxy_pass    = p_pass
    http.proxy_use_ssl = p_use_ssl
  end

  http
end
post (url, data, header = nil)

Posts data to a host; returns a Net::HTTPResponse object.

Argument url must be a URL; argument data must be a string:

_uri = uri.dup
_uri.path = '/posts'
data = '{"title": "foo", "body": "bar", "userId": 1}'
headers = {'content-type': 'application/json'}
res = Net::HTTP.post(_uri, data, headers) # => #<Net::HTTPCreated 201 Created readbody=true>
puts res.body

Output:

{
  "title": "foo",
  "body": "bar",
  "userId": 1,
  "id": 101
}

Related:

# File lib/net/http.rb, line 863
def HTTP.post(url, data, header = nil)
  start(url.hostname, url.port,
        :use_ssl => url.scheme == 'https' ) {|http|
    http.post(url, data, header)
  }
end
post_form (url, params)

Posts data to a host; returns a Net::HTTPResponse object.

Argument url must be a URI; argument data must be a hash:

_uri = uri.dup
_uri.path = '/posts'
data = {title: 'foo', body: 'bar', userId: 1}
res = Net::HTTP.post_form(_uri, data) # => #<Net::HTTPCreated 201 Created readbody=true>
puts res.body

Output:

{
  "title": "foo",
  "body": "bar",
  "userId": "1",
  "id": 101
}
# File lib/net/http.rb, line 890
def HTTP.post_form(url, params)
  req = Post.new(url)
  req.form_data = params
  req.basic_auth url.user, url.password if url.user
  start(url.hostname, url.port,
        :use_ssl => url.scheme == 'https' ) {|http|
    http.request(req)
  }
end
proxy_class? ()

Returns true if self is a class which was created by HTTP::Proxy.

# File lib/net/http.rb, line 1832
def proxy_class?
  defined?(@is_proxy_class) ? @is_proxy_class : false
end
put (url, data, header = nil)

Sends a PUT request to the server; returns a Net::HTTPResponse object.

Argument url must be a URL; argument data must be a string:

_uri = uri.dup
_uri.path = '/posts'
data = '{"title": "foo", "body": "bar", "userId": 1}'
headers = {'content-type': 'application/json'}
res = Net::HTTP.put(_uri, data, headers) # => #<Net::HTTPCreated 201 Created readbody=true>
puts res.body

Output:

{
  "title": "foo",
  "body": "bar",
  "userId": 1,
  "id": 101
}

Related:

# File lib/net/http.rb, line 926
def HTTP.put(url, data, header = nil)
  start(url.hostname, url.port,
        :use_ssl => url.scheme == 'https' ) {|http|
    http.put(url, data, header)
  }
end
start(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, opts) → http
start(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, opts) {|http| ... } → object

Creates a new Net::HTTP object, http, via Net::HTTP.new:

  • For arguments address and port, see Net::HTTP.new.

  • For proxy-defining arguments p_addr through p_pass, see Proxy Server.

  • For argument opts, see below.

With no block given:

  • Calls http.start with no block (see start), which opens a TCP connection and HTTP session.

  • Returns http.

  • The caller should call finish to close the session:

    http = Net::HTTP.start(hostname)
    http.started? # => true
    http.finish
    http.started? # => false
    

With a block given:

  • Calls http.start with the block (see start), which:

    • Opens a TCP connection and HTTP session.

    • Calls the block, which may make any number of requests to the host.

    • Closes the HTTP session and TCP connection on block exit.

    • Returns the block’s value object.

  • Returns object.

Example:

hostname = 'jsonplaceholder.typicode.com'
Net::HTTP.start(hostname) do |http|
  puts http.get('/todos/1').body
  puts http.get('/todos/2').body
end

Output:

{
  "userId": 1,
  "id": 1,
  "title": "delectus aut autem",
  "completed": false
}
{
  "userId": 1,
  "id": 2,
  "title": "quis ut nam facilis et officia qui",
  "completed": false
}

If the last argument given is a hash, it is the opts hash, where each key is a method or accessor to be called, and its value is the value to be set.

The keys may include:

Note: If port is nil and opts[:use_ssl] is a truthy value, the value passed to new is Net::HTTP.https_default_port, not port.

# File lib/net/http.rb, line 1051
def HTTP.start(address, *arg, &block) # :yield: +http+
  arg.pop if opt = Hash.try_convert(arg[-1])
  port, p_addr, p_port, p_user, p_pass = *arg
  p_addr = :ENV if arg.size < 2
  port = https_default_port if !port && opt && opt[:use_ssl]
  http = new(address, port, p_addr, p_port, p_user, p_pass)
  http.ipaddr = opt[:ipaddr] if opt && opt[:ipaddr]

  if opt
    if opt[:use_ssl]
      opt = {verify_mode: OpenSSL::SSL::VERIFY_PEER}.update(opt)
    end
    http.methods.grep(/\A(\w+)=\z/) do |meth|
      key = $1.to_sym
      opt.key?(key) or next
      http.__send__(meth, opt[key])
    end
  end

  http.start(&block)
end
version_1_2 ()

Returns true; retained for compatibility.

# File lib/net/http.rb, line 744
def HTTP.version_1_2
  true
end
version_1_2? ()

Returns true; retained for compatibility.

# File lib/net/http.rb, line 749
def HTTP.version_1_2?
  true
end

Public Instance Methods

continue_timeout= (sec)

Sets the continue timeout value, which is the number of seconds to wait for an expected 100 Continue response. If the HTTP object does not receive a response in this many seconds it sends the request body.

# File lib/net/http.rb, line 1457
def continue_timeout=(sec)
  @socket.continue_timeout = sec if @socket
  @continue_timeout = sec
end
copy (path, initheader = nil)

Sends a COPY request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Copy object created from string path and initial headers hash initheader.

http = Net::HTTP.new(hostname)
http.copy('/todos/1')
# File lib/net/http.rb, line 2201
def copy(path, initheader = nil)
  request(Copy.new(path, initheader))
end
delete (path, initheader = {'Depth' => 'Infinity'})

Sends a DELETE request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Delete object created from string path and initial headers hash initheader.

http = Net::HTTP.new(hostname)
http.delete('/todos/1')
# File lib/net/http.rb, line 2175
def delete(path, initheader = {'Depth' => 'Infinity'})
  request(Delete.new(path, initheader))
end
finish ()

Finishes the HTTP session:

http = Net::HTTP.new(hostname)
http.start
http.started? # => true
http.finish   # => nil
http.started? # => false

Raises IOError if not in a session.

# File lib/net/http.rb, line 1776
def finish
  raise IOError, 'HTTP session not yet started' unless started?
  do_finish
end
get(path, initheader = nil) {|res| ... }

Sends a GET request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Get object created from string path and initial headers hash initheader.

With a block given, calls the block with the response body:

http = Net::HTTP.new(hostname)
http.get('/todos/1') do |res|
  p res
end # => #<Net::HTTPOK 200 OK readbody=true>

Output:

"{\n  \"userId\": 1,\n  \"id\": 1,\n  \"title\": \"delectus aut autem\",\n  \"completed\": false\n}"

With no block given, simply returns the response object:

http.get('/') # => #<Net::HTTPOK 200 OK readbody=true>

Related:

# File lib/net/http.rb, line 1987
def get(path, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  res = nil

  request(Get.new(path, initheader)) {|r|
    r.read_body dest, &block
    res = r
  }
  res
end
head (path, initheader = nil)

Sends a HEAD request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Head object created from string path and initial headers hash initheader:

res = http.head('/todos/1') # => #<Net::HTTPOK 200 OK readbody=true>
res.body                    # => nil
res.to_hash.take(3)
# =>
[["date", ["Wed, 15 Feb 2023 15:25:42 GMT"]],
 ["content-type", ["application/json; charset=utf-8"]],
 ["connection", ["close"]]]
# File lib/net/http.rb, line 2011
def head(path, initheader = nil)
  request(Head.new(path, initheader))
end
inspect ()

Returns a string representation of self:

Net::HTTP.new(hostname).inspect
# => "#<Net::HTTP jsonplaceholder.typicode.com:80 open=false>"
# File lib/net/http.rb, line 1211
def inspect
  "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
end
ipaddr ()

Returns the IP address for the connection.

If the session has not been started, returns the value set by ipaddr=, or nil if it has not been set:

http = Net::HTTP.new(hostname)
http.ipaddr # => nil
http.ipaddr = '172.67.155.76'
http.ipaddr # => "172.67.155.76"

If the session has been started, returns the IP address from the socket:

http = Net::HTTP.new(hostname)
http.start
http.ipaddr # => "172.67.155.76"
http.finish
# File lib/net/http.rb, line 1351
def ipaddr
  started? ?  @socket.io.peeraddr[3] : @ipaddr
end
ipaddr= (addr)

Sets the IP address for the connection:

http = Net::HTTP.new(hostname)
http.ipaddr # => nil
http.ipaddr = '172.67.155.76'
http.ipaddr # => "172.67.155.76"

The IP address may not be set if the session has been started.

# File lib/net/http.rb, line 1363
def ipaddr=(addr)
  raise IOError, "ipaddr value changed, but session already started" if started?
  @ipaddr = addr
end
lock (path, body, initheader = nil)

Sends a LOCK request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Lock object created from string path, string body, and initial headers hash initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.lock('/todos/1', data)
# File lib/net/http.rb, line 2121
def lock(path, body, initheader = nil)
  request(Lock.new(path, initheader), body)
end
max_retries= (retries)

Sets the maximum number of times to retry an idempotent request in case of Net::ReadTimeout, IOError, EOFError, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE, OpenSSL::SSL::SSLError, Timeout::Error. The initial value is 1.

Argument retries must be a non-negative numeric value:

http = Net::HTTP.new(hostname)
http.max_retries = 2   # => 2
http.max_retries       # => 2
# File lib/net/http.rb, line 1397
def max_retries=(retries)
  retries = retries.to_int
  if retries < 0
    raise ArgumentError, 'max_retries should be non-negative integer number'
  end
  @max_retries = retries
end
mkcol (path, body = nil, initheader = nil)

Sends a MKCOL request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Mkcol object created from string path, string body, and initial headers hash initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http.mkcol('/todos/1', data)
http = Net::HTTP.new(hostname)
# File lib/net/http.rb, line 2215
def mkcol(path, body = nil, initheader = nil)
  request(Mkcol.new(path, initheader), body)
end
move (path, initheader = nil)

Sends a MOVE request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Move object created from string path and initial headers hash initheader.

http = Net::HTTP.new(hostname)
http.move('/todos/1')
# File lib/net/http.rb, line 2188
def move(path, initheader = nil)
  request(Move.new(path, initheader))
end
options (path, initheader = nil)

Sends an Options request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Options object created from string path and initial headers hash initheader.

http = Net::HTTP.new(hostname)
http.options('/')
# File lib/net/http.rb, line 2148
def options(path, initheader = nil)
  request(Options.new(path, initheader))
end
patch(path, data, initheader = nil) {|res| ... }

Sends a PATCH request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Patch object created from string path, string data, and initial headers hash initheader.

With a block given, calls the block with the response body:

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.patch('/todos/1', data) do |res|
  p res
end # => #<Net::HTTPOK 200 OK readbody=true>

Output:

"{\n  \"userId\": 1,\n  \"id\": 1,\n  \"title\": \"delectus aut autem\",\n  \"completed\": false,\n  \"{\\\"userId\\\": 1, \\\"id\\\": 1, \\\"title\\\": \\\"delectus aut autem\\\", \\\"completed\\\": false}\": \"\"\n}"

With no block given, simply returns the response object:

http.patch('/todos/1', data) # => #<Net::HTTPCreated 201 Created readbody=true>
# File lib/net/http.rb, line 2074
def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  send_entity(path, data, initheader, dest, Patch, &block)
end
peer_cert ()

Returns the X509 certificate chain (an array of strings) for the session’s socket peer, or nil if none.

# File lib/net/http.rb, line 1599
def peer_cert
  if not use_ssl? or not @socket
    return nil
  end
  @socket.io.peer_cert
end
post(path, data, initheader = nil) {|res| ... }

Sends a POST request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Post object created from string path, string data, and initial headers hash initheader.

With a block given, calls the block with the response body:

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.post('/todos', data) do |res|
  p res
end # => #<Net::HTTPCreated 201 Created readbody=true>

Output:

"{\n  \"{\\\"userId\\\": 1, \\\"id\\\": 1, \\\"title\\\": \\\"delectus aut autem\\\", \\\"completed\\\": false}\": \"\",\n  \"id\": 201\n}"

With no block given, simply returns the response object:

http.post('/todos', data) # => #<Net::HTTPCreated 201 Created readbody=true>

Related:

# File lib/net/http.rb, line 2045
def post(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  send_entity(path, data, initheader, dest, Post, &block)
end
propfind (path, body = nil, initheader = {'Depth' => '0'})

Sends a PROPFIND request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Propfind object created from string path, string body, and initial headers hash initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.propfind('/todos/1', data)
# File lib/net/http.rb, line 2162
def propfind(path, body = nil, initheader = {'Depth' => '0'})
  request(Propfind.new(path, initheader), body)
end
proppatch (path, body, initheader = nil)

Sends a PROPPATCH request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Proppatch object created from string path, string body, and initial headers hash initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.proppatch('/todos/1', data)
# File lib/net/http.rb, line 2107
def proppatch(path, body, initheader = nil)
  request(Proppatch.new(path, initheader), body)
end
proxy? ()

Returns true if a proxy server is defined, false otherwise; see Proxy Server.

# File lib/net/http.rb, line 1858
def proxy?
  !!(@proxy_from_env ? proxy_uri : @proxy_address)
end
proxy_address ()

Returns the address of the proxy server, if defined, nil otherwise; see Proxy Server.

# File lib/net/http.rb, line 1880
def proxy_address
  if @proxy_from_env then
    proxy_uri&.hostname
  else
    @proxy_address
  end
end
proxy_from_env? ()

Returns true if the proxy server is defined in the environment, false otherwise; see Proxy Server.

# File lib/net/http.rb, line 1865
def proxy_from_env?
  @proxy_from_env
end
proxy_pass ()

Returns the password of the proxy server, if defined, nil otherwise; see Proxy Server.

# File lib/net/http.rb, line 1911
def proxy_pass
  if @proxy_from_env
    pass = proxy_uri&.password
    unescape(pass) if pass
  else
    @proxy_pass
  end
end
proxy_port ()

Returns the port number of the proxy server, if defined, nil otherwise; see Proxy Server.

# File lib/net/http.rb, line 1890
def proxy_port
  if @proxy_from_env then
    proxy_uri&.port
  else
    @proxy_port
  end
end
proxy_user ()

Returns the user name of the proxy server, if defined, nil otherwise; see Proxy Server.

# File lib/net/http.rb, line 1900
def proxy_user
  if @proxy_from_env
    user = proxy_uri&.user
    unescape(user) if user
  else
    @proxy_user
  end
end
put (path, data, initheader = nil)

Sends a PUT request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Put object created from string path, string data, and initial headers hash initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.put('/todos/1', data) # => #<Net::HTTPOK 200 OK readbody=true>

Related:

# File lib/net/http.rb, line 2093
def put(path, data, initheader = nil)
  request(Put.new(path, initheader), data)
end
read_timeout= (sec)

Sets the read timeout, in seconds, for self to integer sec; the initial value is 60.

Argument sec must be a non-negative numeric value:

http = Net::HTTP.new(hostname)
http.read_timeout # => 60
http.get('/todos/1') # => #<Net::HTTPOK 200 OK readbody=true>
http.read_timeout = 0
http.get('/todos/1') # Raises Net::ReadTimeout.
# File lib/net/http.rb, line 1420
def read_timeout=(sec)
  @socket.read_timeout = sec if @socket
  @read_timeout = sec
end
request (req, body = nil) { |response| ... }

Sends the given request req to the server; forms the response into a Net::HTTPResponse object.

The given req must be an instance of a subclass of Net::HTTPRequest. Argument body should be given only if needed for the request.

With no block given, returns the response object:

http = Net::HTTP.new(hostname)

req = Net::HTTP::Get.new('/todos/1')
http.request(req)
# => #<Net::HTTPOK 200 OK readbody=true>

req = Net::HTTP::Post.new('/todos')
http.request(req, 'xyzzy')
# => #<Net::HTTPCreated 201 Created readbody=true>

With a block given, calls the block with the response and returns the response:

req = Net::HTTP::Get.new('/todos/1')
http.request(req) do |res|
  p res
end # => #<Net::HTTPOK 200 OK readbody=true>

Output:

#<Net::HTTPOK 200 OK readbody=false>
# File lib/net/http.rb, line 2373
def request(req, body = nil, &block)  # :yield: +response+
  unless started?
    start {
      req['connection'] ||= 'close'
      return request(req, body, &block)
    }
  end
  if proxy_user()
    req.proxy_basic_auth proxy_user(), proxy_pass() unless use_ssl?
  end
  req.set_body_internal body
  res = transport_request(req, &block)
  if sspi_auth?(res)
    sspi_auth(req)
    res = transport_request(req, &block)
  end
  res
end
request_get (path, initheader = nil) { |response| ... }

Sends a GET request to the server; forms the response into a Net::HTTPResponse object.

The request is based on the Net::HTTP::Get object created from string path and initial headers hash initheader.

With no block given, returns the response object:

http = Net::HTTP.new(hostname)
http.request_get('/todos') # => #<Net::HTTPOK 200 OK readbody=true>

With a block given, calls the block with the response object and returns the response object:

http.request_get('/todos') do |res|
  p res
end # => #<Net::HTTPOK 200 OK readbody=true>

Output:

#<Net::HTTPOK 200 OK readbody=false>
# File lib/net/http.rb, line 2254
def request_get(path, initheader = nil, &block) # :yield: +response+
  request(Get.new(path, initheader), &block)
end
request_head (path, initheader = nil, &block)

Sends a HEAD request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Head object created from string path and initial headers hash initheader.

http = Net::HTTP.new(hostname)
http.head('/todos/1') # => #<Net::HTTPOK 200 OK readbody=true>
# File lib/net/http.rb, line 2267
def request_head(path, initheader = nil, &block)
  request(Head.new(path, initheader), &block)
end
request_post (path, data, initheader = nil) { |response| ... }

Sends a POST request to the server; forms the response into a Net::HTTPResponse object.

The request is based on the Net::HTTP::Post object created from string path, string data, and initial headers hash initheader.

With no block given, returns the response object:

http = Net::HTTP.new(hostname)
http.post('/todos', 'xyzzy')
# => #<Net::HTTPCreated 201 Created readbody=true>

With a block given, calls the block with the response body and returns the response object:

http.post('/todos', 'xyzzy') do |res|
  p res
end # => #<Net::HTTPCreated 201 Created readbody=true>

Output:

"{\n  \"xyzzy\": \"\",\n  \"id\": 201\n}"
# File lib/net/http.rb, line 2294
def request_post(path, data, initheader = nil, &block) # :yield: +response+
  request Post.new(path, initheader), data, &block
end
response_body_encoding= (value)

Sets the encoding to be used for the response body; returns the encoding.

The given value may be:

  • An Encoding object.

  • The name of an encoding.

  • An alias for an encoding name.

See Encoding.

Examples:

http = Net::HTTP.new(hostname)
http.response_body_encoding = Encoding::US_ASCII # => #<Encoding:US-ASCII>
http.response_body_encoding = 'US-ASCII'         # => "US-ASCII"
http.response_body_encoding = 'ASCII'            # => "ASCII"
# File lib/net/http.rb, line 1305
def response_body_encoding=(value)
  value = Encoding.find(value) if value.is_a?(String)
  @response_body_encoding = value
end
send_request (name, path, data = nil, header = nil)

Sends an HTTP request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTPRequest object created from string path, string data, and initial headers hash header. That object is an instance of the subclass of Net::HTTPRequest, that corresponds to the given uppercase string name, which must be an HTTP request method or a WebDAV request method.

Examples:

http = Net::HTTP.new(hostname)
http.send_request('GET', '/todos/1')
# => #<Net::HTTPOK 200 OK readbody=true>
http.send_request('POST', '/todos', 'xyzzy')
# => #<Net::HTTPCreated 201 Created readbody=true>
# File lib/net/http.rb, line 2337
def send_request(name, path, data = nil, header = nil)
  has_response_body = name != 'HEAD'
  r = HTTPGenericRequest.new(name,(data ? true : false),has_response_body,path,header)
  request r, data
end
set_debug_output (output)

WARNING This method opens a serious security hole. Never use this method in production code.

Sets the output stream for debugging:

http = Net::HTTP.new(hostname)
File.open('t.tmp', 'w') do |file|
  http.set_debug_output(file)
  http.start
  http.get('/nosuch/1')
  http.finish
end
puts File.read('t.tmp')

Output:

opening connection to jsonplaceholder.typicode.com:80...
opened
<- "GET /nosuch/1 HTTP/1.1\r\nAccept-Encoding: gzip;q=1.0,deflate;q=0.6,identity;q=0.3\r\nAccept: */*\r\nUser-Agent: Ruby\r\nHost: jsonplaceholder.typicode.com\r\n\r\n"
-> "HTTP/1.1 404 Not Found\r\n"
-> "Date: Mon, 12 Dec 2022 21:14:11 GMT\r\n"
-> "Content-Type: application/json; charset=utf-8\r\n"
-> "Content-Length: 2\r\n"
-> "Connection: keep-alive\r\n"
-> "X-Powered-By: Express\r\n"
-> "X-Ratelimit-Limit: 1000\r\n"
-> "X-Ratelimit-Remaining: 999\r\n"
-> "X-Ratelimit-Reset: 1670879660\r\n"
-> "Vary: Origin, Accept-Encoding\r\n"
-> "Access-Control-Allow-Credentials: true\r\n"
-> "Cache-Control: max-age=43200\r\n"
-> "Pragma: no-cache\r\n"
-> "Expires: -1\r\n"
-> "X-Content-Type-Options: nosniff\r\n"
-> "Etag: W/\"2-vyGp6PvFo4RvsFtPoIWeCReyIC8\"\r\n"
-> "Via: 1.1 vegur\r\n"
-> "CF-Cache-Status: MISS\r\n"
-> "Server-Timing: cf-q-config;dur=1.3000000762986e-05\r\n"
-> "Report-To: {\"endpoints\":[{\"url\":\"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=yOr40jo%2BwS1KHzhTlVpl54beJ5Wx2FcG4gGV0XVrh3X9OlR5q4drUn2dkt5DGO4GDcE%2BVXT7CNgJvGs%2BZleIyMu8CLieFiDIvOviOY3EhHg94m0ZNZgrEdpKD0S85S507l1vsEwEHkoTm%2Ff19SiO\"}],\"group\":\"cf-nel\",\"max_age\":604800}\r\n"
-> "NEL: {\"success_fraction\":0,\"report_to\":\"cf-nel\",\"max_age\":604800}\r\n"
-> "Server: cloudflare\r\n"
-> "CF-RAY: 778977dc484ce591-DFW\r\n"
-> "alt-svc: h3=\":443\"; ma=86400, h3-29=\":443\"; ma=86400\r\n"
-> "\r\n"
reading 2 bytes...
-> "{}"
read 2 bytes
Conn keep-alive
# File lib/net/http.rb, line 1264
def set_debug_output(output)
  warn 'Net::HTTP#set_debug_output called after HTTP started', uplevel: 1 if started?
  @debug_output = output
end
start () { |http| ... }

Starts an HTTP session.

Without a block, returns self:

http = Net::HTTP.new(hostname)
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.start
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=true>
http.started? # => true
http.finish

With a block, calls the block with self, finishes the session when the block exits, and returns the block’s value:

http.start do |http|
  http
end
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.started? # => false
# File lib/net/http.rb, line 1627
def start  # :yield: http
  raise IOError, 'HTTP session already opened' if @started
  if block_given?
    begin
      do_start
      return yield(self)
    ensure
      do_finish
    end
  end
  do_start
  self
end
started? ()

Returns true if the HTTP session has been started:

http = Net::HTTP.new(hostname)
http.started? # => false
http.start
http.started? # => true
http.finish # => nil
http.started? # => false

Net::HTTP.start(hostname) do |http|
  http.started?
end # => true
http.started? # => false
# File lib/net/http.rb, line 1490
def started?
  @started
end
trace (path, initheader = nil)

Sends a TRACE request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Trace object created from string path and initial headers hash initheader.

http = Net::HTTP.new(hostname)
http.trace('/todos/1')
# File lib/net/http.rb, line 2228
def trace(path, initheader = nil)
  request(Trace.new(path, initheader))
end
unlock (path, body, initheader = nil)

Sends an UNLOCK request to the server; returns an instance of a subclass of Net::HTTPResponse.

The request is based on the Net::HTTP::Unlock object created from string path, string body, and initial headers hash initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.unlock('/todos/1', data)
# File lib/net/http.rb, line 2135
def unlock(path, body, initheader = nil)
  request(Unlock.new(path, initheader), body)
end
use_ssl= (flag)

Sets whether a new session is to use Transport Layer Security:

Raises IOError if attempting to change during a session.

Raises OpenSSL::SSL::SSLError if the port is not an HTTPS port.

# File lib/net/http.rb, line 1512
def use_ssl=(flag)
  flag = flag ? true : false
  if started? and @use_ssl != flag
    raise IOError, "use_ssl value changed, but session already started"
  end
  @use_ssl = flag
end
use_ssl? ()

Returns true if self uses SSL, false otherwise. See Net::HTTP#use_ssl=.

# File lib/net/http.rb, line 1502
def use_ssl?
  @use_ssl
end
write_timeout= (sec)

Sets the write timeout, in seconds, for self to integer sec; the initial value is 60.

Argument sec must be a non-negative numeric value:

_uri = uri.dup
_uri.path = '/posts'
body = 'bar' * 200000
data = <<EOF
{"title": "foo", "body": "#{body}", "userId": "1"}
EOF
headers = {'content-type': 'application/json'}
http = Net::HTTP.new(hostname)
http.write_timeout # => 60
http.post(_uri.path, data, headers)
# => #<Net::HTTPCreated 201 Created readbody=true>
http.write_timeout = 0
http.post(_uri.path, data, headers) # Raises Net::WriteTimeout.
# File lib/net/http.rb, line 1444
def write_timeout=(sec)
  @socket.write_timeout = sec if @socket
  @write_timeout = sec
end