aws-sdk-core 2.11.212 → 3.170.0

data/lib/aws-sdk-core/param_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   # @api private
   class ParamValidator
@@ -16,8 +18,13 @@ module Aws
     # @param [Seahorse::Model::Shapes::ShapeRef] rules
     # @option options [Boolean] :validate_required (true)
     def initialize(rules, options = {})
-      @rules = rules
+      @rules = rules || begin
+        shape = StructureShape.new
+        shape.struct_class = EmptyStructure
+        ShapeRef.new(shape: shape)
+      end
       @validate_required = options[:validate_required] != false
+      @input = options[:input].nil? ? true : !!options[:input]
     end
 
     # @param [Hash] params
@@ -34,28 +41,58 @@ module Aws
       # ensure the value is hash like
       return unless correct_type?(ref, values, errors, context)
 
-      shape = ref.shape
+      if ref.eventstream
+        # input eventstream is provided from event signals
+        values.each do |value|
+          # each event is structure type
+          case value[:message_type]
+          when 'event'
+            val = value.dup
+            val.delete(:message_type)
+            structure(ref.shape.member(val[:event_type]), val, errors, context)
+          when 'error' # Error is unmodeled
+          when 'exception' # Pending
+            raise Aws::Errors::EventStreamParserError.new(
+              ':exception event validation is not supported')
+          end
+        end
+      else
+        shape = ref.shape
+
+        # ensure required members are present
+        if @validate_required
+          shape.required.each do |member_name|
+            input_eventstream = ref.shape.member(member_name).eventstream && @input
+            if values[member_name].nil? && !input_eventstream
+              param = "#{context}[#{member_name.inspect}]"
+              errors << "missing required parameter #{param}"
+            end
+          end
+        end
 
-      # ensure required members are present
-      if @validate_required
-        shape.required.each do |member_name|
-          if values[member_name].nil?
-            param = "#{context}[#{member_name.inspect}]"
-            errors << "missing required parameter #{param}"
+        if @validate_required && shape.union
+          if values.length > 1
+            errors << "multiple values provided to union at #{context} - must contain exactly one of the supported types: #{shape.member_names.join(', ')}"
+          elsif values.length == 0
+            errors << "No values provided to union at #{context} - must contain exactly one of the supported types: #{shape.member_names.join(', ')}"
           end
         end
-      end
 
-      # validate non-nil members
-      values.each_pair do |name, value|
-        unless value.nil?
-          if shape.member?(name)
-            member_ref = shape.member(name)
-            shape(member_ref, value, errors, context + "[#{name.inspect}]")
-          else
-            errors << "unexpected value at #{context}[#{name.inspect}]"
+        # validate non-nil members
+        values.each_pair do |name, value|
+          unless value.nil?
+            # :event_type is not modeled
+            # and also needed when construct body
+            next if name == :event_type
+            if shape.member?(name)
+              member_ref = shape.member(name)
+              shape(member_ref, value, errors, context + "[#{name.inspect}]")
+            else
+              errors << "unexpected value at #{context}[#{name.inspect}]"
+            end
           end
         end
+
       end
     end
 
@@ -74,8 +111,10 @@ module Aws
     end
 
     def map(ref, values, errors, context)
-
-      return unless correct_type?(ref, values, errors, context)
+      unless Hash === values
+        errors << expected_got(context, "a hash", values)
+        return
+      end
 
       key_ref = ref.shape.key
       value_ref = ref.shape.value
@@ -86,11 +125,32 @@ module Aws
       end
     end
 
+    def document(ref, value, errors, context)
+      document_types = [Hash, Array, Numeric, String, TrueClass, FalseClass, NilClass]
+      unless document_types.any? { |t| value.is_a?(t) }
+        errors << expected_got(context, "one of #{document_types.join(', ')}", value)
+      end
+
+      # recursively validate types for aggregated types
+      case value
+      when Hash
+        value.each do |k, v|
+          document(ref, v, errors, context + "[#{k}]")
+        end
+      when Array
+        value.each do |v|
+          document(ref, v, errors, context)
+        end
+      end
+
+    end
+
     def shape(ref, value, errors, context)
       case ref.shape
       when StructureShape then structure(ref, value, errors, context)
       when ListShape then list(ref, value, errors, context)
       when MapShape then map(ref, value, errors, context)
