class Async::HTTP::Client
Attributes
endpoint[R]
pool[R]
protocol[R]
retries[R]
scheme[R]
Public Class Methods
new(endpoint, protocol: endpoint.protocol, scheme: endpoint.scheme, authority: endpoint.authority, retries: DEFAULT_RETRIES, connection_limit: DEFAULT_CONNECTION_LIMIT)
click to toggle source
Provides a robust interface to a server.
-
If there are no connections, it will create one.
-
If there are already connections, it will reuse it.
-
If a request fails, it will retry it up to N times if it was idempotent.
The client object will never become unusable. It internally manages persistent connections (or non-persistent connections if that's required). @param endpoint [Endpoint] the endpoint to connnect to. @param protocol [Protocol::HTTP1 | Protocol::HTTP2
| Protocol::HTTPS] the protocol to use. @param scheme [String] The default scheme to set to requests. @param authority [String] The default authority to set to requests.
# File lib/async/http/client.rb, line 48 def initialize(endpoint, protocol: endpoint.protocol, scheme: endpoint.scheme, authority: endpoint.authority, retries: DEFAULT_RETRIES, connection_limit: DEFAULT_CONNECTION_LIMIT) @endpoint = endpoint @protocol = protocol @retries = retries @pool = make_pool(connection_limit) @scheme = scheme @authority = authority end
open(*arguments, **options) { |client| ... }
click to toggle source
# File lib/async/http/client.rb, line 72 def self.open(*arguments, **options, &block) client = self.new(*arguments, **options) return client unless block_given? begin yield client ensure client.close end end
Public Instance Methods
call(request)
click to toggle source
# File lib/async/http/client.rb, line 93 def call(request) request.scheme ||= self.scheme request.authority ||= self.authority attempt = 0 # We may retry the request if it is possible to do so. https://tools.ietf.org/html/draft-nottingham-httpbis-retry-01 is a good guide for how retrying requests should work. begin attempt += 1 # As we cache pool, it's possible these pool go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this. If this is the last attempt, we force a new connection. connection = @pool.acquire response = make_response(request, connection) # This signals that the ensure block below should not try to release the connection, because it's bound into the response which will be returned: connection = nil return response rescue Protocol::RequestFailed # This is a specific case where the entire request wasn't sent before a failure occurred. So, we can even resend non-idempotent requests. if connection @pool.release(connection) connection = nil end if attempt < @retries retry else raise end rescue SocketError, IOError, EOFError, Errno::ECONNRESET, Errno::EPIPE if connection @pool.release(connection) connection = nil end if request.idempotent? and attempt < @retries retry else raise end ensure @pool.release(connection) if connection end end
close()
click to toggle source
# File lib/async/http/client.rb, line 84 def close while @pool.busy? Console.logger.warn(self) {"Waiting for #{@protocol} pool to drain: #{@pool}"} @pool.wait end @pool.close end
secure?()
click to toggle source
# File lib/async/http/client.rb, line 68 def secure? @endpoint.secure? end
Protected Instance Methods
make_pool(connection_limit)
click to toggle source
# File lib/async/http/client.rb, line 153 def make_pool(connection_limit) Async::Pool::Controller.wrap(limit: connection_limit) do Console.logger.debug(self) {"Making connection to #{@endpoint.inspect}"} @protocol.client(@endpoint.connect) end end
make_response(request, connection)
click to toggle source
# File lib/async/http/client.rb, line 142 def make_response(request, connection) response = request.call(connection) # The connection won't be released until the body is completely read/released. ::Protocol::HTTP::Body::Completable.wrap(response) do @pool.release(connection) end return response end