smithy-client 1.0.0.pre0 → 1.0.0.pre1

data/lib/smithy-client/default_params.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'time'
+
+module Smithy
+  module Client
+    # @api private
+    class DefaultParams
+      include Schema::Shapes
+
+      def initialize(ref)
+        @ref = ref
+      end
+
+      # @param [Hash] params
+      # @return [Hash]
+      def apply(params)
+        structure(@ref, params)
+      end
+
+      private
+
+      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)
+        else value
+        end
+      end
+
+      def list(ref, values)
+        return if values.nil?
+
+        shape = ref.shape
+        values.each do |value|
+          shape(shape.member, value)
+        end
+        values
+      end
+
+      def map(ref, values)
+        return if values.nil?
+
+        shape = ref.shape
+        values.each_pair do |_key, value|
+          shape(shape.value, value)
+        end
+        values
+      end
+
+      def structure(ref, values)
+        return if values.nil?
+
+        ref.shape.members.each do |member_name, member_ref|
+          value = values[member_name]
+          value ||= default(member_ref) if default?(ref, member_ref.traits)
+          next if value.nil? && !default?(ref, member_ref.traits) # default can have nil values
+
+          values[member_name] = shape(member_ref, value)
+        end
+        values
+      end
+
+      def default?(ref, traits)
+        # skip defaults for top level members
+        return false if ref == @ref
+
+        traits.include?('smithy.api#default') && !traits.include?('smithy.api#clientOptional')
+      end
+
+      def default(ref)
+        default = ref.traits['smithy.api#default']
+        case ref.shape
+        when BlobShape then Base64.strict_decode64(default)
+        when TimestampShape then timestamp_default(default)
+        else default
+        end
+      end
+
+      def timestamp_default(default)
+        case default
+        when String then Time.parse(default)
+        when Integer then Time.at(default)
+        else raise ArgumentError, "Invalid default value for Timestamp: #{default.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/dynamic_errors.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # This module is mixed into generated Errors modules, providing dynamic
+    # error classes. Error classes all inherit from {ServiceError}.
+    #
+    #     # Creates and returns the class
+    #     Weather::Errors::MyNewErrorClass
+    #
+    # Since the complete list of possible errors returned by services may
+    # not be known, this allows us to create them as needed. This also
+    # allows users to rescue errors by class without them being concrete
+    # classes beforehand.
+    #
+    # @api private
+    module DynamicErrors
+      def self.extended(submodule)
+        submodule.instance_variable_set('@const_set_mutex', Mutex.new)
+        submodule.const_set(:ServiceError, Class.new(ServiceError))
+      end
+
+      def const_missing(constant)
+        set_error_constant(constant)
+      end
+
+      # Given the name of a service and an error code, this method
+      # returns an error class that extends {ServiceError}.
+      #
+      #     Weather::Errors.error_class('NoSuchCity').new
+      #     #=> #<Weather::Errors::NoSuchCity>
+      #
+      # @api private
+      def error_class(error_code)
+        constant = error_class_constant(error_code)
+        if error_const_set?(constant)
+          err_class = const_get(constant)
+          err_class.code = constant.to_s
+          err_class
+        else
+          set_error_constant(constant)
+        end
+      end
+
+      private
+
+      # Convert an error code to an error class name/constant.
+      # This requires filtering non-safe characters from the constant
+      # name and ensuring it begins with an uppercase letter.
+      #
+      # @param [String] error_code
+      # @return [Symbol] Returns a symbolized constant name for the given `error_code`.
+      def error_class_constant(error_code)
+        constant = error_code.to_s
+        constant = constant.gsub(/https?:.*$/, '')
+        constant = constant.gsub(/[^a-zA-Z0-9]/, '')
+        constant = "Error#{constant}" unless constant.match(/^[a-z]/i)
+        constant = constant[0].upcase + constant[1..]
+        constant.to_sym
+      end
+
+      def set_error_constant(constant) # rubocop:disable Naming/AccessorMethodName
+        @const_set_mutex.synchronize do
+          # Ensure the const was not defined while blocked by the mutex
+          if error_const_set?(constant)
+            const_get(constant)
+          else
+            error_class = Class.new(const_get(:ServiceError))
+            error_class.code = constant.to_s
+            const_set(constant, error_class)
+          end
+        end
+      end
+
+      def error_const_set?(constant)
+        # Purposefully not using #const_defined? as that method returns true
+        # for constants not defined directly in the current module.
+        constants.include?(constant.to_sym)
+      end
+    end
+  end
+end

