Class Net::HTTP
In: lib/net/https.rb
lib/net/http.rb
Parent: Object

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| 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

D   Proxy   active?   addr_port   begin_transport   conn_address   conn_port   connect   copy   default_port   delete   do_finish   do_start   edit_path   end_transport   finish   get   get   get2   get_print   get_response   head   head2   http_default_port   https_default_port   inspect   keep_alive?   lock   mkcol   move   new   new   on_connect   options   peer_cert   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   ssl_context_accessor   ssl_timeout   ssl_timeout=   start   start   started?   timeout=   trace   unlock   use_ssl   use_ssl=   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 lib/net/http.rb, line 638
638:     def HTTP.Proxy(p_addr, p_port = nil, p_user = nil, p_pass = nil)
639:       return self unless p_addr
640:       delta = ProxyDelta
641:       proxyclass = Class.new(self)
642:       proxyclass.module_eval {
643:         include delta
644:         # with proxy
645:         @is_proxy_class = true
646:         @proxy_address = p_addr
647:         @proxy_port    = p_port || default_port()
648:         @proxy_user    = p_user
649:         @proxy_pass    = p_pass
650:       }
651:       proxyclass
652:     end
default_port()

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

[Source]

     # File lib/net/http.rb, line 414
414:     def HTTP.default_port
415:       http_default_port()
416:     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 lib/net/http.rb, line 355
355:     def HTTP.get(uri_or_host, path = nil, port = nil)
356:       get_response(uri_or_host, path, port).body
357:     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 lib/net/http.rb, line 336
336:     def HTTP.get_print(uri_or_host, path = nil, port = nil)
337:       get_response(uri_or_host, path, port) {|res|
338:         res.read_body do |chunk|
339:           $stdout.print chunk
340:         end
341:       }
342:       nil
343:     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 lib/net/http.rb, line 371
371:     def HTTP.get_response(uri_or_host, path = nil, port = nil, &block)
372:       if path
373:         host = uri_or_host
374:         new(host, port || HTTP.default_port).start {|http|
375:           return http.request_get(path, &block)
376:         }
377:       else
378:         uri = uri_or_host
379:         new(uri.host, uri.port).start {|http|
380:           return http.request_get(uri.request_uri, &block)
381:         }
382:       end
383:     end
http_default_port()

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

[Source]

     # File lib/net/http.rb, line 419
419:     def HTTP.http_default_port
420:       80
421:     end
https_default_port()

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

[Source]

     # File lib/net/http.rb, line 424
424:     def HTTP.https_default_port
425:       443
426:     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 lib/net/http.rb, line 450
450:     def HTTP.new(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil)
451:       h = Proxy(p_addr, p_port, p_user, p_pass).newobj(address, port)
452:       h.instance_eval {
453:         @newimpl = ::Net::HTTP.version_1_2?
454:       }
455:       h
456:     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 lib/net/http.rb, line 460
460:     def initialize(address, port = nil)
461:       @address = address
462:       @port    = (port || HTTP.default_port)
463:       @curr_http_version = HTTPVersion
464:       @seems_1_0_server = false
465:       @close_on_empty_response = false
466:       @socket  = nil
467:       @started = false
468:       @open_timeout = nil
469:       @read_timeout = 60
470:       @debug_output = nil
471:       @use_ssl = false
472:       @ssl_context = nil
473:     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 lib/net/http.rb, line 400
400:     def HTTP.post_form(url, params)
401:       req = Post.new(url.path)
402:       req.form_data = params
403:       req.basic_auth url.user, url.password if url.user
404:       new(url.host, url.port).start {|http|
405:         http.request(req)
406:       }
407:     end
proxy_class?()

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

[Source]

     # File lib/net/http.rb, line 656
656:       def proxy_class?
657:         @is_proxy_class
658:       end
ssl_context_accessor(name)

[Source]

     # File lib/net/https.rb, line 129
129:     def self.ssl_context_accessor(name)
130:       module_eval("def \#{name}\nreturn nil unless @ssl_context\n@ssl_context.\#{name}\nend\n\ndef \#{name}=(val)\n@ssl_context ||= OpenSSL::SSL::SSLContext.new\n@ssl_context.\#{name} = val\nend\n", __FILE__, __LINE__ + 1)
131:     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 lib/net/http.rb, line 439
439:     def HTTP.start(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil, &block) # :yield: +http+
440:       new(address, port, p_addr, p_port, p_user, p_pass).start(&block)
441:     end
version_1_1()

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

