hearth 1.0.0.pre1 → 1.0.0.pre3

data/lib/hearth/context.rb

@@ -1,19 +1,27 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+
 module Hearth
   # Stores request and response objects, and other useful things used by
   # multiple Middleware.
+  # @api private
   class Context
     def initialize(options = {})
+      @invocation_id = SecureRandom.uuid
       @operation_name = options[:operation_name]
       @request = options[:request]
       @response = options[:response]
       @logger = options[:logger]
-      @params = options[:params]
+      @interceptors = options[:interceptors] || InterceptorList.new
+      @auth = options[:auth]
       @metadata = options[:metadata] || {}
     end
 
-    # @return [Symbol] Name of the API operation called.
+    # @return [String] The invocation ID for the request.
+    attr_reader :invocation_id
+
+    # @return [Symbol] The name of the API operation called.
     attr_reader :operation_name
 
     # @return [Hearth::HTTP::Request]
@@ -25,10 +33,27 @@ module Hearth
     # @return [Logger] An instance of the logger configured for the Client.
     attr_reader :logger
 
-    # @return [Hash] The hash of the original request parameters.
-    attr_reader :params
+    # @return [Array] An ordered list of interceptors
+    attr_reader :interceptors
+
+    # @return [ResolvedAuth, nil] The resolved auth for the request.
+    attr_accessor :auth
 
     # @return [Hash]
     attr_reader :metadata
+
+    # Returns the metadata for the given `key`.
+    # @param [Symbol] key
+    # @return [Object]
+    def [](key)
+      @metadata[key]
+    end
+
+    # Sets metadata for the given `key`.
+    # @param [Symbol] key
+    # @param [Object] value
+    def []=(key, value)
+      @metadata[key] = value
+    end
   end
 end

data/lib/hearth/dns/host_address.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hearth
+  module DNS
+    # Address results from a DNS lookup in {HostResolver}.
+    # @!method initialize(*args)
+    #   @option args [Symbol] :address_type The type of address. For example,
+    #    :A or :AAAA.
+    #   @option args [String] :address The IP address.
+    #   @option args [String] :hostname The hostname that was resolved.
+    # @!attribute address_type
+    #   The type of address. For example, :A or :AAAA.
+    #   @return [Symbol]
+    # @!attribute address
+    #   The IP address.
+    #   @return [String]
+    # @!attribute hostname
+    #   The hostname that was resolved.
+    #   @return [String]
+    HostAddress = Struct.new(
+      :address_type,
+      :address,
+      :hostname,
+      keyword_init: true
+    )
+  end
+end

data/lib/hearth/dns/host_resolver.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Hearth
+  module DNS
+    # Resolves a host name and service to an IP address. Can be used with the
+    # {HTTP::Client} host_resolver option. This implementation uses
+    # Addrinfo.getaddrinfo to resolve the host name.
+    #
+    # @see https://ruby-doc.org/stdlib-3.0.2/libdoc/socket/rdoc/Addrinfo.html
+    class HostResolver
+      # @param [Integer] service (443)
+      # @param [Integer] family (nil)
+      # @param [Symbol] socktype (:SOCK_STREAM)
+      # @param [Integer] protocol (nil)
+      # @param [Integer] flags (nil)
+      def initialize(service: 443, family: nil, socktype: :SOCK_STREAM,
+                     protocol: nil, flags: nil)
+        @service = service
+        @family = family
+        @socktype = socktype
+        @protocol = protocol
+        @flags = flags
+      end
+
+      # @return [Integer]
+      attr_reader :service
+
+      # @return [Integer]
+      attr_reader :family
+
+      # @return [Symbol]
+      attr_reader :socktype
+
+      # @return [Integer]
+      attr_reader :protocol
+
+      # @return [Integer]
+      attr_reader :flags
+
+      # @param [String] nodename
+      # @param (see Hearth::DNS::HostResolver#initialize)
+      def resolve_address(nodename:, **kwargs)
+        options = kwargs.merge(nodename: nodename)
+        addrinfo_list = addrinfo(options)
+        ipv6 = ipv6_addr(addrinfo_list, options) if use_ipv6?
+        ipv4 = ipv4_addr(addrinfo_list, options)
+        [ipv6, ipv4]
+      end
+
+      private
+
+      def addrinfo(options)
+        Addrinfo.getaddrinfo(
+          options[:nodename],
+          options.fetch(:service, @service),
+          options.fetch(:family, @family),
+          options.fetch(:socktype, @socktype),
+          options.fetch(:protocol, @protocol),
+          options.fetch(:flags, @flags)
+        )
+      end
+
+      def ipv4_addr(addrinfo_list, options)
+        addr = addrinfo_list.find(&:ipv4?)
+        return unless addr
+
+        HostAddress.new(
+          address_type: :A,
+          address: addr.ip_address,
+          hostname: options[:nodename]
+        )
+      end
+
+      def ipv6_addr(addrinfo_list, options)
+        addr = addrinfo_list.find(&:ipv6?)
+        return unless addr
+
+        HostAddress.new(
+          address_type: :AAAA,
+          address: addr.ip_address,
+          hostname: options[:nodename]
+        )
+      end
+
+      def use_ipv6?
+        Socket.ip_address_list.any? do |a|
+          a.ipv6? && !a.ipv6_loopback? && !a.ipv6_linklocal?
+        end
+      end
+    end
+  end
+end

