Net::HTTP类

require 'net/http'

Net::HTTP.get('example.com', '/index.html') # => String

uri = URI('http://example.com/index.html?count=10')
Net::HTTP.get(uri) # => String

uri = URI('http://example.com/index.html')
params = { :limit => 10, :page => 3 }
uri.query = URI.encode_www_form(params)

res = Net::HTTP.get_response(uri)
puts res.body if res.is_a?(Net::HTTPSuccess)

uri = URI('http://www.example.com/search.cgi')
res = Net::HTTP.post_form(uri, 'q' => 'ruby', 'max' => '50')
puts res.body

uri = URI('http://www.example.com/search.cgi')
res = Net::HTTP.post_form(uri, 'q' => ['ruby', 'perl'], 'max' => '50')
puts res.body

uri = URI('http://example.com/some_path?query=string')

Net::HTTP.start(uri.host, uri.port) do |http|
  request = Net::HTTP::Get.new uri

  response = http.request request # Net::HTTPResponse object
end

uri = URI('http://example.com/index.html')
res = Net::HTTP.get_response(uri)

# Headers
res['Set-Cookie']            # => String
res.get_fields('set-cookie') # => Array
res.to_hash['set-cookie']    # => Array
puts "Headers: #{res.to_hash.inspect}"

# Status
puts res.code       # => '200'
puts res.message    # => 'OK'
puts res.class.name # => 'HTTPOK'

# Body
puts res.body if res.response_body_permitted?

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

  response = Net::HTTP.get_response(URI(uri_str))

  case response
  when Net::HTTPSuccess then
    response
  when Net::HTTPRedirection then
    location = response['location']
    warn "redirected to #{location}"
    fetch(location, limit - 1)
  else
    response.value
  end
end

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

uri = URI('http://www.example.com/todo.cgi')
req = Net::HTTP::Post.new(uri)
req.set_form_data('from' => '2005-01-01', 'to' => '2005-03-31')

res = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(req)
end

case res
when Net::HTTPSuccess, Net::HTTPRedirection
  # OK
else
  res.value
end

req = Net::HTTP::Post.new(uri)
req.body = multipart_data
req.content_type = 'multipart/form-data'

uri = URI('http://example.com/cached_response')
file = File.stat 'cached_response'

req = Net::HTTP::Get.new(uri)
req['If-Modified-Since'] = file.mtime.rfc2822

res = Net::HTTP.start(uri.hostname, uri.port) {|http|
  http.request(req)
}

open 'cached_response', 'w' do |io|
  io.write res.body
end if res.is_a?(Net::HTTPSuccess)

uri = URI('http://example.com/index.html?key=value')

req = Net::HTTP::Get.new(uri)
req.basic_auth 'user', 'pass'

res = Net::HTTP.start(uri.hostname, uri.port) {|http|
  http.request(req)
}
puts res.body

uri = URI('http://example.com/large_file')

Net::HTTP.start(uri.host, uri.port) do |http|
  request = Net::HTTP::Get.new uri

  http.request request do |response|
    open 'large_file', 'w' do |io|
      response.read_body do |chunk|
        io.write chunk
      end
    end
  end
end

uri = URI('https://secure.example.com/some_path?query=string')

Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
  request = Net::HTTP::Get.new uri
  response = http.request request # Net::HTTPResponse object
end

uri = URI('https://example.com/')
Net::HTTP.get(uri) # => String

proxy_addr = 'your.proxy.host'
proxy_port = 8080

Net::HTTP.new('example.com', nil, proxy_addr, proxy_port).start { |http|
  # always proxy via your.proxy.addr:8080
}

-  [Net::HTTP::Get](http/get)

-  [Net::HTTP::Head](http/head)

-  [Net::HTTP::Post](http/post)

-  [Net::HTTP::Patch](http/patch)

-  [Net::HTTP::Put](http/put)

-  [Net::HTTP::Proppatch](http/proppatch)

-  [Net::HTTP::Lock](http/lock)

-  [Net::HTTP::Unlock](http/unlock)

-  [Net::HTTP::Options](http/options)