[Source]

     # File lib/net/http.rb, line 300
300:     def HTTP.version_1_1
301:       @newimpl = false
302:     end
version_1_1?()

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

[Source]

     # File lib/net/http.rb, line 312
312:     def HTTP.version_1_1?
313:       not @newimpl
314:     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 lib/net/http.rb, line 294
294:     def HTTP.version_1_2
295:       @newimpl = true
296:     end
version_1_2?()

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

[Source]

     # File lib/net/http.rb, line 306
306:     def HTTP.version_1_2?
307:       @newimpl
308:     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 lib/net/http.rb, line 903
903:     def copy(path, initheader = nil)
904:       request(Copy.new(path, initheader))
905:     end
delete(path, initheader = {'Depth' => 'Infinity'})

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

[Source]

     # File lib/net/http.rb, line 891
891:     def delete(path, initheader = {'Depth' => 'Infinity'})
892:       request(Delete.new(path, initheader))
893:     end
finish()

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

[Source]

     # File lib/net/http.rb, line 598
598:     def finish
599:       raise IOError, 'HTTP session not yet started' unless started?
600:       do_finish
601:     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 lib/net/http.rb, line 767
767:     def get(path, initheader = nil, dest = nil, &block) # :yield: +body_segment+
768:       res = nil
769:       request(Get.new(path, initheader)) {|r|
770:         r.read_body dest, &block
771:         res = r
772:       }
773:       unless @newimpl
774:         res.value
775:         return res, res.body
776:       end
777: 
778:       res
779:     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 lib/net/http.rb, line 797
797:     def head(path, initheader = nil) 
798:       res = request(Head.new(path, initheader))
799:       res.value unless @newimpl
800:       res
801:     end
head2(path, initheader = nil, &block)

Alias for request_head

inspect()

[Source]

     # File lib/net/http.rb, line 475
