Class: Net::HTTP

Class | Net::HTTP
In: | net/http.rb
Parent: | Protocol

## What Is This Library?

This library provides your program functions to access WWW documents via HTTP, Hyper Text Transfer Protocol version 1.1. For details of HTTP, refer [RFC2616] (www.ietf.org/rfc/rfc2616.txt).

## Examples

### Getting Document From WWW Server

Example 1: Simple GET+print

        require 'net/http'
        Net::HTTP.get_print 'www.example.com', '/index.html'

Example 2: Simple GET+print by URL

        require 'net/http'
        require 'uri'
        Net::HTTP.get_print URI.parse('http://www.example.com/index.html')

Example 3: More generic GET+print

        require 'net/http'
        require 'uri'

        url = URI.parse('http://www.example.com/index.html')
        res = Net::HTTP.start(url.host, url.port) {|http|
          http.get('/index.html')
        }
        puts res.body

Example 4: More generic GET+print

        require 'net/http'

        url = URI.parse('http://www.example.com/index.html')
        req = Net::HTTP::Get.new(url.path)
        res = Net::HTTP.start(url.host, url.port) {|http|
          http.request(req)
        }
        puts res.body

### Posting Form Data

        require 'net/http'
        require 'uri'

        #1: Simple POST
        res = Net::HTTP.post_form(URI.parse('http://www.example.com/search.cgi'),
                                  {'q'=>'ruby', 'max'=>'50'})
        puts res.body

        #2: POST with basic authentication
        res = Net::HTTP.post_form(URI.parse('http://jack:pass@www.example.com/todo.cgi'),
                                            {'from'=>'2005-01-01', 'to'=>'2005-03-31'})
        puts res.body

        #3: Detailed control
        url = URI.parse('http://www.example.com/todo.cgi')
        req = Net::HTTP::Post.new(url.path)
        req.basic_auth 'jack', 'pass'
        req.set_form_data({'from'=>'2005-01-01', 'to'=>'2005-03-31'}, ';')
        res = Net::HTTP.new(url.host, url.port).start { http.request(req) }
        case res
        when Net::HTTPSuccess, Net::HTTPRedirection
          # OK
        else
          res.error!
        end

### Accessing via Proxy

Net::HTTP.Proxy creates http proxy class. It has same methods of Net::HTTP but its instances always connect to proxy, instead of given host.

        require 'net/http'

        proxy_addr = 'your.proxy.host'
        proxy_port = 8080
                :
        Net::HTTP::Proxy(proxy_addr, proxy_port).start('www.example.com') {|http|
          # always connect to your.proxy.addr:8080
                :
        }

Since Net::HTTP.Proxy returns Net::HTTP itself when proxy_addr is nil, there’s no need to change code if there’s proxy or not.

There are two additional parameters in Net::HTTP.Proxy which allow to specify proxy user name and password:

        Net::HTTP::Proxy(proxy_addr, proxy_port, proxy_user = nil, proxy_pass = nil)

You may use them to work with authorization-enabled proxies:

        require 'net/http'
        require 'uri'

        proxy_host = 'your.proxy.host'
        proxy_port = 8080
        uri = URI.parse(ENV['http_proxy'])
        proxy_user, proxy_pass = uri.userinfo.split(/:/) if uri.userinfo
        Net::HTTP::Proxy(proxy_host, proxy_port,
                         proxy_user, proxy_pass).start('www.example.com') {|http|
          # always connect to your.proxy.addr:8080 using specified username and password
                :
        }

Note that net/http never rely on HTTP_PROXY environment variable. If you want to use proxy, set it explicitly.

### Following Redirection

        require 'net/http'
        require 'uri'

        def fetch(uri_str, limit = 10)
          # You should choose better exception.
          raise ArgumentError, 'HTTP redirect too deep' if limit == 0

          response = Net::HTTP.get_response(URI.parse(uri_str))
          case response
          when Net::HTTPSuccess     then response
          when Net::HTTPRedirection then fetch(response['location'], limit - 1)
          else
            response.error!
          end
        end

        print fetch('http://www.ruby-lang.org')

