smithy-client 1.0.0.pre0 → 1.0.0.pre1

data/lib/smithy-client/net_http/handler.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module NetHTTP
+      # The default HTTP handler for Smithy::Client. This is based on Ruby's `Net::HTTP`.
+      # @api private
+      class Handler < Client::Handler
+        # @api private
+        class TruncatedBodyError < IOError
+          def initialize(bytes_expected, bytes_received)
+            msg = "http response body truncated, expected #{bytes_expected} " \
+                  "bytes, received #{bytes_received} bytes"
+            super(msg)
+          end
+        end
+
+        # @param [HandlerContext] context
+        # @return [Output]
+        def call(context)
+          transmit(context.config, context.http_request, context.http_response)
+          Response.new(context: context)
+        end
+
+        private
+
+        # @param [Configuration] config
+        # @param [HTTP::Request] req
+        # @param [HTTP::Response] resp
+        # @return [void]
+        def transmit(config, req, resp)
+          # Monkey patch default content-type set by Net::HTTP
+          Thread.current[:net_http_skip_default_content_type] = true
+          session(config, req) do |http|
+            http.request(build_net_request(req)) do |net_resp|
+              bytes_received = signal_response(net_resp, resp)
+              complete_response(req, resp, bytes_received)
+            end
+          end
+        rescue ArgumentError => e
+          # Invalid verb, ArgumentError is a StandardError
+          # Not retryable.
+          resp.signal_error(e)
+        rescue StandardError => e
+          error = NetworkingError.new(e)
+          resp.signal_error(error)
+        ensure
+          # ensure we turn off monkey patch in case of error
+          Thread.current[:net_http_skip_default_content_type] = nil
+        end
+
+        def signal_response(net_resp, resp)
+          status_code = net_resp.code.to_i
+          headers = extract_headers(net_resp)
+
+          bytes_received = 0
+          resp.signal_headers(status_code, headers)
+          net_resp.read_body do |chunk|
+            bytes_received += chunk.bytesize
+            resp.signal_data(chunk)
+          end
+          bytes_received
+        end
+
+        def complete_response(req, resp, bytes_received)
+          if should_verify_bytes?(req, resp)
+            verify_bytes_received(resp, bytes_received)
+          else
+            resp.signal_done
+          end
+        end
+
+        def should_verify_bytes?(req, resp)
+          req.http_method != 'HEAD' && resp.headers['content-length']
+        end
+
+        def verify_bytes_received(resp, bytes_received)
+          bytes_expected = resp.headers['content-length'].to_i
+          if bytes_expected == bytes_received
+            resp.signal_done
+          else
+            error = TruncatedBodyError.new(bytes_expected, bytes_received)
+            resp.signal_error(NetworkingError.new(error))
+          end
+        end
+
+        # @param [Configuration] config
+        # @param [HTTP::Request] req
+        # @yieldparam [Net::HTTP] http
+        def session(config, req, &)
+          pool_for(config).session_for(req.endpoint, &)
+        end
+
+        # @param [Configuration] config
+        # @return [ConnectionPool]
+        def pool_for(config)
+          ConnectionPool.for(pool_options(config))
+        end
+
+        # Extracts the {ConnectionPool} configuration options.
+        # @param [Configuration] config
+        # @return [Hash]
+        def pool_options(config)
+          ConnectionPool::OPTIONS.keys.each_with_object({}) do |opt, opts|
+            opts[opt] = config.send(opt)
+          end
+        end
+
+        # Constructs and returns a Net::HTTP::Request object from a {HTTP::Request}.
+        # @param [HTTP::Request] request
+        # @return [Net::HTTP::Request]
+        def build_net_request(request)
+          request_class = net_http_request_class(request)
+          req = request_class.new(request.endpoint.request_uri, net_headers_for(request))
+
+          # Net::HTTP adds a default Content-Type when a body is present.
+          # Set the body stream when it has an unknown size or when it is > 0.
+          if !request.body.respond_to?(:size) ||
+             (request.body.respond_to?(:size) && request.body.size.positive?)
+            req.body_stream = request.body
+          end
+          req
+        end
+
+        # @param [HTTP::Request] request
+        # @raise [ArgumentError]
+        # @return Returns a base `Net::HTTP::Request` class, e.g.,
+        #  `Net::HTTP::Get`, `Net::HTTP::Post`, etc.
+        def net_http_request_class(request)
+          Net::HTTP.const_get(request.http_method.capitalize)
+        rescue NameError
+          msg = "`#{request.http_method}` is not a valid http verb"
+          raise ArgumentError, msg
+        end
+
+        # Validate that fields are not trailers and return a hash of headers.
+        # @param [HTTP::Request] request
+        # @return [Hash<String, String>]
+        def net_headers_for(request)
+          # Net::HTTP adds a default header for accept-encoding (2.0.0+).
+          # Setting a default empty value defeats this.
+          # Removing this is necessary for most services to not break request
+          # signatures as well as dynamodb crc32 checks (these fail if the
+          # response is gzipped).
+          headers = { 'accept-encoding' => '' }
+          request.headers.each_pair do |key, value|
+            headers[key] = value
+          end
+          headers
+        end
+
+        # @param [Net::HTTP::Response] response
+        # @return [Hash<String, String>]
+        def extract_headers(response)
+          response.to_hash.transform_values(&:first)
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/net_http/patches.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module NetHTTP
+      # @api private
+      module Patches
+        def self.apply!
+          Net::HTTPGenericRequest.prepend(PatchDefaultContentType)
+        end
+
+        # For requests with bodies, Net::HTTP sets a default content type of:
+        #     'application/x-www-form-urlencoded'
+        # There are cases where we should not send content type at all.
+        # Even when no body is supplied, Net::HTTP uses a default empty body
+        # and sets it anyway. This patch disables the behavior when a Thread
+        # local variable is set.
+        module PatchDefaultContentType
+          def supply_default_content_type
+            return if Thread.current[:net_http_skip_default_content_type]
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/networking_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Raised when a networking error occurs.
+    class NetworkingError < StandardError
+      # @param [StandardError] error
+      def initialize(error)
+        super(error.message)
+        @original_error = error
+      end
+
+      attr_reader :original_error
+    end
+  end
+end

