class Async::HTTP::Client

Attributes

authority[R]
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