-  [Net::HTTP::Propfind](http/propfind)

-  [Net::HTTP::Delete](http/delete)

-  [Net::HTTP::Move](http/move)

-  [Net::HTTP::Copy](http/copy)

-  [Net::HTTP::Mkcol](http/mkcol)

-  [Net::HTTP::Trace](http/trace)

# File lib/net/http.rb, line 1004
def HTTP.Proxy(p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil)
  return self unless p_addr

  Class.new(self) {
    @is_proxy_class = true

    if p_addr == :ENV then
      @proxy_from_env = true
      @proxy_address = nil
      @proxy_port    = nil
    else
      @proxy_from_env = false
      @proxy_address = p_addr
      @proxy_port    = p_port || default_port
    end

    @proxy_user = p_user
    @proxy_pass = p_pass
  }
end

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

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

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

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

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

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

# File lib/net/http.rb, line 441
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

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

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

# File lib/net/http.rb, line 476
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
    start(uri.hostname, uri.port,
          :use_ssl => uri.scheme == 'https') {|http|
      return http.request_get(uri, &block)
    }
  end
end

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

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

# File lib/net/http.rb, line 633
def HTTP.new(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = 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
  elsif p_addr == :ENV then
    http.proxy_from_env = true
  else
    http.proxy_address = p_addr
    http.proxy_port    = p_port || default_port
    http.proxy_user    = p_user
    http.proxy_pass    = p_pass
  end

  http
end

# File lib/net/http.rb, line 657
def initialize(address, port = nil)
  @address = address
  @port    = (port || HTTP.default_port)
  @local_host = nil
  @local_port = nil
  @curr_http_version = HTTPVersion
  @keep_alive_timeout = 2
  @last_communicated = nil
  @close_on_empty_response = false
  @socket  = nil
  @started = false
  @open_timeout = 60
  @read_timeout = 60
  @continue_timeout = nil
  @debug_output = nil

  @proxy_from_env = false
  @proxy_uri      = nil
  @proxy_address  = nil
  @proxy_port     = nil
  @proxy_user     = nil
  @proxy_pass     = nil

  @use_ssl = false
  @ssl_context = nil
  @ssl_session = nil
  @sspi_enabled = false
  SSL_IVNAMES.each do |ivname|
    instance_variable_set ivname, nil
  end
end

require 'net/http'
require 'uri'

Net::HTTP.post URI('http://www.example.com/api/search'),
               { "q" => "ruby", "max" => "50" }.to_json,
               "Content-Type" => "application/json"

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

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

require 'net/http'
require 'uri'

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

# File lib/net/http.rb, line 527
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

# File lib/net/http.rb, line 1027
def proxy_class?
  defined?(@is_proxy_class) ? @is_proxy_class : false
end

# File lib/net/http.rb, line 590
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
  port = https_default_port if !port && opt && opt[:use_ssl]
  http = new(address, port, p_addr, p_port, p_user, p_pass)

  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

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

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

# File lib/net/http.rb, line 749
def continue_timeout=(sec)
  @socket.continue_timeout = sec if @socket
  @continue_timeout = sec
end

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

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

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

response = http.get('/index.html')

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

# File lib/net/http.rb, line 1162
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

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

# File lib/net/http.rb, line 1184
def head(path, initheader = nil)
  request(Head.new(path, initheader))
end

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

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

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

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

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

# File lib/net/http.rb, line 1222
def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  send_entity(path, data, initheader, dest, Patch, &block)
end

# File lib/net/http.rb, line 855
def peer_cert
  if not use_ssl? or not @socket
    return nil
  end
  @socket.io.peer_cert
end

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
}