data/lib/smithy-client/pageable_response.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Raised when calling {PageableResponse#next_page} on a paginator that
+    # is on the last page of results. You can call {PageableResponse#last_page?}
+    # or {PageableResponse#next_page?} to know if there are more pages.
+    class LastPageError < RuntimeError
+      # @param [Response] response
+      def initialize(response)
+        @response = response
+        super('unable to fetch next page, end of results reached')
+      end
+
+      # @return [Response]
+      attr_reader :response
+    end
+
+    # Decorates a {Smithy::Client::Response} with paging convenience methods.
+    # Most API calls provide paged responses to limit the amount of data returned
+    # with each response. To optimize for latency, some APIs may return an
+    # inconsistent number of responses per page. You should rely on the values of
+    # the `next_page?` method or using enumerable methods such as `each_page` rather
+    # than the number of items returned to iterate through results. See below for
+    # examples.
+    #
+    # # Enumerator Methods
+    # The simplest way to handle paged response data is to use the built-in
+    # `each_page` enumerator on the response object:
+    #
+    #     weather = Weather::Client.new
+    #     weather.list_cities.each_page do |page|
+    #       puts page.items.map(&:name)
+    #     end
+    #
+    # This yields one response object per API call made. The SDK retrieves additional
+    # pages of data to complete the request.
+    #
+    # If the operation allows for it, a selected item can be enumerated using
+    # `each_item`:
+    #
+    #     weather = Weather::Client.new
+    #     weather.list_cities.each_item do |item|
+    #       puts item.name
+    #     end
+    #
+    # # Handling Paged Responses Manually
+    # To handle paging yourself, use the Response's `next_page?` method to verify
+    # there are more pages to retrieve, or use the `last_page?` method to verify
+    # there are no more pages to retrieve.
+    #
+    # If there are more pages, use the `next_page` method to retrieve the
+    # next page of results, as shown in the following example.
+    #
+    #     weather = Weather::Client.new
+    #
+    #     # Get the first page of data
+    #     response = weather.list_cities
+    #
+    #     # Get additional pages
+    #     while response.next_page?
+    #       response = response.next_page
+    #       # Use the response data here...
+    #       puts response.items.map(&:name)
+    #     end
+    #
+    module PageableResponse
+      # @api private
+      attr_accessor :paginator
+
+      # Returns `true` if there are no more results. Calling {#next_page}
+      # when this method returns `false` will raise an error.
+      # @return [Boolean]
+      def last_page?
+        return @last_page if @last_page
+
+        @last_page = !truncated?
+      end
+
+      # Returns `true` if there are more results. Calling {#next_page} will
+      # return the next response.
+      # @return [Boolean]
+      def next_page?
+        return @next_page if @next_page
+
+        @next_page = truncated?
+      end
+
+      # @param [Hash] params A hash of additional request params.
+      # @return [Response] Returns the next page of results.
+      def next_page(params = {})
+        raise LastPageError, self if last_page?
+
+        params = next_page_params(params)
+        context.client.send(context.operation_name, params)
+      end
+
+      # Yields the current and each following response to the given block.
+      # @yieldparam [Response] response
+      # @return [Enumerable, nil] Returns a new Enumerable if no block is given.
+      def each_page(&)
+        response = self
+        yield(response)
+        until response.last_page?
+          response = response.next_page
+          yield(response)
+        end
+      end
+
+      # Yields the current and each following item to the given block.
+      # @yieldparam [Object] item
+      # @return [Enumerable, nil] Returns a new Enumerable if no block is given.
+      def each_item(&)
+        response = self
+        @paginator.items(response.data).each(&)
+        until response.last_page?
+          response = response.next_page
+          @paginator.items(response.data).each(&)
+        end
+      end
+
+      private
+
+      def truncated?
+        next_t = @paginator.next_tokens(data)
+        !(next_t.empty? || next_t == @paginator.prev_tokens(context.params))
+      end
+
+      def next_page_params(params)
+        prev_tokens = @paginator.prev_tokens(context.params)
+        # Remove all previous tokens from original params
+        # Sometimes a token can be nil and merge would not include it.
+        new_params = context.params.except(*prev_tokens)
+        new_params.merge!(@paginator.next_tokens(data).merge(params))
+      end
+    end
+  end
+end

data/lib/smithy-client/param_converter.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'stringio'
+require 'date'
+require 'time'
+require 'tempfile'
+
+module Smithy
+  module Client
+    # @api private
+    class ParamConverter
+      include Schema::Shapes
+
+      @mutex = Mutex.new
+      @converters = Hash.new { |h, k| h[k] = {} }
+
+      def initialize(ref)
+        @ref = ref
+        @opened_files = []
+      end
+
+      attr_reader :opened_files
+
+      # @param [Hash] params
+      # @return [Hash]
+      def convert(params)
+        structure(@ref, params)
+      end
+
+      def close_opened_files
+        @opened_files.each(&:close)
+        @opened_files = []
+      end
+
+      private
+
+      def c(ref, value)
+        self.class.c(ref.shape.class, value, self)
+      end
+
+      def shape(ref, value)
+        case ref.shape
+        when ListShape then list(ref, value)
+        when MapShape then map(ref, value)
+        when StructureShape then structure(ref, value)
+        when UnionShape then union(ref, value)
+        else c(ref, value)
+        end
+      end
+
+      def list(ref, values)
+        values = c(ref, values)
+        return values unless values.is_a?(Array)
+
+        values.collect { |v| shape(ref.shape.member, v) }
+      end
+
+      def map(ref, values)
+        values = c(ref, values)
+        return values unless values.is_a?(Hash)
+
+        values.each.with_object({}) do |(key, value), hash|
+          hash[shape(ref.shape.key, key)] = shape(ref.shape.value, value)
+        end
+      end
+
+      def structure(ref, values)
+        values = c(ref, values)
+        return values unless values.respond_to?(:each_pair)
+
+        values.each_pair do |k, v|
+          next if v.nil?
+          next unless ref.shape.member?(k)
+
+          values[k] = shape(ref.shape.member(k), v)
+        end
+        values
+      end
+
+      def union(ref, values)
+        values = c(ref, values)
+
+        if values.is_a?(Schema::Union)
+          _name, member_ref = ref.shape.member_by_type(values.class)
+          values = shape(member_ref, values)
+        else
+          key, value = values.first
+          values[key] = shape(ref.shape.member(key), value)
+        end
+        values
+      end
+
+      class << self
+        # Registers a new value converter. Converters run in the context
+        # of a shape and value class.
+        #
+        #     # add a converter that stringifies integers
+        #     shape_class = Shapes::StringShape
+        #     ParamConverter.add(shape_class, Integer) { |i| i.to_s }
+        #
+        # @param [Class<Shapes::Shape>] shape_class
+        # @param [Class] value_class
+        # @param [#call] block An object that responds to `#call`
+        #    accepting a single argument. This function should perform
+        #    the value conversion if possible, returning the result.
+        #    If the conversion is not possible, the original value should
+        #    be returned.
+        # @return [void]
+        def add(shape_class, value_class, &block)
+          @converters[shape_class][value_class] = block
+        end
+
+        def ensure_open(file, converter)
+          if file.closed?
+            new_file = File.open(file.path, 'rb')
+            converter.opened_files << new_file
+            new_file
+          else
+            file
+          end
+        end
+
+        def c(shape, value, instance = nil)
+          if (converter = converter_for(shape, value))
+            converter.call(value, instance)
+          else
+            value
+          end
+        end
+
+        private
+
+        def converter_for(shape_class, value)
+          unless @converters[shape_class].key?(value.class)
+            @mutex.synchronize do
+              unless @converters[shape_class].key?(value.class)
+                @converters[shape_class][value.class] = find(shape_class, value)
+              end
+            end
+          end
+          @converters[shape_class][value.class]
+        end
+
+        def find(shape_class, value)
+          converter = nil
+          each_base_class(shape_class) do |klass|
+            @converters[klass].each do |value_class, block|
+              if value.is_a?(value_class)
+                converter = block
+                break
+              end
+            end
+            break if converter
+          end
+          converter
+        end
+
+        def each_base_class(shape_class, &)
+          shape_class.ancestors.each do |ancestor|
+            yield(ancestor) if @converters.key?(ancestor)
+          end
+        end
+      end
+
+      add(BigDecimalShape, BigDecimal)
+      add(BigDecimalShape, Integer) { |i| BigDecimal(i) }
+      add(BigDecimalShape, Float) { |f| BigDecimal(f.to_s) }
+      add(BigDecimalShape, String) do |str|
+        BigDecimal(str)
+      rescue ArgumentError
+        str
+      end
+
+      add(BlobShape, IO)
+      add(BlobShape, File) { |file, converter| ensure_open(file, converter) }
+      add(BlobShape, Tempfile) { |tmpfile, converter| ensure_open(tmpfile, converter) }
+      add(BlobShape, StringIO)
+      add(BlobShape, String)
+
+      add(BooleanShape, TrueClass)
+      add(BooleanShape, FalseClass)
+      add(BooleanShape, String) do |str|
+        { 'true' => true, 'false' => false }[str]
+      end
+
+      add(EnumShape, String)
+      add(EnumShape, Symbol) { |sym, _| sym.to_s }
+
+      add(IntegerShape, Integer)
+      add(IntegerShape, Float) { |f, _| f.to_i }
+      add(IntegerShape, String) do |str|
+        Integer(str)
+      rescue ArgumentError
+        str
+      end
+
+      add(IntEnumShape, Integer)
+      add(IntEnumShape, Float) { |f, _| f.to_i }
+      add(IntEnumShape, String) do |str|
+        Integer(str)
+      rescue ArgumentError
+        str
+      end
+
+      add(FloatShape, Float)
+      add(FloatShape, Integer) { |i, _| i.to_f }
+      add(FloatShape, String) do |str|
+        Float(str)
+      rescue ArgumentError
+        str
+      end
+
+      add(ListShape, Array) { |a, _| a.dup }
+      add(ListShape, Enumerable) { |v, _| v.to_a }
+
+      add(MapShape, Hash) { |h, _| h.dup }
+      add(MapShape, ::Struct) do |s|
+        s.members.each.with_object({}) { |k, h| h[k] = s[k] }
+      end
+
+      add(StringShape, String)
+      add(StringShape, Symbol) { |sym, _| sym.to_s }
+
+      add(StructureShape, Hash) { |h, _| h.dup }
+      add(StructureShape, ::Struct)
+
+      add(TimestampShape, Time)
+      add(TimestampShape, Date) { |d, _| d.to_time }
+      add(TimestampShape, DateTime) { |dt, _| dt.to_time }
+      add(TimestampShape, Integer) { |i| Time.at(i) }
+      add(TimestampShape, Float) { |f| Time.at(f) }
+      add(TimestampShape, String) do |str|
+        Time.parse(str)
+      rescue ArgumentError
+        str
+      end
+
+      add(UnionShape, Hash) { |h, _| h.dup }
+      add(UnionShape, Schema::Union)
+    end
+  end
+end