class Net::HTTP

Возвращает целое число 80 — порт по умолчанию для HTTP-запросов:

Net::HTTP.default_port # => 80

Отправляет 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.

Как Net::HTTP.get, но записывает возвращённое тело в $stdout; возвращает nil.

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

Возвращает целое число 80 — порт по умолчанию для HTTP-запросов:

Net::HTTP.http_default_port # => 80

Возвращает целое число 443 — порт по умолчанию для HTTPS-запросов:

Net::HTTP.https_default_port # => 443

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

Если передан только строковый аргумент address (а 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_no_proxy см. в разделе Прокси-сервер.

Отправляет данные на хост; возвращает объект 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.

Отправляет данные на хост; возвращает объект 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
}

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

Отправляет PUT-запрос на сервер; возвращает объект 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.put(_uri, data, headers) # => #<Net::HTTPCreated 201 Created readbody=true>
puts res.body

Вывод:

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

Связанные методы:

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

• Net::HTTP#put: вспомогательный метод для HTTP-метода PUT.

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

• Сведения об аргументах address и port см. в описании Net::HTTP.new.

• Сведения об аргументах для задания прокси p_addr–p_pass см. в разделе Прокси-сервер.

• Сведения об аргументе opts приведены ниже.

Если блок не указан:

• Вызывает 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

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

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

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

Задаёт значение тайм-аута ожидания продолжения — количество секунд, в течение которых ожидается ответ 100 Continue. Если объект HTTP не получает ответ за это время, он отправляет тело запроса.

Отправляет серверу запрос COPY; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Copy, созданном из строки path и хеша начальных заголовков initheader.

http = Net::HTTP.new(hostname)
http.copy('/todos/1')

Отправляет серверу запрос DELETE; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Delete, созданном из строки path и хеша начальных заголовков initheader.

http = Net::HTTP.new(hostname)
http.delete('/todos/1')

Завершает сеанс HTTP:

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

Вызывает исключение IOError, если сеанс не запущен.

Отправляет серверу запрос GET; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Get, созданном из строки path и хеша начальных заголовков initheader.

Если передан блок, вызывает его с телом ответа:

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

Вывод:

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

Если блок не передан, просто возвращает объект ответа:

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

Связанные методы:

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

• Net::HTTP.get: отправляет запрос GET и возвращает тело ответа.

Отправляет серверу запрос HEAD; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Head, созданном из строки path и хеша начальных заголовков initheader:

res = http.head('/todos/1') # => #<Net::HTTPOK 200 OK readbody=true>
res.body                    # => nil
res.to_hash.take(3)
# =>
[["date", ["Wed, 15 Feb 2023 15:25:42 GMT"]],
 ["content-type", ["application/json; charset=utf-8"]],
 ["connection", ["close"]]]

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

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

Возвращает 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

Задаёт IP-адрес соединения:

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

IP-адрес нельзя задать, если сеанс уже запущен.

Отправляет серверу запрос LOCK; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Lock, созданном из строки path, строки body и хеша начальных заголовков initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.lock('/todos/1', data)

Задаёт максимальное количество повторных попыток для идемпотентного запроса в случае 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

Отправляет серверу запрос MKCOL; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Mkcol, созданном из строки path, строки body и хеша начальных заголовков initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http.mkcol('/todos/1', data)
http = Net::HTTP.new(hostname)

Отправляет серверу запрос MOVE; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Move, созданном из строки path и хеша начальных заголовков initheader.

http = Net::HTTP.new(hostname)
http.move('/todos/1')

Отправляет серверу запрос Options; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Options, созданном из строки path и хеша начальных заголовков initheader.

http = Net::HTTP.new(hostname)
http.options('/')

Отправляет серверу запрос PATCH; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Patch, созданном из строки path, строки data и хеша начальных заголовков initheader.

Если передан блок, вызывает его с телом ответа:

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

Вывод:

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

Если блок не передан, просто возвращает объект ответа:

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

Возвращает цепочку сертификатов X509 (массив строк) для узла на другой стороне сокета сеанса или nil, если сертификатов нет.

Отправляет серверу запрос POST; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Post, созданном из строки path, строки data и хеша начальных заголовков initheader.

Если передан блок, вызывает его с телом ответа:

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

Вывод:

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

Если блок не передан, просто возвращает объект ответа:

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

Связанные методы:

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

• Net::HTTP.post: отправляет запрос POST и возвращает тело ответа.

Отправляет серверу запрос PROPFIND; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Propfind, созданном из строки path, строки body и хеша начальных заголовков initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.propfind('/todos/1', data)

