smithy-client 1.0.0.pre0 → 1.0.0.pre1

data/lib/smithy-client/handler_list_entry.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # A container for an un-constructed handler. A handler entry has the
+    # handler class, and information about handler priority/order.
+    #
+    # This class is an implementation detail of the {HandlerList} class.
+    # Do not rely on public interfaces of this class.
+    class HandlerListEntry
+      # @api private
+      STEPS = {
+        initialize: 600,
+        validate: 500,
+        build: 400,
+        retry: 300,
+        parse: 200,
+        sign: 100,
+        send: 0
+      }.freeze
+
+      # @option options [Handler, Class<Handler>] :handler_class
+      # @option options [Integer] :inserted The insertion
+      #  order/position. This is used to determine sort order when two
+      #  entries have the same priority.
+      # @option options [Symbol] :step (:build)
+      # @option options [Integer] :priority (50)
+      # @option options [Set<String>, nil] :operations (nil)
+      def initialize(options)
+        @options = options
+        @handler_class = options[:handler_class]
+        @inserted = options[:inserted]
+        @operations = Set.new(options[:operations]) if options[:operations]
+        self.step = options[:step] || :build
+        self.priority = options[:priority] || 50
+        compute_weight
+      end
+
+      # @return [Handler, Class<Handler>] Returns the handler. This may
+      #  be a constructed handler object or a handler class.
+      attr_reader :handler_class
+
+      # @return [Integer] The insertion order/position. This is used to
+      #  determine sort order when two entries have the same priority.
+      #  Entries inserted later (with a higher inserted value) have a
+      #  lower priority.
+      attr_reader :inserted
+
+      # @return [Symbol]
+      attr_reader :step
+
+      # @return [Integer]
+      attr_reader :priority
+
+      # @return [Set<String>, nil]
+      attr_reader :operations
+
+      # @return [Integer]
+      attr_reader :weight
+
+      # @return [Integer]
+      def <=>(other)
+        if weight == other.weight
+          other.inserted <=> inserted
+        else
+          weight <=> other.weight
+        end
+      end
+
+      # @option options (see #initialize)
+      # @return [HandlerListEntry]
+      def copy(options = {})
+        HandlerListEntry.new(@options.merge(options))
+      end
+
+      private
+
+      def step=(step)
+        if STEPS.key?(step)
+          @step = step
+        else
+          msg = "invalid :step `%s', must be one of :initialize, :validate, " \
+                ':build, :retry, :parse, :sign or :send'
+          raise ArgumentError, msg % step.inspect
+        end
+      end
+
+      def priority=(priority)
+        if (0..99).include?(priority)
+          @priority = priority
+        else
+          msg = "invalid :priority `%s', must be between 0 and 99"
+          raise ArgumentError, msg % priority.inspect
+        end
+      end
+
+      def compute_weight
+        @weight = STEPS[@step] + @priority
+      end
+    end
+  end
+end