data/lib/smithy-client/endpoint_rules.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'ipaddr'
+require 'uri'
+
+module Smithy
+  module Client
+    # 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
+      # Regex that extracts anything in square brackets
+      BRACKET_REGEX = /\[(.*?)\]/
+
+      # An Endpoint resolved by an EndpointProvider
+      class Endpoint
+        # @param [String] uri
+        # @param [Hash] properties ({})
+        # @param [Hash] headers ({})
+        def initialize(uri:, properties: {}, headers: {})
+          @uri = uri
+          @properties = properties
+          @headers = headers
+        end
+
+        # The URI of the endpoint.
+        # @return [String]
+        attr_accessor :uri
+
+        # The authentication schemes supported by the endpoint.
+        # @return [Hash]
+        attr_accessor :properties
+
+        # The headers to include in requests to the endpoint.
+        # @return [Hash]
+        attr_accessor :headers
+      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
+      def self.valid_host_label?(value, allow_sub_domains)
+        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
+
+      # 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
+
+      # isSet(value: Option<T>) bool
+      # @api private
+      def self.set?(value)
+        !value.nil?
+      end
+
+      # not(value: bool) bool
+      # @api private
+      def self.not?(bool)
+        !bool
+      end
+
+      # getAttr(value: Object | Array, path: string) Document
+      # @api private
+      def self.attr(value, path)
+        parts = path.split('.')
+
+        val = attr_brackets(parts, value)
+
+        if parts.size == 1
+          val
+        else
+          attr(val, parts.slice(1..-1).join('.')) # rubocop:disable Style/Attr
+        end
+      end
+
+      # stringEquals(value1: string, value2: string) bool
+      # @api private
+      def self.string_equals?(value1, value2)
+        value1 == value2
+      end
+
+      # booleanEquals(value1: bool, value2: bool) bool
+      # @api private
+      def self.boolean_equals?(value1, value2)
+        value1 == value2
+      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 = extract_authority(url, uri)
+          @path = uri.path
+          @normalized_path = uri.path + (uri.path[-1] == '/' ? '' : '/')
+          @is_ip = ip?(uri.host)
+        end
+
+        attr_reader :scheme, :authority, :path, :normalized_path, :is_ip
+
+        def as_json(*)
+          {
+            'scheme' => scheme,
+            'authority' => authority,
+            'path' => path,
+            'normalizedPath' => normalized_path,
+            'isIp' => is_ip
+          }
+        end
+
+        private
+
+        def extract_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 ip?(authority)
+          IPAddr.new(authority)
+          true
+        rescue IPAddr::InvalidAddressError
+          false
+        end
+      end
+
+      def self.attr_brackets(parts, value)
+        if (index = parts.first[BRACKET_REGEX, 1])
+          # remove brackets and index from part before indexing
+          if (base = parts.first.gsub(BRACKET_REGEX, '')) && !base.empty?
+            value[base][index.to_i]
+          else
+            value[index.to_i]
+          end
+        else
+          value[parts.first]
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/handler.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Base class for handlers in the client stack.
+    class Handler
+      # @param [Handler] handler (nil) The next handler in the stack that
+      #  should be called from within the {#call} method. This value
+      #  must only be nil for send handlers.
+      def initialize(handler = nil)
+        @handler = handler
+      end
+
+      # @return [Handler, nil]
+      attr_accessor :handler
+
+      # @param [Smithy::Client::HandlerContext] context
+      # @return [Smithy::Client::Response]
+      def call(context)
+        @handler.call(context)
+      end
+
+      # @api private
+      def inspect
+        "#<#{self.class.name || 'UnknownHandler'} @handler=#{@handler.inspect}>"
+      end
+    end
+  end
+end