data/lib/hearth/dns.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+require_relative 'dns/host_address'
+require_relative 'dns/host_resolver'
+
+# These patches are based on resolv-replace
+# https://github.com/ruby/ruby/blob/master/lib/resolv-replace.rb
+# We cannot require resolv-replace because it would change DNS resolution
+# globally. When opening an HTTP request, we will set a thread local variable
+# to enable custom DNS resolution, and then disable it after the request is
+# complete. When the thread local variable is not set, we will use the default
+# Ruby DNS resolution, which may be Resolv or the system resolver.
+
+# Patch IPSocket
+# @api private
+class << IPSocket
+  alias original_hearth_getaddress getaddress
+
+  def getaddress(host)
+    unless (resolver = Thread.current[:net_http_hearth_dns_resolver])
+      return original_hearth_getaddress(host)
+    end
+
+    ipv6, ipv4 = resolver.resolve_address(nodename: host)
+    return ipv6.address if ipv6
+
+    ipv4.address
+  end
+end
+
+# Patch TCPSocket
+# @api private
+class TCPSocket < IPSocket
+  alias original_hearth_initialize initialize
+
+  # rubocop:disable Lint/MissingSuper
+  def initialize(host, serv, *rest)
+    if Thread.current[:net_http_hearth_dns_resolver]
+      rest[0] = IPSocket.getaddress(rest[0]) if rest[0]
+      original_hearth_initialize(IPSocket.getaddress(host), serv, *rest)
+    else
+      original_hearth_initialize(host, serv, *rest)
+    end
+  end
+  # rubocop:enable Lint/MissingSuper
+end