+      when DocumentShape then document(ref, value, errors, context)
       when StringShape
         unless value.is_a?(String)
           errors << expected_got(context, "a String", value)
@@ -112,8 +172,22 @@ module Aws
           errors << expected_got(context, "true or false", value)
         end
       when BlobShape
-        unless io_like?(value) or value.is_a?(String)
-          errors << expected_got(context, "a String or IO object", value)
+        unless value.is_a?(String)
+          if streaming_input?(ref)
+            unless io_like?(value, _require_size = false)
+              errors << expected_got(
+                context,
+                "a String or IO like object that supports read and rewind",
+                value
+              )
+            end
+          elsif !io_like?(value, _require_size = true)
+            errors << expected_got(
+              context,
+              "a String or IO like object that supports read, rewind, and size",
+              value
+            )
+          end
         end
       else
         raise "unhandled shape type: #{ref.shape.class.name}"
@@ -121,19 +195,28 @@ module Aws
     end
 
     def correct_type?(ref, value, errors, context)
+      if ref.eventstream && @input
+        errors << "instead of providing value directly for eventstreams at input,"\
+                  " expected to use #signal events per stream"
+        return false
+      end
       case value
       when Hash then true
-      when ref[:struct_class] then true
+      when ref.shape.struct_class then true
+      when Enumerator then ref.eventstream && value.respond_to?(:event_types)
       else
         errors << expected_got(context, "a hash", value)
         false
       end
     end
 
-    def io_like?(value)
-      value.respond_to?(:read) &&
-      value.respond_to?(:rewind) &&
-      value.respond_to?(:size)
+    def io_like?(value, require_size = true)
+      value.respond_to?(:read) && value.respond_to?(:rewind) &&
+        (!require_size || value.respond_to?(:size))
+    end
+
+    def streaming_input?(ref)
+      (ref["streaming"] || ref.shape["streaming"])
     end
 
     def error_messages(errors)