data/lib/smithy-client/handler_builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # This module provides the ability to add handlers to a class or
+    # module. The including class or extending module must respond to
+    # `#handlers`, returning a {HandlerList}.
+    module HandlerBuilder
+      def handle(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        handler_class = block ? handler_for(*args, &block) : args.first
+        handlers.add(handler_class, options)
+      end
+      alias handler handle
+
+      private
+
+      def handler_for(name = nil, &block)
+        if name
+          const_set(name, new_handler(block))
+        else
+          new_handler(block)
+        end
+      end
+
+      def new_handler(block)
+        Class.new(Handler) do
+          define_method(:call, &block)
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/handler_context.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Context that is passed to handlers during execution.
+    class HandlerContext
+      # @option options [Symbol] :operation_name (nil)
+      # @option options [OperationShape] :operation (nil)
+      # @option options [Base] :client (nil)
+      # @option options [Hash] :params ({})
+      # @option options [Configuration] :config (nil)
+      # @option options [HTTP::Request] :http_request (HTTP::Request.new)
+      # @option options [HTTP::Response] :http_response (HTTP::Response.new)
+      # @option options [Hash] :metadata ({})
+      def initialize(options = {})
+        @operation_name = options[:operation_name]
+        @operation = options[:operation]
+        @client = options[:client]
+        @params = options[:params] || {}
+        @config = options[:config]
+        @http_request = options[:http_request] || HTTP::Request.new
+        @http_response = options[:http_response] || HTTP::Response.new
+        @retries = 0
+        @metadata = {}
+      end
+
+      # @return [Symbol] Name of the API operation called.
+      attr_accessor :operation_name
+
+      # @return [OperationShape] Shape of the Operation called.
+      attr_accessor :operation
+
+      # @return [Base]
+      attr_accessor :client
+
+      # @return [Hash] The request parameters as a Hash.
+      attr_accessor :params
+
+      # @return [Struct] The client configuration.
+      attr_accessor :config
+
+      # @return [HTTP::Request]
+      attr_accessor :http_request
+
+      # @return [HTTP::Response]
+      attr_accessor :http_response
+
+      # @return [Integer]
+      attr_accessor :retries
+
+      # @return [Hash]
+      attr_reader :metadata
+
+      # @param [Symbol] key
+      # @return [Object]
+      def [](key)
+        @metadata[key]
+      end
+
+      # @param [Symbol] key
+      # @param [Object] value
+      def []=(key, value)
+        @metadata[key] = value
+      end
+    end
+  end
+end

data/lib/smithy-client/handler_list.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # A list of handlers that are used to build a handler stack.
+    class HandlerList
+      include Enumerable
+
+      # @api private
+      def initialize(options = {})
+        @index = options[:index] || 0
+        @entries = {}
+        @mutex = Mutex.new
+        entries = options[:entries] || []
+        add_entries(entries) unless entries.empty?
+      end
+
+      # Yields the handlers in stack order, which is reverse priority.
+      # @yieldparam [Class<Handler>] handler_class
+      def each
+        entries.sort.each do |entry|
+          yield(entry.handler_class) if entry.operations.nil?
+        end
+      end
+
+      # @return [Array<HandlerListEntry>]
+      def entries
+        @mutex.synchronize do
+          @entries.values
+        end
+      end
+
+      # Registers a handler. Handlers are used to build a handler stack.
+      # Handlers default to the `:build` step with default priority of 50.
+      # The step and priority determine where in the stack a handler
+      # will be.
+      #
+      # ## Handler Stack Ordering
+      #
+      # A handler stack is built from the inside-out. The stack is
+      # seeded with the send handler. Handlers are constructed recursively
+      # in reverse step and priority order so that the highest priority
+      # handler is on the outside.
+      #
+      # By constructing the stack from the inside-out, this ensures
+      # that the validate handlers will be called first and the sign handlers
+      # will be called just before the final and only send handler is called.
+      #
+      # ## Steps
+      #
+      # Handlers are ordered first by step. These steps represent the
+      # life-cycle of a request. Valid steps are:
+      #
+      # * `:initialize`
+      # * `:validate`
+      # * `:build`
+      # * `:retry`
+      # * `:parse`
+      # * `:sign`
+      # * `:send`
+      #
+      # Many handlers can be added to the same step, except for `:send`.
+      # There can be only one `:send` handler. Adding an additional
+      # `:send` handler replaces the previous one.
+      #
+      # ## Priorities
+      #
+      # Handlers within a single step are executed in priority order. The
+      # higher the priority, the earlier in the stack the handler will
+      # be called.
+      #
+      # * Handler priority is an integer between 0 and 99, inclusively.
+      # * Handler priority defaults to 50.
+      # * When multiple handlers are added to the same step with the same
+      #   priority, the last one added will have the highest priority and
+      #   the first one added will have the lowest priority.
+      #
+      # @param [Class<Handler>] handler_class This should be a subclass
+      #  of {Handler}.
+      #
+      # @option options [Symbol] :step (:build) The request life-cycle
+      #  step the handler should run in. Defaults to `:build`. The
+      #  list of possible steps, in high-to-low priority order are:
+      #
+      #  * `:initialize`
+      #  * `:validate`
+      #  * `:build`
+      #  * `:retry`
+      #  * `:parse`
+      #  * `:sign`
+      #  * `:send`
+      #
+      # @option options [Integer] :priority (50) The priority of this
+      #  handler within a step. The priority must be between 0 and 99
+      #  inclusively. It defaults to 50. When two handlers have the
+      #  same `:step` and `:priority`, the handler registered last has
+      #  the highest priority.
+      #
+      # @option options [Array<Symbol>] :operations A list of
+      #  operations names the handler should be applied to. When
+      #  `:operations` is omitted, the handler is applied to all
+      #  operations for the client.
+      #
+      # @raise ArgumentError if the priority is not between 0 and 99 or
+      #  if the step is not a valid step.
+      # @return [Class<Handler>] Returns the handler class that was added.
+      #
+      def add(handler_class, options = {})
+        @mutex.synchronize do
+          add_entry(
+            HandlerListEntry.new(
+              options.merge(
+                handler_class: handler_class,
+                inserted: next_index
+              )
+            )
+          )
+        end
+        handler_class
+      end
+
+      # @param [Class<Handler>] handler_class
+      def remove(handler_class)
+        @mutex.synchronize do
+          @entries.each do |key, entry|
+            remove_entry(key, entry, handler_class)
+          end
+        end
+      end
+
+      # Copies handlers from the `source_list` onto the current handler list.
+      # If a block is given, only the entries that return a `true` value
+      # from the block will be copied.
+      # @param [HandlerList] source_list
+      # @return [void]
+      def copy_from(source_list)
+        entries = []
+        source_list.entries.each do |entry|
+          if block_given?
+            entries << entry.copy(inserted: next_index) if yield(entry)
+          else
+            entries << entry.copy(inserted: next_index)
+          end
+        end
+        add_entries(entries)
+      end
+
+      # Returns a handler list for the given operation.  The returned
+      # will have the operation specific handlers merged with the common
+      # handlers.
+      # @param [Symbol] operation The name of an operation.
+      # @return [HandlerList]
+      def for(operation)
+        HandlerList.new(index: @index, entries: filter(operation))
+      end
+
+      # Constructs the handlers recursively, building a handler stack.
+      # The `:send` handler will be at the top of the stack and the
+      # `:validate` handlers will be at the bottom.
+      # @return [Handler, nil]
+      def to_stack
+        inject(nil) { |stack, handler| handler.new(stack) }
+      end
+
+      private
+
+      def add_entries(entries)
+        @mutex.synchronize do
+          entries.each { |entry| add_entry(entry) }
+        end
+      end
+
+      def add_entry(entry)
+        key = entry.step == :send ? :send : entry.object_id
+        @entries[key] = entry
+      end
+
+      def remove_entry(key, entry, handler_class)
+        @entries.delete(key) if entry.handler_class == handler_class
+      end
+
+      def filter(operation)
+        entries.each_with_object([]) do |entry, filtered|
+          if entry.operations.nil?
+            filtered << entry.copy
+          elsif entry.operations.include?(operation)
+            filtered << entry.copy(operations: nil)
+          end
+        end
+      end
+
+      def next_index
+        @index += 1
+      end
+    end
+  end
+end