data/lib/hearth/endpoint_rules.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'ipaddr'
+require 'uri'
+
+module Hearth
+  # Functions in the Smithy rules engine are named routines that
+  # operate on a finite set of specified inputs, returning an output.
+  # The rules engine has a set of included functions that can be
+  # invoked without additional dependencies, called the standard library.
+  module EndpointRules
+    # An Authentication Scheme supported by an Endpoint
+    # @!attribute scheme_id
+    #   The identifier of the authentication scheme.
+    #   @return [String]
+    # @!attribute properties
+    #   Additional properties of the authentication scheme.
+    #   @return [Hash]
+    AuthScheme = Struct.new(
+      :scheme_id,
+      :properties,
+      keyword_init: true
+    ) do
+      # @option args [String] :scheme_id
+      # @option args [Hash] :properties ({})
+      def initialize(*args)
+        super
+        self.properties ||= {}
+      end
+    end
+
+    # An Endpoint resolved by an EndpointProvider
+    # @!attribute uri
+    #   The URI of the endpoint.
+    #   @return [String]
+    # @!attribute auth_schemes
+    #   The authentication schemes supported by the endpoint.
+    #   @return [Array<AuthScheme>]
+    # @!attribute headers
+    #   The headers to include in requests to the endpoint.
+    #   @return [Hash]
+    Endpoint = Struct.new(
+      :uri,
+      :auth_schemes,
+      :headers,
+      keyword_init: true
+    ) do
+      # @option args [String] :uri
+      # @option args [Array<AuthScheme>] :auth_schemes ([])
+      # @option args [Hash] :headers ({})
+      def initialize(*args)
+        super
+        self.auth_schemes ||= []
+        self.headers ||= {}
+      end
+    end
+
+    # Evaluates whether the input string is a compliant RFC 1123 host segment.
+    # When allowSubDomains is true, evaluates whether the input string is
+    # composed of values that are each compliant RFC 1123 host segments
+    # joined by dot (.) characters.
+    # @api private
+    # rubocop:disable Style/OptionalBooleanParameter
+    def self.valid_host_label?(value, allow_sub_domains = false)
+      return false if value.empty?
+
+      if allow_sub_domains
+        labels = value.split('.', -1)
+        return labels.all? { |l| valid_host_label?(l, false) }
+      end
+
+      !!(value =~ /\A(?!-)[a-zA-Z0-9-]{1,63}(?<!-)\z/)
+    end
+    # rubocop:enable Style/OptionalBooleanParameter
+
+    # Computes a URL structure given an input string.
+    # @api private
+    def self.parse_url(value)
+      URL.new(value).as_json
+    rescue ArgumentError, URI::InvalidURIError
+      nil
+    end
+
+    # Computes a portion of a given string based on
+    # the provided start and end indices.
+    # @api private
+    def self.substring(input, start, stop, reverse)
+      return nil if start >= stop || input.size < stop
+
+      return nil if input.chars.any? { |c| c.ord > 127 }
+
+      return input[start...stop] unless reverse
+
+      r_start = input.size - stop
+      r_stop = input.size - start
+      input[r_start...r_stop]
+    end
+
+    # Performs RFC 3986#section-2.1 defined percent-encoding on the input value.
+    # @api private
+    def self.uri_encode(value)
+      CGI.escape(value.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
+    end
+
+    # @api private
+    class URL
+      def initialize(url)
+        uri = URI(url)
+        @scheme = uri.scheme
+        # only support http and https schemes
+        raise ArgumentError unless %w[https http].include?(@scheme)
+
+        # do not support query
+        raise ArgumentError if uri.query
+
+        @authority = _authority(url, uri)
+        @path = uri.path
+        @normalized_path = uri.path + (uri.path[-1] == '/' ? '' : '/')
+        @is_ip = _is_ip(uri.host)
+      end
+
+      attr_reader :scheme, :authority, :path, :normalized_path, :is_ip
+
+      def as_json(_options = {})
+        {
+          'scheme' => scheme,
+          'authority' => authority,
+          'path' => path,
+          'normalizedPath' => normalized_path,
+          'isIp' => is_ip
+        }
+      end
+
+      private
+
+      def _authority(url, uri)
+        # don't include port if it's default and not parsed originally
+        if uri.default_port == uri.port && !url.include?(":#{uri.port}")
+          uri.host
+        else
+          "#{uri.host}:#{uri.port}"
+        end
+      end
+
+      def _is_ip(authority)
+        IPAddr.new(authority)
+        true
+      rescue IPAddr::InvalidAddressError
+        false
+      end
+    end
+  end
+end

data/lib/hearth/http/api_error.rb

@@ -7,23 +7,19 @@ module Hearth
     class ApiError < Hearth::ApiError
       def initialize(http_resp:, **kwargs)
         @http_status = http_resp.status
-        @http_headers = http_resp.headers
+        @http_fields = http_resp.fields
         @http_body = http_resp.body
-        @request_id = http_resp.headers['x-request-id']
         super(**kwargs)
       end
 
       # @return [Integer]
       attr_reader :http_status
 
-      # @return [Hash<String, String>]
-      attr_reader :http_headers
+      # @return [Fields]
+      attr_reader :http_fields
 
-      # @return [String]
+      # @return [IO]
       attr_reader :http_body
-
-      # @return [String]
-      attr_reader :request_id
     end
   end
 end