class HTTP::Client
Overview
An HTTP Client.
One-shot usage
Without a block, an HTTP::Client::Response
is returned and the response's body
is available as a String
by invoking HTTP::Client::Response#body
.
require "http/client"
response = HTTP::Client.get "http://www.example.com"
response.status_code # => 200
response.body.lines.first # => "<!doctype html>"
Streaming
With a block, an HTTP::Client::Response
body is returned and the response's body
is available as an IO
by invoking HTTP::Client::Response#body_io
.
require "http/client"
HTTP::Client.get("http://www.example.com") do |response|
response.status_code # => 200
response.body_io.gets # => "<!doctype html>"
end
Reusing a connection
Similar to the above cases, but creating an instance of an HTTP::Client
.
require "http/client"
client = HTTP::Client.new "www.example.com"
response = client.get "/"
response.status_code # => 200
response.body.lines.first # => "<!doctype html>"
client.close
Compression
If compress
isn't set to false
, and no Accept-Encoding
header is explicitly specified,
an HTTP::Client will add an "Accept-Encoding": "gzip, deflate"
header, and automatically decompress
the response body/body_io.
Encoding
If a response has a Content-Type
header with a charset, that charset is set as the encoding
of the returned IO (or used for creating a String for the body). Invalid bytes in the given encoding
are silently ignored when reading text content.
Defined in:
http/client.crClass Method Summary
-
.delete(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a DELETE request and yields the response to the block.
-
.delete(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a DELETE request.
-
.exec(method, url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a request.
-
.exec(method, url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a request.
-
.get(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a GET request and yields the response to the block.
-
.get(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a GET request.
-
.head(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a HEAD request.
-
.head(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a HEAD request and yields the response to the block.
-
.new(host, port = nil, tls = false, &block)
Creates a new HTTP client, yields it to the block, and closes the client afterwards.
- .new(host, port = nil, tls : Bool | OpenSSL::SSL::Context::Client = false)
-
.new(uri : URI, tls = nil)
Creates a new HTTP client from a URI.
-
.patch(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a PATCH request.
-
.patch(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a PATCH request and yields the response to the block.
-
.post(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a POST request and yields the response to the block.
-
.post(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a POST request.
-
.post_form(url, form : String | Hash, headers : HTTP::Headers | Nil = nil, tls = nil, &block)
Executes a POST with form data and yields the response to the block.
-
.post_form(url, form : String | Hash, headers : HTTP::Headers | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a POST with form data.
-
.put(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil, &block)
Executes a PUT request and yields the response to the block.
-
.put(url : String | URI, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, tls = nil) : HTTP::Client::Response
Executes a PUT request.
Instance Method Summary
-
#basic_auth(username, password)
Configures this client to perform basic authentication in every request.
-
#before_request(&callback : HTTP::Request -> )
Adds a callback to execute before each request.
-
#close
Closes this client.
-
#compress=(compress : Bool)
Whether automatic compression/decompression is enabled.
-
#compress? : Bool
Whether automatic compression/decompression is enabled.
-
#connect_timeout=(connect_timeout : Time::Span)
Set the open timeout with a
Time::Span
to wait when connecting, before raising anIO::Timeout
. -
#connect_timeout=(connect_timeout : Number)
Set the number of seconds to wait when connecting, before raising an
IO::Timeout
. -
#delete(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a DELETE request and yields the response to the block.
-
#delete(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a DELETE request.
-
#dns_timeout=(dns_timeout : Time::Span)
This method has no effect right now
-
#dns_timeout=(dns_timeout : Number)
This method has no effect right now
-
#exec(request : HTTP::Request, &block)
Executes a request request and yields an
HTTP::Client::Response
to the block. -
#exec(method : String, path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a request.
-
#exec(request : HTTP::Request) : HTTP::Client::Response
Executes a request.
-
#exec(method : String, path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a request.
-
#get(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a GET request and yields the response to the block.
-
#get(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a GET request.
-
#head(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a HEAD request.
-
#head(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a HEAD request and yields the response to the block.
-
#host : String
Returns the target host.
-
#patch(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a PATCH request and yields the response to the block.
-
#patch(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a PATCH request.
-
#port : Int32
Returns the target port.
-
#post(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a POST request and yields the response to the block.
-
#post(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a POST request.
-
#post_form(path, form : Hash, headers : HTTP::Headers | Nil = nil) : HTTP::Client::Response
Executes a POST with form data.
-
#post_form(path, form : Hash, headers : HTTP::Headers | Nil = nil, &block)
Executes a POST with form data and yields the response to the block.
-
#post_form(path, form : String, headers : HTTP::Headers | Nil = nil, &block)
Executes a POST with form data and yields the response to the block.
-
#post_form(path, form : String, headers : HTTP::Headers | Nil = nil) : HTTP::Client::Response
Executes a POST with form data.
-
#put(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil, &block)
Executes a PUT request and yields the response to the block.
-
#put(path, headers : HTTP::Headers | Nil = nil, body : String | Nil = nil) : HTTP::Client::Response
Executes a PUT request.
-
#read_timeout=(read_timeout : Number)
Set the number of seconds to wait when reading before raising an
IO::Timeout
. -
#read_timeout=(read_timeout : Time::Span)
Set the read timeout with a
Time::Span
, to wait when reading before raising anIO::Timeout
. - #tls
- #tls? : Nil | OpenSSL::SSL::Context::Client
Instance methods inherited from class Reference
==(other)==(other : self) ==, dup dup, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, same?(other : Reference)
same?(other : Nil) same?, to_s(io : IO) : Nil to_s
Instance methods inherited from class Object
!=(other)
!=,
!~(other)
!~,
==(other)
==,
===(other)===(other : YAML::Any)
===(other : JSON::Any) ===, =~(other) =~, class class, crystal_type_id crystal_type_id, dup dup, hash hash, inspect(io : IO)
inspect inspect, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml
to_yaml(io : IO) to_yaml, try(&block) try
Class methods inherited from class Object
==(other : Class)
==,
===(other)
===,
cast(other) : self
cast,
clone
clone,
dup
dup,
from_json(string_or_io) : selffrom_json(string_or_io, root : String) : self from_json, from_yaml(string : String) : self from_yaml, hash hash, inspect(io) inspect, name : String name, nilable? nilable?, to_s(io) to_s, |(other : U.class) forall U |
Class Method Detail
Executes a DELETE request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.delete("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a DELETE request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
response = HTTP::Client.delete("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a request.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.exec("GET", "http://www.example.com") do |response|
response.body_io.gets # => "..."
end
Executes a request.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
response = HTTP::Client.exec "GET", "http://www.example.com"
response.body # => "..."
Executes a GET request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.get("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a GET request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
response = HTTP::Client.get("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a HEAD request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
response = HTTP::Client.head("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a HEAD request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.head("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Creates a new HTTP client, yields it to the block, and closes the client afterwards.
HTTP::Client.new("www.example.com") do |client|
client.get "/"
end
Creates a new HTTP client from a URI. Parses the host, port,
and tls configuration from the url provided. Port defaults to
80 if not specified unless using the https protocol, which defaults
to port 443 and sets tls to true
.
uri = URI.parse("https://secure.example.com")
client = HTTP::Client.new(uri)
client.tls? # => true
client.get("/")
This constructor will ignore any path or query segments in the URI as those will need to be passed to the client when a request is made.
If tls is given it will be used, if not a new TLS context will be created.
If tls is given and uri is a HTTP URI, ArgumentError
is raised.
In any case the active context can be accessed through #tls
.
This constructor will raise an exception if any scheme but HTTP or HTTPS is used.
Executes a PATCH request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
response = HTTP::Client.patch("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a PATCH request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.patch("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a POST request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.post("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a POST request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
response = HTTP::Client.post("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a POST with form data and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
The "Content-type" header is set to "application/x-www-form-urlencoded".
HTTP::Client.post_form("http://www.example.com", "foo=bar") do |response|
response.body_io.gets
end
Executes a POST with form data. The "Content-type" header is set to "application/x-www-form-urlencoded".
response = HTTP::Client.post_form "http://www.example.com", "foo=bar"
Executes a PUT request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
HTTP::Client.put("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a PUT request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
response = HTTP::Client.put("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Instance Method Detail
Configures this client to perform basic authentication in every request.
Adds a callback to execute before each request. This is usually used to set an authorization header. Any number of callbacks can be added.
client = HTTP::Client.new("www.example.com")
client.before_request do |request|
request.headers["Authorization"] = "XYZ123"
end
client.get "/"
Whether automatic compression/decompression is enabled.
Set the open timeout with a Time::Span
to wait when connecting, before raising an IO::Timeout
.
client = HTTP::Client.new("example.org")
client.connect_timeout = 5.minutes
begin
response = client.get("/")
rescue IO::Timeout
puts "Timeout!"
end
Set the number of seconds to wait when connecting, before raising an IO::Timeout
.
client = HTTP::Client.new("example.org")
client.connect_timeout = 1.5
begin
response = client.get("/")
rescue IO::Timeout
puts "Timeout!"
end
Executes a DELETE request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new("www.example.com")
client.delete("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a DELETE request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new("www.example.com")
response = client.delete("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
This method has no effect right now
Set the number of seconds to wait when resolving a name with a Time::Span
, before raising an IO::Timeout
.
client = HTTP::Client.new("example.org")
client.dns_timeout = 1.5.seconds
begin
response = client.get("/")
rescue IO::Timeout
puts "Timeout!"
end
This method has no effect right now
Set the number of seconds to wait when resolving a name, before raising an IO::Timeout
.
client = HTTP::Client.new("example.org")
client.dns_timeout = 1.5
begin
response = client.get("/")
rescue IO::Timeout
puts "Timeout!"
end
Executes a request request and yields an HTTP::Client::Response
to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new "www.example.com"
client.exec(HTTP::Request.new("GET", "/")) do |response|
response.body_io.gets # => "..."
end
Executes a request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new "www.example.com"
response = client.exec "GET", "/"
response.body # => "..."
Executes a request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new "www.example.com"
response = client.exec HTTP::Request.new("GET", "/")
response.body # => "..."
Executes a request.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new "www.example.com"
client.exec("GET", "/") do |response|
response.body_io.gets # => "..."
end
Executes a GET request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new("www.example.com")
client.get("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a GET request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new("www.example.com")
response = client.get("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a HEAD request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new("www.example.com")
response = client.head("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a HEAD request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new("www.example.com")
client.head("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Returns the target host.
client = HTTP::Client.new "www.example.com"
client.host # => "www.example.com"
Executes a PATCH request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new("www.example.com")
client.patch("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a PATCH request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new("www.example.com")
response = client.patch("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Returns the target port.
client = HTTP::Client.new "www.example.com"
client.port # => 80
Executes a POST request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new("www.example.com")
client.post("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a POST request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new("www.example.com")
response = client.post("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Executes a POST with form data. The "Content-type" header is set to "application/x-www-form-urlencoded".
client = HTTP::Client.new "www.example.com"
response = client.post_form "/", {"foo": "bar"}
Executes a POST with form data and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
The "Content-type" header is set to "application/x-www-form-urlencoded".
client = HTTP::Client.new "www.example.com"
client.post_form("/", {"foo": "bar"}) do |response|
response.body_io.gets
end
Executes a POST with form data and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
The "Content-type" header is set to "application/x-www-form-urlencoded".
client = HTTP::Client.new "www.example.com"
client.post_form("/", "foo=bar") do |response|
response.body_io.gets
end
Executes a POST with form data. The "Content-type" header is set to "application/x-www-form-urlencoded".
client = HTTP::Client.new "www.example.com"
response = client.post_form "/", "foo=bar"
Executes a PUT request and yields the response to the block.
The response will have its body as an IO
accessed via HTTP::Client::Response#body_io
.
client = HTTP::Client.new("www.example.com")
client.put("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!") do |response|
response.body_io.gets #=> "..."
end
Executes a PUT request.
The response will have its body as a String
, accessed via HTTP::Client::Response#body
.
client = HTTP::Client.new("www.example.com")
response = client.put("/", headers: HTTP::Headers{"User-agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."
Set the number of seconds to wait when reading before raising an IO::Timeout
.
client = HTTP::Client.new("example.org")
client.read_timeout = 1.5
begin
response = client.get("/")
rescue IO::Timeout
puts "Timeout!"
end
Set the read timeout with a Time::Span
, to wait when reading before raising an IO::Timeout
.
client = HTTP::Client.new("example.org")
client.read_timeout = 5.minutes
begin
response = client.get("/")
rescue IO::Timeout
puts "Timeout!"
end