data/lib/aws-sdk-core/plugins/api_key.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+
+    # Provide support for `api_key` parameter for `api-gateway` protocol
+    # specific `api-gateway` protocol gems' user-agent
+    class ApiKey < Seahorse::Client::Plugin
+
+      option(:api_key,
+        default: nil,
+        doc_type: 'String',
+        docstring: <<-DOCS)
+When provided, `x-api-key` header will be injected with the value provided.
+        DOCS
+
+      def add_handlers(handlers, config)
+        handlers.add(OptionHandler, step: :initialize)
+        handlers.add(ApiKeyHandler, step: :build, priority: 0)
+      end
+
+      # @api private
+      class OptionHandler < Seahorse::Client::Handler
+        def call(context)
+          if context.operation.require_apikey
+            if context.params.is_a?(Hash) && context.params[:api_key]
+              api_key = context.params.delete(:api_key)
+            end
+            api_key = context.config.api_key if api_key.nil?
+            context[:api_key] = api_key
+          end
+
+          @handler.call(context)
+        end
+
+      end
+
+      # @api private
+      class ApiKeyHandler < Seahorse::Client::Handler
+
+        def call(context)
+          if context[:api_key]
+            apply_api_key(context)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_api_key(context)
+          context.http_request.headers['x-api-key'] = context[:api_key]
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/apig_authorizer_token.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+
+    # apply APIG custom authorizer token to
+    # operations with 'authtype' of 'custom' only
+    class APIGAuthorizerToken < Seahorse::Client::Plugin
+
+      option(:authorizer_token, default: nil)
+
+      def add_handlers(handlers, config)
+        handlers.add(AuthTokenHandler, step: :sign)
+      end
+
+      # @api private
+      class AuthTokenHandler < Seahorse::Client::Handler
+
+        def call(context)
+          if context.operation['authtype'] == 'custom' &&
+            context.config.authorizer_token &&
+            context.authorizer.placement[:location] == 'header'
+
+            header = context.authorizer.placement[:name]
+            context.http_request.headers[header] = context.config.authorizer_token
+          end
+          @handler.call(context)
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/apig_credentials_configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Plugins
+    # @api private
+    # Used for APIGateway generated SDKs credentials config
+    class APIGCredentialsConfiguration < Seahorse::Client::Plugin
+
+      option(:access_key_id, doc_type: String, docstring: '')
+
+      option(:secret_access_key, doc_type: String, docstring: '')
+
+      option(:session_token, doc_type: String, docstring: '')
+
+      option(:profile, doc_type: String, docstring: '')
+
+      option(:credentials,
+        required: false,
+        doc_type: 'Aws::CredentialProvider',
+        docstring: <<-DOCS
+AWS Credentials options is only required when your API uses 
+[AWS Signature Version 4](http://docs.aws.amazon.com/general/latest/gr/signature-version-4.html),
+more AWS Credentials Configuration Options are available [here](https://github.com/aws/aws-sdk-ruby#configuration).
+        DOCS
+      ) do |config|
+        CredentialProviderChain.new(config).resolve
+      end
+
+      option(:instance_profile_credentials_retries, 0)
+
+      option(:instance_profile_credentials_timeout, 1)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/apig_user_agent.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    # @api private
+    class APIGUserAgent < Seahorse::Client::Plugin
+
+      option(:user_agent_suffix)
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          set_user_agent(context)
+          @handler.call(context)
+        end
+
+        def set_user_agent(context)
+          ua = "aws-apig-ruby/#{CORE_GEM_VERSION}"
+
+          begin
+            ua += " #{RUBY_ENGINE}/#{RUBY_VERSION}"
+          rescue
+            ua += " RUBY_ENGINE_NA/#{RUBY_VERSION}"
+          end
+
+          ua += " #{RUBY_PLATFORM}"
+          ua += " #{context.config.user_agent_suffix}" if context.config.user_agent_suffix
+
+          context.http_request.headers['User-Agent'] = ua.strip
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/bearer_authorization.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Plugins
+    # @api private
+    class BearerAuthorization < Seahorse::Client::Plugin
+
+      option(:token_provider,
+             required: false,
+             doc_type: 'Aws::TokenProvider',
+             docstring: <<-DOCS
+A Bearer Token Provider. This can be an instance of any one of the
+following classes:
+
+* `Aws::StaticTokenProvider` - Used for configuring static, non-refreshing
+  tokens.
+
+* `Aws::SSOTokenProvider` - Used for loading tokens from AWS SSO using an
+  access token generated from `aws login`.
+
+When `:token_provider` is not configured directly, the `Aws::TokenProviderChain`
+will be used to search for tokens configured for your profile in shared configuration files.
+      DOCS
+      ) do |config|
+        if config.stub_responses
+          StaticTokenProvider.new('token')
+        else
+          TokenProviderChain.new(config).resolve
+        end
+      end
+
+
+      def add_handlers(handlers, cfg)
+        bearer_operations =
+          if cfg.api.metadata['signatureVersion'] == 'bearer'
+            # select operations where authtype is either not set or is bearer
+            cfg.api.operation_names.select do |o|
+              !cfg.api.operation(o)['authtype'] || cfg.api.operation(o)['authtype'] == 'bearer'
+            end
+          else # service is not bearer auth
+            # select only operations where authtype is explicitly bearer
+            cfg.api.operation_names.select do |o|
+              cfg.api.operation(o)['authtype'] == 'bearer'
+            end
+          end
+        handlers.add(Handler, step: :sign, operations: bearer_operations)
+      end
+
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          if context.http_request.endpoint.scheme != 'https'
+            raise ArgumentError, 'Unable to use bearer authorization on non https endpoint.'
+          end
+
+          token_provider = context.config.token_provider
+          if token_provider && token_provider.set?
+            context.http_request.headers['Authorization'] = "Bearer #{token_provider.token.token}"
+          else
+            raise Errors::MissingBearerTokenError
+          end
+          @handler.call(context)
+        end
+      end
+    end
+  end
+end