Net::HTTPSuccess and Net::HTTPRedirection is a HTTPResponse class. All HTTPResponse objects belong to its own response class which indicate HTTP result status. For details of response classes, see section "HTTP Response Classes".

### Basic Authentication

        require 'net/http'

        Net::HTTP.start('www.example.com') {|http|
          req = Net::HTTP::Get.new('/secret-page.html')
          req.basic_auth 'account', 'password'
          response = http.request(req)
          print response.body
        }

### HTTP Request Classes

Here is HTTP request class hierarchy.

      Net::HTTPRequest
          Net::HTTP::Get
          Net::HTTP::Head
          Net::HTTP::Post
          Net::HTTP::Put
          Net::HTTP::Proppatch
          Net::HTTP::Lock
          Net::HTTP::Unlock
          Net::HTTP::Options
          Net::HTTP::Propfind
          Net::HTTP::Delete
          Net::HTTP::Move
          Net::HTTP::Copy
          Net::HTTP::Mkcol
          Net::HTTP::Trace

### HTTP Response Classes

Here is HTTP response class hierarchy. All classes are defined in Net module.

      HTTPResponse
          HTTPUnknownResponse
          HTTPInformation                    # 1xx
              HTTPContinue                       # 100
              HTTPSwitchProtocl                  # 101
          HTTPSuccess                        # 2xx
              HTTPOK                             # 200
              HTTPCreated                        # 201
              HTTPAccepted                       # 202
              HTTPNonAuthoritativeInformation    # 203
              HTTPNoContent                      # 204
              HTTPResetContent                   # 205
              HTTPPartialContent                 # 206
          HTTPRedirection                    # 3xx
              HTTPMultipleChoice                 # 300
              HTTPMovedPermanently               # 301
              HTTPFound                          # 302
              HTTPSeeOther                       # 303
              HTTPNotModified                    # 304
              HTTPUseProxy                       # 305
              HTTPTemporaryRedirect              # 307
          HTTPClientError                    # 4xx
              HTTPBadRequest                     # 400
              HTTPUnauthorized                   # 401
              HTTPPaymentRequired                # 402
              HTTPForbidden                      # 403
              HTTPNotFound                       # 404
              HTTPMethodNotAllowed               # 405
              HTTPNotAcceptable                  # 406
              HTTPProxyAuthenticationRequired    # 407
              HTTPRequestTimeOut                 # 408
              HTTPConflict                       # 409
              HTTPGone                           # 410
              HTTPLengthRequired                 # 411
              HTTPPreconditionFailed             # 412
              HTTPRequestEntityTooLarge          # 413
              HTTPRequestURITooLong              # 414
              HTTPUnsupportedMediaType           # 415
              HTTPRequestedRangeNotSatisfiable   # 416
              HTTPExpectationFailed              # 417
          HTTPServerError                    # 5xx
              HTTPInternalServerError            # 500
              HTTPNotImplemented                 # 501
              HTTPBadGateway                     # 502
              HTTPServiceUnavailable             # 503
              HTTPGatewayTimeOut                 # 504
              HTTPVersionNotSupported            # 505

## Switching Net::HTTP versions

You can use net/http.rb 1.1 features (bundled with Ruby 1.6) by calling HTTP.version_1_1. Calling Net::HTTP.version_1_2 allows you to use 1.2 features again.

        # example
        Net::HTTP.start {|http1| ...(http1 has 1.2 features)... }

        Net::HTTP.version_1_1
        Net::HTTP.start {|http2| ...(http2 has 1.1 features)... }

        Net::HTTP.version_1_2
        Net::HTTP.start {|http3| ...(http3 has 1.2 features)... }

This function is NOT thread-safe.