data/lib/smithy-client/http/error_inspector.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Smithy
+  module Client
+    module HTTP
+      # An HTTP error inspector, using hints from status code and headers.
+      class ErrorInspector
+        def initialize(error, http_response)
+          @error = error
+          @http_response = http_response
+        end
+
+        def retryable?
+          (modeled_retryable? ||
+            throttling? ||
+            transient? ||
+            server?) &&
+            # IO does not respond to #truncate and is not rewindable
+            @http_response.body.respond_to?(:truncate)
+        end
+
+        def error_type
+          if transient?
+            'Transient'
+          elsif throttling?
+            'Throttling'
+          elsif server?
+            'ServerError'
+          elsif client?
+            'ClientError'
+          else
+            'Unknown'
+          end
+        end
+
+        def hints
+          hints = {}
+          if (retry_after = retry_after_hint)
+            hints[:retry_after] = retry_after
+          end
+          hints
+        end
+
+        private
+
+        def transient?
+          @error.is_a?(NetworkingError)
+        end
+
+        def throttling?
+          @http_response.status_code == 429 || modeled_throttling?
+        end
+
+        def server?
+          (500..599).cover?(@http_response.status_code)
+        end
+
+        def client?
+          (400..499).cover?(@http_response.status_code)
+        end
+
+        def modeled_retryable?
+          @error.is_a?(ServiceError) && @error.retryable?
+        end
+
+        def modeled_throttling?
+          modeled_retryable? && @error.throttling?
+        end
+
+        def retry_after_hint
+          retry_after = @http_response.headers['retry-after']
+          Integer(retry_after)
+        rescue ArgumentError # string is present, assume it is a date
+          begin
+            Time.parse(retry_after) - Time.now
+          rescue ArgumentError # empty string, somehow
+            nil
+          end
+        rescue TypeError # header is not present
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/http/headers.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module HTTP
+      # Provides a Hash-like interface for HTTP headers.  Header names
+      # are treated indifferently as lower-cased strings.  Header values
+      # are cast to strings.
+      #
+      #     headers = HTTP::Headers.new
+      #     headers['Content-Length'] = 100
+      #     headers[:Authorization] = 'Abc'
+      #
+      #     headers.keys
+      #     #=> ['content-length', 'authorization']
+      #
+      #     headers.values
+      #     #=> ['100', 'Abc']
+      #
+      # You can get the header values as a vanilla hash by calling {#to_h}:
+      #
+      #     headers.to_h
+      #     #=> { 'content-length' => '100', 'authorization' => 'Abc' }
+      #
+      class Headers
+        include Enumerable
+
+        # @api private
+        def initialize(headers = {})
+          @data = {}
+          headers.each_pair do |key, value|
+            self[key] = value
+          end
+        end
+
+        # @yield [key, value]
+        # @yieldparam [String] key
+        # @yieldparam [String] value
+        # @return [nil]
+        def each(&)
+          if block_given?
+            @data.each_pair(&)
+            nil
+          else
+            @data.enum_for(:each)
+          end
+        end
+        alias each_pair each
+
+        # @param [String] key
+        # @return [String]
+        def [](key)
+          @data[key.to_s.downcase]
+        end
+
+        # @param [String] key
+        # @param [String] value
+        def []=(key, value)
+          @data[key.to_s.downcase] = value.to_s
+        end
+
+        # @param [Hash] headers
+        # @return [Headers]
+        def update(headers)
+          headers.each_pair do |k, v|
+            self[k] = v
+          end
+          self
+        end
+
+        # @param [String] key
+        def delete(key)
+          @data.delete(key.to_s.downcase)
+        end
+
+        # @return [Headers]
+        def clear
+          @data = {}
+          self
+        end
+
+        # @return [Boolean]
+        def empty?
+          @data.empty?
+        end
+
+        # @return [Array<String>]
+        def keys
+          @data.keys
+        end
+
+        # @return [Array<String>]
+        def values
+          @data.values
+        end
+
+        # @return [Array<String>]
+        def values_at(*keys)
+          @data.values_at(*keys.map { |key| key.to_s.downcase })
+        end
+
+        # @return [Boolean] Returns `true` if the header is set.
+        def key?(key)
+          @data.key?(key.to_s.downcase)
+        end
+        alias has_key? key?
+        alias include? key?
+
+        # @return [Hash]
+        def to_hash
+          @data.dup
+        end
+        alias to_h to_hash
+
+        # @api private
+        def inspect
+          @data.inspect
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/http/request.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module Smithy
+  module Client
+    module HTTP
+      # Represents an HTTP request.
+      class Request
+        # @option options [String, URI::HTTP, URI::HTTPS, nil] :endpoint (nil)
+        # @option options [String] :http_method ('GET')
+        # @option options [Headers] :headers (Headers.new)
+        # @option options [IO, StringIO, #read, #size, #rewind] :body (StringIO.new)
+        def initialize(options = {})
+          self.endpoint = options[:endpoint]
+          @http_method = options[:http_method] || 'GET'
+          @headers = Headers.new(options[:headers] || {})
+          self.body = options[:body]
+        end
+
+        # @return [URI::HTTP, URI::HTTPS, nil]
+        attr_reader :endpoint
+
+        # @return [String]
+        attr_accessor :http_method
+
+        # @return [Headers]
+        attr_reader :headers
+
+        # @return [IO, StringIO]
+        attr_reader :body
+
+        # @param [String, URI::HTTP, URI::HTTPS, nil] endpoint
+        def endpoint=(endpoint)
+          endpoint = URI.parse(endpoint) if endpoint.is_a?(String)
+          unless endpoint.nil? || endpoint.is_a?(URI::HTTP) || endpoint.is_a?(URI::HTTPS)
+            msg = 'invalid endpoint, expected URI::HTTP, URI::HTTPS, or nil, ' \
+                  "got #{endpoint.inspect}"
+            raise ArgumentError, msg
+          end
+
+          @endpoint = endpoint
+        end
+
+        # @param [#read, #size, #rewind] io
+        def body=(io)
+          @body =
+            case io
+            when nil then StringIO.new
+            when String then StringIO.new(io)
+            else io
+            end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/http/response.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module Smithy
+  module Client
+    module HTTP
+      # Represents an HTTP Response.
+      class Response
+        # @option options [Integer] :status_code (0)
+        # @option options [Headers] :headers (Headers.new)
+        # @option options [IO] :body (StringIO.new)
+        def initialize(options = {})
+          @status_code = options[:status_code] || 0
+          @headers = Headers.new(options[:headers] || {})
+          self.body = options[:body]
+
+          @listeners = Hash.new { |h, k| h[k] = [] }
+          @done = nil
+          @error = nil
+        end
+
+        # @return [Integer]
+        attr_accessor :status_code
+
+        # @return [Headers]
+        attr_reader :headers
+
+        # @return [IO, StringIO]
+        attr_reader :body
+
+        # @return [StandardError, nil]
+        attr_reader :error
+
+        # @param [#read, #size, #rewind] io
+        def body=(io)
+          @body =
+            case io
+            when nil then StringIO.new
+            when String then StringIO.new(io)
+            else io
+            end
+        end
+
+        # @param [Integer] status_code
+        # @param [Hash<String, String>] headers
+        def signal_headers(status_code, headers)
+          @status_code = status_code
+          @headers = Headers.new(headers)
+          emit(:headers, @status_code, @headers)
+        end
+
+        # @param [string] chunk
+        def signal_data(chunk)
+          return if chunk == ''
+
+          @body.write(chunk)
+          emit(:data, chunk)
+        end
+
+        # Completes the http response.
+        #
+        # @example Completing the response in a single call
+        #
+        #     http_response.signal_done(
+        #       status_code: 200,
+        #       headers: {},
+        #       body: ''
+        #     )
+        #
+        # @example Complete the response in parts
+        #
+        #     # signal headers straight-way
+        #     http_response.signal_headers(200, {})
+        #
+        #     # signal data as it is received from the socket
+        #     http_response.signal_data("...")
+        #     http_response.signal_data("...")
+        #     http_response.signal_data("...")
+        #
+        #     # signal done once the body data is all written
+        #     http_response.signal_done
+        #
+        # @overload signal_done()
+        #
+        # @overload signal_done(options = {})
+        #   @option options [required, Integer] :status_code
+        #   @option options [required, Hash] :headers
+        #   @option options [required, String] :body
+        #
+        def signal_done(options = {})
+          if options.keys.sort == %i[body headers status_code]
+            signal_headers(options[:status_code], options[:headers])
+            signal_data(options[:body])
+            signal_done
+          elsif options.empty?
+            @body.rewind if @body.respond_to?(:rewind)
+            @done = true
+            emit(:done)
+          else
+            msg = 'options must be empty or must contain :status_code, :headers, ' \
+                  'and :body'
+            raise ArgumentError, msg
+          end
+        end
+
+        # @param [StandardError] error
+        def signal_error(error)
+          @error = error
+          signal_done
+        end
+
+        # @param [Integer, Range<Integer>] status_code_range
+        # @yield A block to be called when headers are received.
+        def on_headers(status_code_range = nil, &block)
+          @listeners[:headers] << listener(status_code_range, block)
+        end
+
+        # @yield A block to be called when data is received.
+        def on_data(&block)
+          @listeners[:data] << block
+        end
+
+        # @param [Integer, Range<Integer>] status_code_range
+        # @yield A block to be called when the response is complete.
+        def on_done(status_code_range = nil, &block)
+          listener = listener(status_code_range, block)
+          if @done
+            listener.call
+          else
+            @listeners[:done] << listener
+          end
+        end
+
+        # @param [Integer, Range<Integer>] status_code_range
+        # @yield A block to be called when the response is successful.
+        def on_success(status_code_range = 200..599)
+          on_done(status_code_range) do
+            yield unless @error
+          end
+        end
+
+        # @yieldparam [StandardError] error
+        # @yield A block to be called when an error occurs.
+        def on_error
+          on_done(0..599) do
+            yield(@error) if @error
+          end
+        end
+
+        # Resets the HTTP response.
+        def reset
+          @status_code = 0
+          @headers.clear
+          @body.truncate(0)
+          @error = nil
+        end
+
+        private
+
+        def listener(range, block)
+          range = range..range if range.is_a?(Integer)
+          if range
+            lambda do |*args|
+              block.call(*args) if range.include?(@status_code)
+            end
+          else
+            block
+          end
+        end
+
+        def emit(event_name, *args)
+          @listeners[event_name].each { |listener| listener.call(*args) }
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/http_api_key_provider.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Returns an HTTP API key identity
+    class HttpApiKeyProvider
+      # @param [String] key
+      def initialize(key)
+        @identity = Identities::HttpApiKey.new(key: key)
+      end
+
+      # @return [Identities::HttpApiKey]
+      def identity(_properties)
+        @identity
+      end
+    end
+  end
+end