475:     def inspect
476:       "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
477:     end
lock(path, body, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 867
867:     def lock(path, body, initheader = nil)
868:       request(Lock.new(path, initheader), body)
869:     end
mkcol(path, body = nil, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 909
909:     def mkcol(path, body = nil, initheader = nil)
910:       request(Mkcol.new(path, initheader), body)
911:     end
move(path, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 897
897:     def move(path, initheader = nil)
898:       request(Move.new(path, initheader))
899:     end
options(path, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 879
879:     def options(path, initheader = nil)
880:       request(Options.new(path, initheader))
881:     end
peer_cert()

[Source]

     # File lib/net/https.rb, line 168
168:     def peer_cert
169:       return nil if not use_ssl? or not @socket
170:       @socket.io.peer_cert
171:     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
    }

You should set Content-Type: header field for POST. If no Content-Type: field given, this method uses "application/x-www-form-urlencoded" by default.

[Source]

     # File lib/net/http.rb, line 840
840:     def post(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
841:       res = nil
842:       request(Post.new(path, initheader), data) {|r|
843:         r.read_body dest, &block
844:         res = r
845:       }
846:       unless @newimpl
847:         res.value
848:         return res, res.body
849:       end
850:       res
851:     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 lib/net/http.rb, line 885
885:     def propfind(path, body = nil, initheader = {'Depth' => '0'})
886:       request(Propfind.new(path, initheader), body)
887:     end
proppatch(path, body, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 861
861:     def proppatch(path, body, initheader = nil)
862:       request(Proppatch.new(path, initheader), body)
863:     end
proxy?()

True if self is a HTTP proxy class.

[Source]

     # File lib/net/http.rb, line 667
667:     def proxy?
668:       self.class.proxy_class?
669:     end
proxy_address()

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

[Source]

     # File lib/net/http.rb, line 672
672:     def proxy_address
673:       self.class.proxy_address
674:     end
proxy_pass()

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

[Source]

     # File lib/net/http.rb, line 687
687:     def proxy_pass
688:       self.class.proxy_pass
689:     end
proxy_port()

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

[Source]

     # File lib/net/http.rb, line 677
677:     def proxy_port
678:       self.class.proxy_port
679:     end
proxy_user()

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

[Source]

     # File lib/net/http.rb, line 682
682:     def proxy_user
683:       self.class.proxy_user
684:     end
proxyaddr()

Alias for proxy_address

proxyport()

Alias for proxy_port

read_timeout=(sec)

Setter for the read_timeout attribute.

[Source]

     # File lib/net/http.rb, line 510
510:     def read_timeout=(sec)
511:       @socket.read_timeout = sec if @socket
512:       @read_timeout = sec
513:     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 lib/net/http.rb, line 1030
1030:     def request(req, body = nil, &block)  # :yield: +response+
1031:       unless started?
1032:         start {
1033:           req['connection'] ||= 'close'
1034:           return request(req, body, &block)
1035:         }
1036:       end
1037:       if proxy_user()
1038:         unless use_ssl?
1039:           req.proxy_basic_auth proxy_user(), proxy_pass()
1040:         end
1041:       end
1042: 
1043:       req.set_body_internal body
1044:       begin_transport req
1045:         req.exec @socket, @curr_http_version, edit_path(req.path)
1046:         begin
1047:           res = HTTPResponse.read_new(@socket)
1048:         end while res.kind_of?(HTTPContinue)
1049:         res.reading_body(@socket, req.response_body_permitted?) {
1050:           yield res if block_given?
1051:         }
1052:       end_transport req, res
1053: 
1054:       res
1055:     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 lib/net/http.rb, line 944
944:     def request_get(path, initheader = nil, &block) # :yield: +response+
945:       request(Get.new(path, initheader), &block)
946:     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 lib/net/http.rb, line 958
958:     def request_head(path, initheader = nil, &block)
959:       request(Head.new(path, initheader), &block)
960:     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 lib/net/http.rb, line 988
988:     def request_post(path, data, initheader = nil, &block) # :yield: +response+
989:       request Post.new(path, initheader), data, &block
990:     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 lib/net/http.rb, line 1012
1012:     def send_request(name, path, data = nil, header = nil)
1013:       r = HTTPGenericRequest.new(name,(data ? true : false),true,path,header)
1014:       request r, data
1015:     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 lib/net/http.rb, line 488
488:     def set_debug_output(output)
489:       warn 'Net::HTTP#set_debug_output called after HTTP started' if started?
490:       @debug_output = output
491:     end
ssl_timeout()

[Source]

     # File lib/net/https.rb, line 153
153:     def ssl_timeout
154:       return nil unless @ssl_context
155:       @ssl_context.timeout
156:     end
ssl_timeout=(sec)

[Source]

     # File lib/net/https.rb, line 158
158:     def ssl_timeout=(sec)
159:       raise ArgumentError, 'Net::HTTP#ssl_timeout= called but use_ssl=false' \
160:           unless use_ssl?
161:       @ssl_context ||= OpenSSL::SSL::SSLContext.new
162:       @ssl_context.timeout = sec
163:     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 lib/net/http.rb, line 538
538:     def start  # :yield: http
539:       raise IOError, 'HTTP session already opened' if @started
540:       if block_given?
541:         begin
542:           do_start
543:           return yield(self)
544:         ensure
545:           do_finish
546:         end
547:       end
548:       do_start
549:       self
550:     end
started?()

returns true if the HTTP session is started.

[Source]

     # File lib/net/http.rb, line 516
516:     def started?
517:       @started
518:     end
timeout=(sec)

Alias for ssl_timeout=

trace(path, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 915
915:     def trace(path, initheader = nil)
916:       request(Trace.new(path, initheader))
917:     end
unlock(path, body, initheader = nil)

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

[Source]

     # File lib/net/http.rb, line 873
873:     def unlock(path, body, initheader = nil)
874:       request(Unlock.new(path, initheader), body)
875:     end
use_ssl()

Alias for use_ssl?

use_ssl=(flag)

Turn on/off SSL. This flag must be set before starting session. If you change use_ssl value after session started, a Net::HTTP object raises IOError.

[Source]

     # File lib/net/https.rb, line 119
119:     def use_ssl=(flag)
120:       flag = (flag ? true : false)
121:       raise IOError, "use_ssl value changed, but session already started" \
122:           if started? and @use_ssl != flag
123:       if flag and not @ssl_context
124:         @ssl_context = OpenSSL::SSL::SSLContext.new
125:       end
126:       @use_ssl = flag
127:     end
use_ssl?()

returns true if use SSL/TLS with HTTP.

[Source]

     # File lib/net/http.rb, line 525
525:     def use_ssl?
526:       false   # redefined in net/https
527:     end
use_ssl?()

[Source]

     # File lib/net/https.rb, line 108
108:     def use_ssl?
109:       @use_ssl
110:     end

Private Instance methods

D(msg)

[Source]

      # File lib/net/http.rb, line 1113
1113:     def D(msg)
1114:       return unless @debug_output
1115:       @debug_output << msg
1116:       @debug_output << "\n"
1117:     end
addr_port()

utils

[Source]

      # File lib/net/http.rb, line 1105
1105:     def addr_port
1106:       if use_ssl?
1107:         address() + (port == HTTP.https_default_port ? '' : ":#{port()}")
1108:       else
1109:         address() + (port == HTTP.http_default_port ? '' : ":#{port()}")
1110:       end
1111:     end
begin_transport(req)

[Source]

      # File lib/net/http.rb, line 1059
1059:     def begin_transport(req)
1060:       if @socket.closed?
1061:         connect
1062:       end
1063:       if @seems_1_0_server
1064:         req['connection'] ||= 'close'
1065:       end
1066:       if not req.response_body_permitted? and @close_on_empty_response
1067:         req['connection'] ||= 'close'
1068:       end
1069:       req['host'] ||= addr_port()
1070:     end
conn_address()

without proxy

[Source]

     # File lib/net/http.rb, line 698
698:     def conn_address
699:       address()
700:     end
conn_port()

[Source]

     # File lib/net/http.rb, line 702
702:     def conn_port
703:       port()
704:     end
connect()

[Source]

     # File lib/net/http.rb, line 558
558:     def connect
559:       D "opening connection to #{conn_address()}..."
560:       s = timeout(@open_timeout) { TCPSocket.open(conn_address(), conn_port()) }
561:       D "opened"
562:       if use_ssl?
563:         unless @ssl_context.verify_mode
564:           warn "warning: peer certificate won't be verified in this SSL session"
565:           @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
566:         end
567:         s = OpenSSL::SSL::SSLSocket.new(s, @ssl_context)
568:         s.sync_close = true
569:       end
570:       @socket = BufferedIO.new(s)
571:       @socket.read_timeout = @read_timeout
572:       @socket.debug_output = @debug_output
573:       if use_ssl?
574:         if proxy?
575:           @socket.writeline sprintf('CONNECT %s:%s HTTP/%s',
576:                                     @address, @port, HTTPVersion)
577:           @socket.writeline "Host: #{@address}:#{@port}"
578:           if proxy_user
579:             credential = ["#{proxy_user}:#{proxy_pass}"].pack('m')
580:             credential.delete!("\r\n")
581:             @socket.writeline "Proxy-Authorization: Basic #{credential}"
582:           end
583:           @socket.writeline ''
584:           HTTPResponse.read_new(@socket).value
585:         end
586:         s.connect
587:       end
588:       on_connect
589:     end
do_finish()

[Source]

     # File lib/net/http.rb, line 603
603:     def do_finish
604:       @started = false
605:       @socket.close if @socket and not @socket.closed?
606:       @socket = nil
607:     end
do_start()

[Source]

     # File lib/net/http.rb, line 552
552:     def do_start
553:       connect
554:       @started = true
555:     end
edit_path(path)

[Source]

     # File lib/net/http.rb, line 706
706:     def edit_path(path)
707:       path
708:     end
end_transport(req, res)

[Source]

      # File lib/net/http.rb, line 1072
1072:     def end_transport(req, res)
1073:       @curr_http_version = res.http_version
1074:       if not res.body and @close_on_empty_response
1075:         D 'Conn close'
1076:         @socket.close
1077:       elsif keep_alive?(req, res)
1078:         D 'Conn keep-alive'
1079:         if @socket.closed?
1080:           D 'Conn (but seems 1.0 server)'
1081:           @seems_1_0_server = true
1082:         end
1083:       else
1084:         D 'Conn close'
1085:         @socket.close
1086:       end
1087:     end
keep_alive?(req, res)

[Source]

      # File lib/net/http.rb, line 1089
1089:     def keep_alive?(req, res)
1090:       return false if /close/i =~ req['connection'].to_s
1091:       return false if @seems_1_0_server
1092:       return true  if /keep-alive/i =~ res['connection'].to_s
1093:       return false if /close/i      =~ res['connection'].to_s
1094:       return true  if /keep-alive/i =~ res['proxy-connection'].to_s
1095:       return false if /close/i      =~ res['proxy-connection'].to_s
1096:       (@curr_http_version == '1.1')
1097:     end
on_connect()

[Source]

     # File lib/net/http.rb, line 592
592:     def on_connect
593:     end

[Validate]