### Methods

Proxy active? copy default_port delete finish get get get2 get_print get_response head head2 http_default_port https_default_port inspect lock mkcol move new new options post post2 post_form propfind proppatch proxy? proxy_address proxy_class? proxy_pass proxy_port proxy_user proxyaddr proxyport read_timeout= request request_get request_head request_post send_request set_debug_output start start started? trace unlock use_ssl use_ssl? version_1_1 version_1_1? version_1_2 version_1_2?

### Classes and Modules

Class Net::HTTP::Copy
Class Net::HTTP::Delete
Class Net::HTTP::Get
Class Net::HTTP::Head
Class Net::HTTP::Lock
Class Net::HTTP::Mkcol
Class Net::HTTP::Move
Class Net::HTTP::Options
Class Net::HTTP::Post
Class Net::HTTP::Propfind
Class Net::HTTP::Proppatch
Class Net::HTTP::Put
Class Net::HTTP::Trace
Class Net::HTTP::Unlock

### External Aliases

version_1_1? | -> | is_version_1_1?
version_1_2? | -> | is_version_1_2?
new | -> | newobj
request_put | -> | put2

### Attributes

address | [R] | The host name to connect to.
close_on_empty_response | [RW] |
open_timeout | [RW] | Seconds to wait until connection is opened. If the HTTP object cannot open a connection in this many seconds, it raises a TimeoutError exception.
port | [R] | The port number to connect to.
proxy_address | [R] |
proxy_pass | [R] |
proxy_port | [R] |
proxy_user | [R] |
read_timeout | [R] | Seconds to wait until reading one block (by one read(2) call). If the HTTP object cannot open a connection in this many seconds, it raises a TimeoutError exception.

### Public Class methods

Proxy(p_addr, p_port = nil, p_user = nil, p_pass = nil)

Creates an HTTP proxy class. Arguments are address/port of proxy host and username/password if authorization on proxy server is required. You can replace the HTTP class with created proxy class.

If ADDRESS is nil, this method returns self (Net::HTTP).

        # Example
        proxy_class = Net::HTTP::Proxy('proxy.example.com', 8080)
                        :
        proxy_class.start('www.ruby-lang.org') {|http|
          # connecting proxy.foo.org:8080
                        :
        }

[Source]

    # File net/http.rb, line 640
        def HTTP.Proxy(p_addr, p_port = nil, p_user = nil, p_pass = nil)
          return self unless p_addr
          delta = ProxyDelta
          proxyclass = Class.new(self)
          proxyclass.module_eval {
            include delta
            # with proxy
            @is_proxy_class = true
            @proxy_address = p_addr
            @proxy_port    = p_port || default_port()
            @proxy_user    = p_user
            @proxy_pass    = p_pass
          }
          proxyclass
        end

default_port()

The default port to use for HTTP requests; defaults to 80.

[Source]

    # File net/http.rb, line 414
        def HTTP.default_port
          http_default_port()
        end

get(uri_or_host, path = nil, port = nil)

Send a GET request to the target and return the response as a string. The target can either be specified as (`uri`), or as (`host`, `path`, `port` = 80); so:

       print Net::HTTP.get(URI.parse('http://www.example.com/index.html'))

or:

       print Net::HTTP.get('www.example.com', '/index.html')

[Source]

    # File net/http.rb, line 355
        def HTTP.get(uri_or_host, path = nil, port = nil)
          get_response(uri_or_host, path, port).body
        end

get_print(uri_or_host, path = nil, port = nil)

Get body from target and output it to +$stdout+. The target can either be specified as (`uri`), or as (`host`, `path`, `port` = 80); so:

       Net::HTTP.get_print URI.parse('http://www.example.com/index.html')

or:

       Net::HTTP.get_print 'www.example.com', '/index.html'

