класс Net::HTTP

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

Возвращает целое число 80, стандартный порт для HTTP запросов:

Net::HTTP.default_port # => 80

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

Отправляет запрос GET и возвращает тело HTTP-ответа в виде строки.

С использованием строковых аргументов hostname и path:

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

Вывод:

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

С объектом URI uri и необязательным аргументом-словарём headers:

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

Связанные:

• Net::HTTP::Get: класс запроса для HTTP-метода GET.

• Net::HTTP#get: удобный метод для HTTP-метода GET.

# File lib/net/http.rb, line 419
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, но записывает возвращаемое тело в $stdout; возвращает nil.

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

Аналогично Net::HTTP.get, но возвращает объект Net::HTTPResponse вместо строки тела.

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

Возвращает целое число 80, стандартный порт для HTTP запросов:

Net::HTTP.http_default_port # => 80

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

Возвращает целое число 443, стандартный порт для запросов HTTPS:

Net::HTTP.https_default_port # => 443

# File lib/net/http.rb, line 802
def HTTP.new(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, p_no_proxy = 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
    if p_addr && p_no_proxy && !URI::Generic.use_proxy?(p_addr, p_addr, p_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
  end

  http
end

Возвращает новый объект Net::HTTP http (но не открывает TCP-соединение или HTTP сеанс).

Без прокси

Если передан только строковый аргумент hostname (и ENV['http_proxy'] не определен или nil), возвращаемый объект http:

• Имеет заданный адрес.

• Имеет стандартный номер порта, Net::HTTP.default_port (80).

• Не имеет прокси.

Пример:

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

Если также передан целочисленный аргумент port, возвращаемый объект http имеет заданный порт:

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

Прокси, используя аргумент p_addr как строку

Если аргумент p_addr является строковым именем хоста, возвращаемый объект http имеет прокси:

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

Порт, имя пользователя и пароль для прокси также могут быть указаны:

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

Прокси, используя ENV['http_proxy']

Если переменная окружения 'http_proxy' установлена в строку URI, возвращаемый объект http будет иметь этот URI в качестве прокси; обратите внимание, что строка URI должна иметь протокол, такой как 'http' или 'https':

ENV['http_proxy'] = 'http://example.com'
# => "http://example.com"
http = Net::HTTP.new(hostname)
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.proxy?        # => true
http.address       # => "jsonplaceholder.typicode.com"
http.proxy_address # => "example.com"

Строка URI может включать имя пользователя прокси, пароль и номер порта:

ENV['http_proxy'] = 'http://pname:ppass@example.com:8000'
# => "http://pname:ppass@example.com:8000"
http = Net::HTTP.new(hostname)
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.proxy_port # => 8000
http.proxy_user # => "pname"
http.proxy_pass # => "ppass"

Аргумент p_no_proxy

Вы можете использовать аргумент p_no_proxy для отклонения определённых прокси:

• Отклонить определённый адрес:

  http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'proxy.example')
  http.proxy_address # => nil
  

• Отклонить определённые домены или поддомены:

  http = Net::HTTP.new('example.com', nil, 'my.proxy.example', 8000, 'pname', 'ppass', 'proxy.example')
  http.proxy_address # => nil
  

• Отклонить определённые сочетания адресов и портов:

  http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'proxy.example:1234')
  http.proxy_address # => "proxy.example"
  
  http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'proxy.example:8000')
  http.proxy_address # => nil
  

• Отклонить список вышеперечисленных типов, разделённых запятыми:

  http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'my.proxy,proxy.example:8000')
  http.proxy_address # => nil
  
  http = Net::HTTP.new('example.com', nil, 'my.proxy', 8000, 'pname', 'ppass', 'my.proxy,proxy.example:8000')
  http.proxy_address # => nil
  

# File lib/net/http.rb, line 830
def initialize(address, port = nil)
  @address = address
  @port    = (port || HTTP.default_port)
  @ipaddr = nil
  @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
  @write_timeout = 60
  @continue_timeout = nil
  @max_retries = 1
  @debug_output = nil
  @response_body_encoding = false
  @ignore_eof = true

  @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

Создаёт новый объект Net::HTTP для указанного адреса сервера без открытия TCP-соединения или инициализации HTTP сеанса. address должен быть именем хоста DNS или IP-адресом.

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

Отправляет данные на хост; возвращает объект Net::HTTPResponse.

Аргумент url должен быть URL; аргумент data должен быть строкой:

_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

Вывод:

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

Связанные:

• Net::HTTP::Post: класс запроса для HTTP-метода POST.

• Net::HTTP#post: удобный метод для HTTP-метода POST.

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

Отправляет данные на хост; возвращает объект Net::HTTPResponse.

Аргумент url должен быть URI; аргумент data должен быть словарём:

_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

Вывод:

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

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

Возвращает true, если self — класс, созданный HTTP::Proxy.

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

Создаёт новый объект Net::HTTP, http, с помощью Net::HTTP.new:

Net::HTTP.new(address, port, p_addr, p_port, p_user, p_pass)