# File lib/net/http.rb, line 1216
def post(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
  send_entity(path, data, initheader, dest, Post, &block)
end

# File lib/net/http.rb, line 1256
def propfind(path, body = nil, initheader = {'Depth' => '0'})
  request(Propfind.new(path, initheader), body)
end

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

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

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

# File lib/net/http.rb, line 1051
def proxy_from_env?
  @proxy_from_env
end

# File lib/net/http.rb, line 1088
def proxy_pass
  @proxy_pass
end

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

# File lib/net/http.rb, line 1083
def proxy_user
  @proxy_user
end

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

# File lib/net/http.rb, line 1404
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

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

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

# File lib/net/http.rb, line 1315
def request_get(path, initheader = nil, &block) # :yield: +response+
  request(Get.new(path, initheader), &block)
end

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

# File lib/net/http.rb, line 1329
def request_head(path, initheader = nil, &block)
  request(Head.new(path, initheader), &block)
end

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

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

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

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

# File lib/net/http.rb, line 1383
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

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

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

# File lib/net/http.rb, line 871
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

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

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

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

# File lib/net/http.rb, line 778
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

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

# File lib/net/http.rb, line 1573
def D(msg)
  return unless @debug_output
  @debug_output << msg
  @debug_output << "\n"
end

# File lib/net/http.rb, line 1565
def addr_port
  if use_ssl?
    address() + (port == HTTP.https_default_port ? '' : ":#{port()}")
  else
    address() + (port == HTTP.http_default_port ? '' : ":#{port()}")
  end
end

# File lib/net/http.rb, line 1482
def begin_transport(req)
  if @socket.closed?
    connect
  elsif @last_communicated
    if @last_communicated + @keep_alive_timeout < Process.clock_gettime(Process::CLOCK_MONOTONIC)
      D 'Conn close because of keep_alive_timeout'
      @socket.close
      connect
    elsif @socket.io.to_io.wait_readable(0) && @socket.eof?
      D "Conn close because of EOF"
      @socket.close
      connect
    end
  end

  if not req.response_body_permitted? and @close_on_empty_response
    req['connection'] ||= 'close'
  end

  req.update_uri address, port, use_ssl?
  req['host'] ||= addr_port()
end

# File lib/net/http.rb, line 891
def connect
  if proxy? then
    conn_address = proxy_address
    conn_port    = proxy_port
  else
    conn_address = address
    conn_port    = port
  end

  D "opening connection to #{conn_address}:#{conn_port}..."
  s = Timeout.timeout(@open_timeout, Net::OpenTimeout) {
    begin
      TCPSocket.open(conn_address, conn_port, @local_host, @local_port)
    rescue => e
      raise e, "Failed to open TCP connection to " +
        "#{conn_address}:#{conn_port} (#{e.message})"
    end
  }
  s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
  D "opened"
  if use_ssl?
    if proxy?
      plain_sock = BufferedIO.new(s, read_timeout: @read_timeout,
                                  continue_timeout: @continue_timeout,
                                  debug_output: @debug_output)
      buf = "CONNECT #{@address}:#{@port} HTTP/#{HTTPVersion}\r\n"
      buf << "Host: #{@address}:#{@port}\r\n"
      if proxy_user
        credential = ["#{proxy_user}:#{proxy_pass}"].pack('m0')
        buf << "Proxy-Authorization: Basic #{credential}\r\n"
      end
      buf << "\r\n"
      plain_sock.write(buf)
      HTTPResponse.read_new(plain_sock).value
      # assuming nothing left in buffers after successful CONNECT response
    end

    ssl_parameters = Hash.new
    iv_list = instance_variables
    SSL_IVNAMES.each_with_index do |ivname, i|
      if iv_list.include?(ivname) and
        value = instance_variable_get(ivname)
        ssl_parameters[SSL_ATTRIBUTES[i]] = value if value
      end
    end
    @ssl_context = OpenSSL::SSL::SSLContext.new
    @ssl_context.set_params(ssl_parameters)
    D "starting SSL for #{conn_address}:#{conn_port}..."
    s = OpenSSL::SSL::SSLSocket.new(s, @ssl_context)
    s.sync_close = true
    # Server Name Indication (SNI) RFC 3546
    s.hostname = @address if s.respond_to? :hostname=
    if @ssl_session and
       Process.clock_gettime(Process::CLOCK_REALTIME) < @ssl_session.time.to_f + @ssl_session.timeout
      s.session = @ssl_session if @ssl_session
    end
    ssl_socket_connect(s, @open_timeout)
    if @ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
      s.post_connection_check(@address)
    end
    @ssl_session = s.session
    D "SSL established"
  end
  @socket = BufferedIO.new(s, read_timeout: @read_timeout,
                           continue_timeout: @continue_timeout,
                           debug_output: @debug_output)
  on_connect
rescue => exception
  if s
    D "Conn close because of connect error #{exception}"
    s.close
  end
  raise
end

# File lib/net/http.rb, line 978
def do_finish
  @started = false
  @socket.close if @socket
  @socket = nil
end

# File lib/net/http.rb, line 885
def do_start
  connect
  @started = true
end

# File lib/net/http.rb, line 1107
def edit_path(path)
  if proxy?
    if path.start_with?("ftp://") || use_ssl?
      path
    else
      "http://#{addr_port}#{path}"
    end
  else
    path
  end
end

# File lib/net/http.rb, line 1505
def end_transport(req, res)
  @curr_http_version = res.http_version
  @last_communicated = nil
  if @socket.closed?
    D 'Conn socket closed'
  elsif not res.body and @close_on_empty_response
    D 'Conn close'
    @socket.close
  elsif keep_alive?(req, res)
    D 'Conn keep-alive'
    @last_communicated = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  else
    D 'Conn close'
    @socket.close
  end
end

# File lib/net/http.rb, line 1522
def keep_alive?(req, res)
  return false if req.connection_close?
  if @curr_http_version <= '1.0'
    res.connection_keep_alive?
  else   # HTTP/1.1 or later
    not res.connection_close?
  end
end

# File lib/net/http.rb, line 967
def on_connect
end

# File lib/net/http.rb, line 1427
def send_entity(path, data, initheader, dest, type, &block)
  res = nil
  request(type.new(path, initheader), data) {|r|
    r.read_body dest, &block
    res = r
  }
  res
end

# File lib/net/http.rb, line 1546
def sspi_auth(req)
  n = Win32::SSPI::NegotiateAuth.new
  req["Proxy-Authorization"] = "Negotiate #{n.get_initial_token}"
  # Some versions of ISA will close the connection if this isn't present.
  req["Connection"] = "Keep-Alive"
  req["Proxy-Connection"] = "Keep-Alive"
  res = transport_request(req)
  authphrase = res["Proxy-Authenticate"]  or return res
  req["Proxy-Authorization"] = "Negotiate #{n.complete_authentication(authphrase)}"
rescue => err
  raise HTTPAuthenticationError.new('HTTP authentication failed', err)
end

# File lib/net/http.rb, line 1531
def sspi_auth?(res)
  return false unless @sspi_enabled
  if res.kind_of?(HTTPProxyAuthenticationRequired) and
      proxy? and res["Proxy-Authenticate"].include?("Negotiate")
    begin
      require 'win32/sspi'
      true
    rescue LoadError
      false
    end
  else
    false
  end
end

# File lib/net/http.rb, line 1438
def transport_request(req)
  count = 0
  begin
    begin_transport req
    res = catch(:response) {
      req.exec @socket, @curr_http_version, edit_path(req.path)
      begin
        res = HTTPResponse.read_new(@socket)
        res.decode_content = req.decode_content
      end while res.kind_of?(HTTPInformation)

      res.uri = req.uri

      res
    }
    res.reading_body(@socket, req.response_body_permitted?) {
      yield res if block_given?
    }
  rescue Net::OpenTimeout
    raise
  rescue Net::ReadTimeout, IOError, EOFError,
         Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE,
         # avoid a dependency on OpenSSL
         defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : IOError,
         Timeout::Error => exception
    if count == 0 && IDEMPOTENT_METHODS_.include?(req.method)
      count += 1
      @socket.close if @socket
      D "Conn close because of error #{exception}, and retry"
      retry
    end
    D "Conn close because of error #{exception}"
    @socket.close if @socket
    raise
  end

  end_transport req, res
  res
rescue => exception
  D "Conn close because of error #{exception}"
  @socket.close if @socket
  raise exception
end