[Source]

    # File net/http.rb, line 336
        def HTTP.get_print(uri_or_host, path = nil, port = nil)
          get_response(uri_or_host, path, port) {|res|
            res.read_body do |chunk|
              $stdout.print chunk
            end
          }
          nil
        end

get_response(uri_or_host, path = nil, port = nil, &block)

Send a GET request to the target and return the response as a Net::HTTPResponse object. The target can either be specified as (`uri`), or as (`host`, `path`, `port` = 80); so:

       res = Net::HTTP.get_response(URI.parse('http://www.example.com/index.html'))
       print res.body

or:

       res = Net::HTTP.get_response('www.example.com', '/index.html')
       print res.body

[Source]

    # File net/http.rb, line 371
        def HTTP.get_response(uri_or_host, path = nil, port = nil, &block)
          if path
            host = uri_or_host
            new(host, port || HTTP.default_port).start {|http|
              return http.request_get(path, &block)
            }
          else
            uri = uri_or_host
            new(uri.host, uri.port).start {|http|
              return http.request_get(uri.request_uri, &block)
            }
          end
        end

http_default_port()

The default port to use for HTTP requests; defaults to 80.

[Source]

    # File net/http.rb, line 419
        def HTTP.http_default_port
          80
        end

https_default_port()

The default port to use for HTTPS requests; defaults to 443.

[Source]

    # File net/http.rb, line 424
        def HTTP.https_default_port
          443
        end

new(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil)

Creates a new Net::HTTP object. If `proxy_addr` is given, creates an Net::HTTP object with proxy support. This method does not open the TCP connection.

[Source]

    # File net/http.rb, line 450
        def HTTP.new(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil)
          h = Proxy(p_addr, p_port, p_user, p_pass).newobj(address, port)
          h.instance_eval {
            @newimpl = ::Net::HTTP.version_1_2?
          }
          h
        end

new(address, port = nil)

Creates a new Net::HTTP object for the specified `address`. This method does not open the TCP connection.

[Source]

    # File net/http.rb, line 460
        def initialize(address, port = nil)
          @address = address
          @port    = (port || HTTP.default_port)
          @curr_http_version = HTTPVersion
          @seems_1_0_server = false
          @close_on_empty_response = false
          @socket  = nil
          @started = false
          @open_timeout = nil
          @read_timeout = 60
          @debug_output = nil
          @use_ssl = false
          @ssl_context = nil
        end

post_form(url, params)

Posts HTML form data to the `URL`. Form data must be represented as a Hash of String to String, e.g:

      { "cmd" => "search", "q" => "ruby", "max" => "50" }

This method also does Basic Authentication iff `URL`.user exists.

Example:

      require 'net/http'
      require 'uri'

      HTTP.post_form URI.parse('http://www.example.com/search.cgi'),
                     { "q" => "ruby", "max" => "50" }

[Source]

    # File net/http.rb, line 400
        def HTTP.post_form(url, params)
          req = Post.new(url.path)
          req.form_data = params
          req.basic_auth url.user, url.password if url.user
          new(url.host, url.port).start {|http|
            http.request(req)
          }
        end

proxy_class?()

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

[Source]

    # File net/http.rb, line 658
          def proxy_class?
            @is_proxy_class
          end

start(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil) {|+http+| ...}

creates a new Net::HTTP object and opens its TCP connection and HTTP session. If the optional block is given, the newly created Net::HTTP object is passed to it and closed when the block finishes. In this case, the return value of this method is the return value of the block. If no block is given, the return value of this method is the newly created Net::HTTP object itself, and the caller is responsible for closing it upon completion.

[Source]

    # File net/http.rb, line 439
        def HTTP.start(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil, &block) # :yield: +http+
          new(address, port, p_addr, p_port, p_user, p_pass).start(&block)
        end

version_1_1()

Turns on net/http 1.1 (ruby 1.6) features. Defaults to OFF in ruby 1.8.

[Source]

    # File net/http.rb, line 300
        def HTTP.version_1_1
          @newimpl = false
        end