data/lib/smithy-client/http_bearer_provider.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Returns an HTTP Bearer identity
+    class HttpBearerProvider
+      # @param [String] token
+      def initialize(token)
+        @identity = Identities::HttpBearer.new(token: token)
+      end
+
+      # @return [Identities::HttpBearer]
+      def identity(_properties)
+        @identity
+      end
+    end
+  end
+end

data/lib/smithy-client/http_login_provider.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Returns an HTTP login identity
+    class HttpLoginProvider
+      # @param [String] username
+      # @param [String] password
+      def initialize(username, password)
+        @identity = Identities::HttpLogin.new(username: username, password: password)
+      end
+
+      # @return [Identities::HttpLogin]
+      def identity(_properties)
+        @identity
+      end
+    end
+  end
+end

data/lib/smithy-client/identities/anonymous.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Identities
+      # @api private
+      class Anonymous < Identity; end
+    end
+  end
+end

data/lib/smithy-client/identities/http_api_key.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Identities
+      # Identity class for HTTP API Key authentication.
+      class HttpApiKey < Identity
+        def initialize(key:, **)
+          @key = key
+          super(**)
+        end
+
+        # @return [String, nil]
+        attr_reader :key
+      end
+    end
+  end
+end

data/lib/smithy-client/identities/http_bearer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Identities
+      # Identity class for HTTP Bearer token authentication.
+      class HttpBearer < Identity
+        def initialize(token:, **)
+          @token = token
+          super(**)
+        end
+
+        # @return [String, nil]
+        attr_reader :token
+      end
+    end
+  end
+end

data/lib/smithy-client/identities/http_login.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Identities
+      # Identity class for HTTP login authentication.
+      class HttpLogin < Identity
+        def initialize(username:, password:, **)
+          @username = username
+          @password = password
+          super(**)
+        end
+
+        # @return [String]
+        attr_reader :username
+
+        # @return [String]
+        attr_reader :password
+      end
+    end
+  end
+end

data/lib/smithy-client/identity.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Base class for all Identity classes.
+    class Identity
+      def initialize(expiration: nil)
+        @expiration = expiration
+      end
+
+      # @return [Time, nil]
+      attr_reader :expiration
+    end
+  end
+end