Отправляет серверу запрос PROPPATCH; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Proppatch, созданном из строки path, строки body и хеша начальных заголовков initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.proppatch('/todos/1', data)

Возвращает true, если задан прокси-сервер, и false в противном случае; см. раздел Прокси-сервер.

Возвращает адрес прокси-сервера, если он задан, и nil в противном случае; см. раздел Прокси-сервер.

Возвращает true, если прокси-сервер задан в окружении, и false в противном случае; см. раздел Прокси-сервер.

Возвращает пароль прокси-сервера, если он задан, и nil в противном случае; см. раздел Прокси-сервер.

Возвращает номер порта прокси-сервера, если он задан, и nil в противном случае; см. раздел Прокси-сервер.

Возвращает имя пользователя прокси-сервера, если оно задано, и nil в противном случае; см. раздел Прокси-сервер.

Отправляет серверу запрос PUT; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Put, созданном из строки path, строки data и хеша начальных заголовков initheader.

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

Связанные методы:

• Net::HTTP::Put: класс запроса для метода HTTP PUT.

• Net::HTTP.put: отправляет запрос PUT и возвращает тело ответа.

Задаёт тайм-аут чтения в секундах для 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.

Отправляет серверу заданный запрос req; формирует ответ в виде объекта Net::HTTPResponse.

Заданный req должен быть экземпляром подкласса Net::HTTPRequest. Аргумент body следует указывать только в том случае, если он требуется для запроса.

Если блок не передан, возвращает объект ответа:

http = Net::HTTP.new(hostname)

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

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

Если блок передан, вызывает его с ответом и возвращает ответ:

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

Вывод:

#<Net::HTTPOK 200 OK readbody=false>

Отправляет серверу запрос GET; формирует ответ в виде объекта Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Get, созданном из строки path и хеша начальных заголовков initheader.

Если блок не передан, возвращает объект ответа:

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

Если блок передан, вызывает его с объектом ответа и возвращает объект ответа:

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

Вывод:

#<Net::HTTPOK 200 OK readbody=false>

Отправляет серверу запрос HEAD; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Head, созданном из строки path и хеша начальных заголовков initheader.

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

Отправляет серверу запрос POST; формирует ответ в виде объекта Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Post, созданном из строки path, строки data и хеша начальных заголовков initheader.

Если блок не передан, возвращает объект ответа:

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

Если блок передан, вызывает его с телом ответа и возвращает объект ответа:

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

Вывод:

"{\n  \"xyzzy\": \"\",\n  \"id\": 201\n}"

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

Значение 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"

Отправляет серверу HTTP-запрос; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTPRequest, созданном из строки path, строки data и хеша начальных заголовков header. Этот объект является экземпляром подкласса Net::HTTPRequest, соответствующего заданной строке name в верхнем регистре, которая должна обозначать метод HTTP-запроса или метод запроса WebDAV.

Примеры:

http = Net::HTTP.new(hostname)
http.send_request('GET', '/todos/1')
# => #<Net::HTTPOK 200 OK readbody=true>
http.send_request('POST', '/todos', 'xyzzy')
# => #<Net::HTTPCreated 201 Created readbody=true>

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

Задаёт поток вывода для отладки:

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

Запускает сеанс HTTP.

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

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

Если блок передан, вызывает его с self, завершает сеанс после выхода из блока и возвращает значение блока:

http.start do |http|
  http
end
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.started? # => false

Возвращает true, если сеанс HTTP запущен:

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

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

Отправляет серверу запрос TRACE; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос основан на объекте Net::HTTP::Trace, созданном из строки path и хеша начальных заголовков initheader.

http = Net::HTTP.new(hostname)
http.trace('/todos/1')

Отправляет серверу запрос UNLOCK; возвращает экземпляр подкласса Net::HTTPResponse.

Запрос формируется на основе объекта Net::HTTP::Unlock, созданного из строки path, строки body и хеша начальных заголовков initheader.

data = '{"userId": 1, "id": 1, "title": "delectus aut autem", "completed": false}'
http = Net::HTTP.new(hostname)
http.unlock('/todos/1', data)

Устанавливает, будет ли новый сеанс использовать протокол защиты транспортного уровня:

Вызывает исключение IOError при попытке изменить значение во время сеанса.

Вызывает исключение OpenSSL::SSL::SSLError, если порт не является портом HTTPS.

Возвращает true, если self использует SSL, и false в противном случае. См. Net::HTTP#use_ssl=.

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

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

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

Выполняет запрос, использующий представление, и возвращает его тело.