version_1_1?()

true if net/http is in version 1.1 compatible mode. Defaults to true.

[Source]

    # File net/http.rb, line 312
        def HTTP.version_1_1?
          not @newimpl
        end

version_1_2()

Turns on net/http 1.2 (ruby 1.8) features. Defaults to ON in ruby 1.8.

I strongly recommend to call this method always.

      require 'net/http'
      Net::HTTP.version_1_2

[Source]

    # File net/http.rb, line 294
        def HTTP.version_1_2
          @newimpl = true
        end

version_1_2?()

true if net/http is in version 1.2 mode. Defaults to true.

[Source]

    # File net/http.rb, line 306
        def HTTP.version_1_2?
          @newimpl
        end

### Public Instance methods

active?()

Alias for started?

copy(path, initheader = nil)

Sends a COPY request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 902
        def copy(path, initheader = nil)
          request(Copy.new(path, initheader))
        end

delete(path, initheader = {'Depth' => 'Infinity'})

Sends a DELETE request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 890
        def delete(path, initheader = {'Depth' => 'Infinity'})
          request(Delete.new(path, initheader))
        end

finish()

Finishes HTTP session and closes TCP connection. Raises IOError if not started.

[Source]

    # File net/http.rb, line 600
        def finish
          raise IOError, 'HTTP session not yet started' unless started?
          do_finish
        end

get(path, initheader = nil, dest = nil) {|+body_segment+| ...}

Gets data from `path` on the connected-to host. `header` must be a Hash like { ‘Accept’ => ’*/*’, … }.

In version 1.1 (ruby 1.6), this method returns a pair of objects, a Net::HTTPResponse object and the entity body string. In version 1.2 (ruby 1.8), this method returns a Net::HTTPResponse object.

If called with a block, yields each fragment of the entity body in turn as a string as it is read from the socket. Note that in this case, the returned response object will not contain a (meaningful) body.

`dest` argument is obsolete. It still works but you must not use it.

In version 1.1, this method might raise an exception for 3xx (redirect). In this case you can get a HTTPResponse object by "anException.response".

In version 1.2, this method never raises exception.

        # version 1.1 (bundled with Ruby 1.6)
        response, body = http.get('/index.html')

        # version 1.2 (bundled with Ruby 1.8 or later)
        response = http.get('/index.html')

        # using block
        File.open('result.txt', 'w') {|f|
          http.get('/~foo/') do |str|
            f.write str
          end
        }

[Source]

    # File net/http.rb, line 769
        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
          }
          unless @newimpl
            res.value
            return res, res.body
          end

          res
        end

get2(path, initheader = nil)

Alias for request_get

head(path, initheader = nil)

Gets only the header from `path` on the connected-to host. `header` is a Hash like { ‘Accept’ => ’*/*’, … }.

This method returns a Net::HTTPResponse object.

In version 1.1, this method might raise an exception for 3xx (redirect). On the case you can get a HTTPResponse object by "anException.response". In version 1.2, this method never raises an exception.

        response = nil
        Net::HTTP.start('some.www.server', 80) {|http|
          response = http.head('/index.html')
        }
        p response['content-type']

[Source]

    # File net/http.rb, line 799
        def head(path, initheader = nil)
          res = request(Head.new(path, initheader))
          res.value unless @newimpl
          res
        end

head2(path, initheader = nil, &block)

Alias for request_head

inspect()

[Source]

    # File net/http.rb, line 475
        def inspect
          "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
        end

lock(path, body, initheader = nil)

Sends a LOCK request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 866
        def lock(path, body, initheader = nil)
          request(Lock.new(path, initheader), body)
        end

mkcol(path, body = nil, initheader = nil)

Sends a MKCOL request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 908
        def mkcol(path, body = nil, initheader = nil)
          request(Mkcol.new(path, initheader), body)
        end