• Для аргументов hostname по p_pass, см. Net::HTTP.new.

• Для аргумента opts, см. ниже.

Примечание: Если port равно nil и opts[:use_ssl] имеет истинное значение, значение, переданное в new — Net::HTTP.https_default_port, а не port.

Без блока:

• Вызывает http.start без блока (см. start), что открывает TCP-соединение и HTTP-сессию.

• Возвращает http.

• Вызывающий метод должен вызвать finish для закрытия сессии:

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

С блоком:

• Вызывает http.start с блоком (см. start), что:

  • Открывает TCP-соединение и HTTP-сессию.

  • Вызывает блок, который может выполнить любое количество запросов к хосту.

  • Закрывает HTTP-сессию и TCP-соединение при выходе из блока.

  • Возвращает значение блока object.

• Возвращает object.

Пример:

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

Вывод:

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

Если последний переданный аргумент — хеш, это хеш opts, где каждый ключ — метод или аксессор, который нужно вызвать, а его значение — значение, которое нужно установить.

Ключи могут включать:

• ca_file

• ca_path

• cert

• cert_store

• ciphers

• close_on_empty_response

• ipaddr (вызывает ipaddr=)

• keep_alive_timeout

• key

• open_timeout

• read_timeout

• ssl_timeout

• ssl_version

• use_ssl (вызывает use_ssl=)

• verify_callback

• verify_depth

• verify_mode

• write_timeout

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

Возвращает true; сохранено для совместимости.

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

Возвращает true; сохранено для совместимости.

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

Устанавливает значение атрибута continue_timeout.

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

Отправляет запрос COPY на path и получает ответ в виде объекта HTTPResponse.

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

Отправляет запрос DELETE на path и получает ответ в виде объекта HTTPResponse.

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

Завершает сеанс HTTP и закрывает TCP-соединение. Вызывает исключение IOError, если сеанс не был начат.

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

Получает данные из path на подключенном хосте, который может быть абсолютным путем String или URI для извлечения пути.

initheader должен быть Hash типом, например { ‘Accept’ => ‘/’, … }, и по умолчанию является пустым массивом. Если у initheader нет ключа ‘accept-encoding’, используется значение «gzip;q=1.0,deflate;q=0.6,identity;q=0.3», так что сжатие gzip используется в приоритете перед сжатием deflate, которое используется в приоритете перед отсутствием сжатия. В Ruby нет библиотек для поддержки сжатия (Lempel-Ziv), поэтому оно не поддерживается. Цель этого — по умолчанию уменьшить пропускную способность. Если эта функция настраивает сжатие, она также выполняет разархивирование, удаляя заголовок, чтобы избежать путаницы. В противном случае она оставляет тело в том виде, в котором оно было найдено.

Этот метод возвращает объект Net::HTTPResponse.

Если вызывается с блоком, он передает каждый фрагмент тела сущности по очереди как строку по мере чтения его из сокета. Обратите внимание, что в этом случае возвращаемый объект ответа не будет содержать тело (полезной информации).

Аргумент dest устарел. Он всё ещё работает, но его не следует использовать.

Этот метод никогда не генерирует исключение.

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 1595
def head(path, initheader = nil)
  request(Head.new(path, initheader))
end

Получает только заголовок из path на подключенном хосте. header является Hash типом, например { ‘Accept’ => ‘/’, … }.

Этот метод возвращает объект Net::HTTPResponse.

Этот метод никогда не генерирует исключение.

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 872
def inspect
  "#<#{self.class} #{@address}:#{@port} open=#{started?}>"
end

Возвращает строковое представление self:

Net::HTTP.new(hostname).inspect
# => "#<Net::HTTP jsonplaceholder.typicode.com:80 open=false>"

# File lib/net/http.rb, line 995
def ipaddr
  started? ?  @socket.io.peeraddr[3] : @ipaddr
end

Возвращает IP-адрес для подключения.

Если сеанс не был начат, возвращает значение, установленное ipaddr=, или nil, если оно не было установлено:

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

Если сеанс был начат, возвращает IP-адрес из сокета:

http = Net::HTTP.new(hostname)
http.start
http.ipaddr # => "172.67.155.76"
http.finish

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

Устанавливает IP-адрес для подключения:

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

IP-адрес не может быть установлен, если сеанс уже начат.

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

Отправляет запрос LOCK на path и получает ответ в виде объекта HTTPResponse.

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

Устанавливает максимальное количество попыток повтора идемпотентного запроса в случае Net::ReadTimeout, IOError, EOFError, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE, OpenSSL::SSL::SSLError, Timeout::Error. Начальное значение равно 1.

Аргумент retries должен быть неотрицательным числовым значением:

http = Net::HTTP.new(hostname)
http.max_retries = 2   # => 2
http.max_retries       # => 2

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

Отправляет запрос MKCOL на path и получает ответ в виде объекта HTTPResponse.

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

Отправляет запрос MOVE на path и получает ответ в виде объекта HTTPResponse.

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

Отправляет запрос OPTIONS на path и получает ответ в виде объекта HTTPResponse.

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

Отправляет запрос PATCH на path и получает ответ в виде объекта HTTPResponse.

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

Возвращает сертификаты X.509, представленные сервером.

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

Отправляет data (должен быть String) на path. header должен быть Hash типа { ‘Accept’ => ‘/’, … }.

Этот метод возвращает объект Net::HTTPResponse.

Если вызывается с блоком, он поочерёдно передает каждый фрагмент тела сущности в качестве строки по мере его чтения из сокета. Обратите внимание, что в этом случае возвращаемый объект ответа не будет содержать (полезное) тело.

Аргумент dest устарел. Он всё ещё работает, но его не следует использовать.

Этот метод никогда не вызывает исключения.

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
}

Для POST запроса необходимо установить заголовок Content-Type. Если заголовок Content-Type не задан, этот метод по умолчанию использует «application/x-www-form-urlencoded».

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

Отправляет запрос PROPFIND на path и получает ответ в виде объекта HTTPResponse.

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

Отправляет запрос PROPPATCH на path и получает ответ в виде объекта HTTPResponse.

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

Истина, если запросы для этого соединения будут проксироваться

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

Адрес сервера прокси, если он настроен.

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

Истина, если прокси для этого соединения определяется из среды

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

Пароль сервера прокси, если он настроен.

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

Порт сервера прокси, если он настроен.

# File lib/net/http.rb, line 1479
def proxy_user
  if @proxy_from_env
    user = proxy_uri&.user
    unescape(user) if user
  else
    @proxy_user
  end
end

Имя пользователя сервера прокси, если он настроен.

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

Устанавливает таймаут чтения в секундах для self до целого числа sec; начальное значение равно 60.

Аргумент sec должен быть неотрицательным числовым значением:

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

Отправляет объект HTTPRequest req на сервер HTTP.

Если req является запросом Net::HTTP::Post или Net::HTTP::Put содержащим данные, данные также отправляются. Предоставление данных для запроса Net::HTTP::Head или Net::HTTP::Get приводит к ошибке ArgumentError.

Возвращает объект HTTPResponse.

При вызове с блоком, передаёт объект HTTPResponse в блок. Тело ответа ещё не будет прочитано; блок может обработать его используя HTTPResponse#read_body, если необходимо.

Этот метод никогда не вызывает исключений Net::*.

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

Отправляет запрос GET на path. Возвращает ответ как объект Net::HTTPResponse.

При вызове с блоком, передаёт объект HTTPResponse в блок. Тело ответа ещё не будет прочитано; блок может обработать его используя HTTPResponse#read_body, если необходимо.

Возвращает ответ.

Этот метод никогда не вызывает исключений Net::*.

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 1740
def request_head(path, initheader = nil, &block)
  request(Head.new(path, initheader), &block)
end

Отправляет запрос HEAD на path и возвращает ответ как объект Net::HTTPResponse.

Возвращает ответ.

Этот метод никогда не вызывает исключений Net::*.

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

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

Отправляет запрос POST на path.

Возвращает ответ как объект Net::HTTPResponse.

При вызове с блоком, в блок передаётся объект HTTPResponse. Тело ответа ещё не будет прочитано; блок может обработать его используя HTTPResponse#read_body, если необходимо.

Возвращает ответ.

Этот метод никогда не вызывает исключений Net::*.

# 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 965
def response_body_encoding=(value)
  value = Encoding.find(value) if value.is_a?(String)
  @response_body_encoding = value
end

Устанавливает кодировку, используемую для тела ответа; возвращает кодировку.

Переданное value может быть:

• Объектом Encoding.

• Названием кодировки.

• Псевдонимом имени кодировки.

См. Encoding.

Примеры:

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 1794
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 на сервер HTTP. Также отправляет строку DATA, если data задана.

Возвращает объект Net::HTTPResponse.

Этот метод никогда не вызывает исключений Net::*.

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

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

ПРЕДУПРЕЖДЕНИЕ Этот метод открывает серьезную уязвимость безопасности. Никогда не используйте этот метод в рабочем коде.

Устанавливает поток вывода для отладки:

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

Вывод:

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

Открывает TCP-соединение и сеанс HTTP.

Когда этот метод вызывается с блоком, он передает объект Net::HTTP в блок и закрывает TCP-соединение и сеанс HTTP после выполнения блока.

При вызове с блоком он возвращает результат блока; в противном случае он возвращает self.

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

Возвращает true, если сеанс HTTP был начат.

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

Отправляет запрос TRACE на path и получает ответ в виде объекта HTTPResponse.

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

Отправляет запрос UNLOCK на path и получает ответ в виде объекта HTTPResponse.

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

Включает/выключает SSL. Этот флаг должен быть установлен до начала сеанса. Если вы измените значение use_ssl после запуска сеанса, объект Net::HTTP вызовет исключение IOError.

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

Возвращает true, если SSL/TLS используется с HTTP.

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

Устанавливает тайм-аут записи в секундах для self до целого числа sec; начальное значение равно 60.

Аргумент sec должен быть неотрицательным числовым значением.