move(path, initheader = nil)

Sends a MOVE request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 896
        def move(path, initheader = nil)
          request(Move.new(path, initheader))
        end

options(path, initheader = nil)

Sends a OPTIONS request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 878
        def options(path, initheader = nil)
          request(Options.new(path, initheader))
        end

post(path, data, initheader = nil, dest = nil) {|+body_segment+| ...}

Posts `data` (must be a String) to `path`. `header` must be a Hash like { ‘Accept’ => ’*/*’, … }.

In version 1.1 (ruby 1.6), this method returns a pair of objects, a Net::HTTPResponse object and an entity body string. In version 1.2 (ruby 1.8), this method returns a Net::HTTPResponse object.

If called with a block, yields each fragment of the entity body in turn as a string as it are read from the socket. Note that in this case, the returned response object will not contain a (meaningful) body.

`dest` argument is obsolete. It still works but you must not use it.

In version 1.1, this method might raise an exception for 3xx (redirect). In this case you can get an HTTPResponse object by "anException.response". In version 1.2, this method never raises exception.

        # version 1.1
        response, body = http.post('/cgi-bin/search.rb', 'query=foo')

        # version 1.2
        response = http.post('/cgi-bin/search.rb', 'query=foo')

        # using block
        File.open('result.txt', 'w') {|f|
          http.post('/cgi-bin/search.rb', 'query=foo') do |str|
            f.write str
          end
        }

[Source]

    # File net/http.rb, line 838
        def post(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
          res = nil
          request(Post.new(path, initheader), data) {|r|
            r.read_body dest, &block
            res = r
          }
          unless @newimpl
            res.value
            return res, res.body
          end

          res
        end

post2(path, data, initheader = nil)

Alias for request_post

propfind(path, body = nil, initheader = {'Depth' => '0'})

Sends a PROPFIND request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 884
        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 `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 860
        def proppatch(path, body, initheader = nil)
          request(Proppatch.new(path, initheader), body)
        end

proxy?()

True if self is a HTTP proxy class.

[Source]

    # File net/http.rb, line 669
        def proxy?
          self.class.proxy_class?
        end

proxy_address()

Address of proxy host. If self does not use a proxy, nil.

[Source]

    # File net/http.rb, line 674
        def proxy_address
          self.class.proxy_address
        end

proxy_pass()

User password for accessing proxy. If self does not use a proxy, nil.

[Source]

    # File net/http.rb, line 689
        def proxy_pass
          self.class.proxy_pass
        end

proxy_port()

Port number of proxy host. If self does not use a proxy, nil.

[Source]

    # File net/http.rb, line 679
        def proxy_port
          self.class.proxy_port
        end

proxy_user()

User name for accessing proxy. If self does not use a proxy, nil.

[Source]

    # File net/http.rb, line 684
        def proxy_user
          self.class.proxy_user
        end

proxyaddr()

Alias for proxy_address

proxyport()

Alias for proxy_port

read_timeout=(sec)

Setter for the read_timeout attribute.

[Source]

    # File net/http.rb, line 510
        def read_timeout=(sec)
          @socket.read_timeout = sec if @socket
          @read_timeout = sec
        end

request(req, body = nil) {|+response+| ...}

Sends an HTTPRequest object REQUEST to the HTTP server. This method also sends DATA string if REQUEST is a post/put request. Giving DATA for get/head request causes ArgumentError.

When called with a block, yields an HTTPResponse object. The body of this response will not have been read yet; the caller can process it using HTTPResponse#read_body, if desired.

Returns a HTTPResponse object.

This method never raises Net::* exceptions.

[Source]

    # File net/http.rb, line 1029
        def request(req, body = nil, &block)  # :yield: +response+
          unless started?
            start {
              req['connection'] ||= 'close'
              return request(req, body, &block)
            }
          end
          if proxy_user()
            unless use_ssl?
              req.proxy_basic_auth proxy_user(), proxy_pass()
            end
          end

          req.set_body_internal body
          begin_transport req
            req.exec @socket, @curr_http_version, edit_path(req.path)
            begin
              res = HTTPResponse.read_new(@socket)
            end while res.kind_of?(HTTPContinue)
            res.reading_body(@socket, req.response_body_permitted?) {
              yield res if block_given?
            }
          end_transport req, res

          res
        end

request_get(path, initheader = nil) {|+response+| ...}

Sends a GET request to the `path` and gets a response, as an HTTPResponse object.

When called with a block, yields an HTTPResponse object. The body of this response will not have been read yet; the caller can process it using HTTPResponse#read_body, if desired.

Returns the response.

This method never raises Net::* exceptions.

        response = http.request_get('/index.html')
        # The entity body is already read here.
        p response['content-type']
        puts response.body

        # using block
        http.request_get('/index.html') {|response|
          p response['content-type']
          response.read_body do |str|   # read body now
            print str
          end
        }

[Source]

    # File net/http.rb, line 943
        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 `path` and gets a response, as an HTTPResponse object.

Returns the response.

This method never raises Net::* exceptions.

        response = http.request_head('/index.html')
        p response['content-type']

[Source]

    # File net/http.rb, line 957
        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 `path` and gets a response, as an HTTPResponse object.

When called with a block, yields an HTTPResponse object. The body of this response will not have been read yet; the caller can process it using HTTPResponse#read_body, if desired.

Returns the response.

This method never raises Net::* exceptions.

        # example
        response = http.request_post('/cgi-bin/nice.rb', 'datadatadata...')
        p response.status
        puts response.body          # body is already read

        # using block
        http.request_post('/cgi-bin/nice.rb', 'datadatadata...') {|response|
          p response.status
          p response['content-type']
          response.read_body do |str|   # read body now
            print str
          end
        }

[Source]

    # File net/http.rb, line 987
        def request_post(path, data, initheader = nil, &block) # :yield: +response+
          request Post.new(path, initheader), data, &block
        end

send_request(name, path, data = nil, header = nil)

Sends an HTTP request to the HTTP server. This method also sends DATA string if DATA is given.

Returns a HTTPResponse object.

This method never raises Net::* exceptions.

       response = http.send_request('GET', '/index.html')
       puts response.body

[Source]

    # File net/http.rb, line 1011
        def send_request(name, path, data = nil, header = nil)
          r = HTTPGenericRequest.new(name,(data ? true : false),true,path,header)
          request r, data
        end

set_debug_output(output)

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

Set an output stream for debugging.

      http = Net::HTTP.new
      http.set_debug_output $stderr
      http.start { .... }

[Source]

    # File net/http.rb, line 488
        def set_debug_output(output)
          warn 'Net::HTTP#set_debug_output called after HTTP started' if started?
          @debug_output = output
        end

start( {|http| ...}

Opens TCP connection and HTTP session.

When this method is called with block, gives a HTTP object to the block and closes the TCP connection / HTTP session after the block executed.

When called with a block, returns the return value of the block; otherwise, returns self.

[Source]

    # File net/http.rb, line 540
        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 is started.

[Source]

    # File net/http.rb, line 516
        def started?
          @started
        end

trace(path, initheader = nil)

Sends a TRACE request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 914
        def trace(path, initheader = nil)
          request(Trace.new(path, initheader))
        end

unlock(path, body, initheader = nil)

Sends a UNLOCK request to the `path` and gets a response, as an HTTPResponse object.

[Source]

    # File net/http.rb, line 872
        def unlock(path, body, initheader = nil)
          request(Unlock.new(path, initheader), body)
        end

use_ssl()

Alias for use_ssl?

use_ssl?()

returns true if use SSL/TLS with HTTP.

[Source]

    # File net/http.rb, line 525
        def use_ssl?
          @use_ssl
        end

[Validate]