aws-sdk-core 3.196.1 → 3.199.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Cbor
+
+    # CBOR Tagged data (Major type 6).
+    # A Tag consists of a tag number and a value.
+    # In the extended generic data model, a tag number's definition
+    # describes the additional semantics conveyed with the tag number.
+    # # @!method initialize(*args)
+    #   @option args [Integer] :tag The tag number.
+    #   @option args [Object] :value The tag's content.
+    # @!attribute tag
+    #   The tag number.
+    #   @return [Integer]
+    # @!attribute value
+    #   The tag's content.
+    #   @return [Object]
+    Tagged = Struct.new(:tag, :value)
+
+    class Error < StandardError; end
+
+    class OutOfBytesError < Error
+      def initialize(n, left)
+        super("Out of bytes. Trying to read #{n} bytes but buffer contains only #{left}")
+      end
+    end
+
+    class UnknownTypeError < Error
+      def initialize(type)
+        super("Unable to encode #{type}")
+      end
+    end
+
+    class ExtraBytesError < Error
+      def initialize(pos, size)
+        super("Extra bytes follow after decoding item. Read #{pos} / #{size} bytes")
+      end
+    end
+
+    class UnexpectedBreakCodeError < Error; end
+
+    class UnexpectedAdditionalInformationError < Error
+      def initialize(add_info)
+        super("Unexpected additional information: #{add_info}")
+      end
+    end
+
+    class << self
+      # @param [Symbol,Class] engine
+      #   Must be one of the following values:
+      #
+      #   * :cbor
+      #
+      def engine=(engine)
+        @engine = Class === engine ? engine : load_engine(engine)
+      end
+
+      # @return [Class] Returns the default engine.
+      #   One of:
+      #
+      #   * {CborEngine}
+      #
+      def engine
+        set_default_engine unless @engine
+        @engine
+      end
+
+      def encode(data)
+        @engine.encode(data)
+      end
+
+      def decode(bytes)
+        bytes.force_encoding(Encoding::BINARY)
+        @engine.decode(bytes)
+      end
+
+      def set_default_engine
+        [:cbor].each do |name|
+          @engine ||= try_load_engine(name)
+        end
+
+        unless @engine
+          raise 'Unable to find a compatible cbor library.'
+        end
+      end
+
+      private
+
+      def load_engine(name)
+        require "aws-sdk-core/cbor/#{name}_engine"
+        const_name = name[0].upcase + name[1..-1] + 'Engine'
+        const_get(const_name)
+      end
+
+      def try_load_engine(name)
+        load_engine(name)
+      rescue LoadError
+        false
+      end
+    end
+
+    set_default_engine
+  end
+end

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

@@ -308,10 +308,11 @@ module Aws
     def protocol_helper
       case config.api.metadata['protocol']
       when 'json'        then Stubbing::Protocols::Json
-      when 'query'       then Stubbing::Protocols::Query
-      when 'ec2'         then Stubbing::Protocols::EC2
       when 'rest-json'   then Stubbing::Protocols::RestJson
       when 'rest-xml'    then Stubbing::Protocols::RestXml
+      when 'query'       then Stubbing::Protocols::Query
+      when 'ec2'         then Stubbing::Protocols::EC2
+      when 'smithy-rpc-v2-cbor' then Stubbing::Protocols::RpcV2
       when 'api-gateway' then Stubbing::Protocols::ApiGateway
       else raise "unsupported protocol"
       end.new

data/lib/aws-sdk-core/endpoints/matchers.rb

@@ -28,7 +28,11 @@ module Aws
 
         val = if (index = parts.first[BRACKET_REGEX, 1])
                 # remove brackets and index from part before indexing
-                value[parts.first.gsub(BRACKET_REGEX, '')][index.to_i]
+                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

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Aws
+  class ErrorHandler < Seahorse::Client::Handler
+
+    private
+
+    def error(context)
+      body = context.http_response.body_contents
+      if body.empty?
+        code, message, data = http_status_error(context)
+      else
+        code, message, data = extract_error(body, context)
+      end
+      build_error(context, code, message, data)
+    end
+
+    def build_error(context, code, message, data)
+      errors_module = context.client.class.errors_module
+      errors_module.error_class(code).new(context, message, data)
+    end
+
+    def http_status_error(context)
+      [http_status_error_code(context), '', EmptyStructure.new]
+    end
+
+    def http_status_error_code(context)
+      status_code = context.http_response.status_code
+      {
+        302 => 'MovedTemporarily',
+        304 => 'NotModified',
+        400 => 'BadRequest',
+        403 => 'Forbidden',
+        404 => 'NotFound',
+        412 => 'PreconditionFailed',
+        413 => 'RequestEntityTooLarge',
+      }[status_code] || "Http#{status_code}Error"
+    end
+
+  end
+end

data/lib/aws-sdk-core/json/error_handler.rb

@@ -2,10 +2,8 @@
 
 module Aws
   module Json
-    class ErrorHandler < Xml::ErrorHandler
+    class ErrorHandler < Aws::ErrorHandler
 
-      # @param [Seahorse::Client::RequestContext] context
-      # @return [Seahorse::Client::Response]
       def call(context)
         @handler.call(context).on(300..599) do |response|
           response.error = error(context)
@@ -19,7 +17,7 @@ module Aws
         json = Json.load(body)
         code = error_code(json, context)
         message = error_message(code, json)
-        data = parse_error_data(context, code)
+        data = parse_error_data(context, body, code)
         [code, message, data]
       rescue Json::ParseError
         [http_status_error_code(context), '', EmptyStructure.new]
@@ -48,7 +46,7 @@ module Aws
       end
 
       def remove_prefix(error_code, context)
-        if prefix = context.config.api.metadata['errorPrefix']
+        if (prefix = context.config.api.metadata['errorPrefix'])
           error_code.sub(/^#{prefix}/, '')
         else
           error_code
@@ -63,9 +61,9 @@ module Aws
         end
       end
 
-      def parse_error_data(context, code)
+      def parse_error_data(context, body, code)
         data = EmptyStructure.new
-        if error_rules = context.operation.errors
+        if (error_rules = context.operation.errors)
           error_rules.each do |rule|
             # match modeled shape name with the type(code) only
             # some type(code) might contains invalid characters
@@ -73,7 +71,7 @@ module Aws
             match = rule.shape.name == code.gsub(/[^^a-zA-Z0-9]/, '')
             next unless match && rule.shape.members.any?
 
-            data = Parser.new(rule).parse(context.http_response.body_contents)
+            data = Parser.new(rule).parse(body)
             # errors support HTTP bindings
             apply_error_headers(rule, context, data)
           end

data/lib/aws-sdk-core/json/handler.rb

@@ -12,8 +12,7 @@ module Aws
         build_request(context)
         response = @handler.call(context)
         response.on(200..299) { |resp| parse_response(resp) }
-        response.on(200..599) { |resp| apply_request_id(context) }
-        response
+        response.on(200..599) { |_resp| apply_request_id(context) }
       end
 
       private
@@ -38,10 +37,10 @@ module Aws
       end
 
       def parse_body(context)
+        json = context.http_response.body_contents
         if simple_json?(context)
-          Json.load(context.http_response.body_contents)
-        elsif rules = context.operation.output
-          json = context.http_response.body_contents
+          Json.load(json)
+        elsif (rules = context.operation.output)
           if json.is_a?(Array)
             # an array of emitted events
             if json[0].respond_to?(:response)
@@ -62,7 +61,7 @@ module Aws
             Parser.new(
               rules,
               query_compatible: query_compatible?(context)
-            ).parse(json == '' ? '{}' : json)
+            ).parse(json)
           end
         else
           EmptyStructure.new

data/lib/aws-sdk-core/json/json_engine.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Aws
   module Json
-    module JSONEngine
+    module JsonEngine
       class << self
         def load(json)
           JSON.parse(json)

data/lib/aws-sdk-core/json/oj_engine.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
+require 'oj'
+
 module Aws
   module Json
     module OjEngine
       # @api private
-      LOAD_OPTIONS = { mode: :compat, symbol_keys: false, empty_string: false }.freeze
+      LOAD_OPTIONS = {
+        mode: :compat,
+        symbol_keys: false,
+        empty_string: false
+      }.freeze
 
       # @api private
       DUMP_OPTIONS = { mode: :compat }.freeze

data/lib/aws-sdk-core/json/parser.rb

@@ -17,6 +17,8 @@ module Aws
 
       # @param [String<JSON>] json
       def parse(json, target = nil)
+        json = '{}' if json.empty?
+
         parse_ref(@rules, Json.load(json), target)
       end
 

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

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'json'
 require_relative 'json/builder'
 require_relative 'json/error_handler'
 require_relative 'json/handler'
 require_relative 'json/parser'
-require_relative 'json/json_engine'
-require_relative 'json/oj_engine'
 
 module Aws
   # @api private
@@ -21,29 +18,61 @@ module Aws
     end
 
     class << self
-      def load(json)
-        ENGINE.load(json)
+      # @param [Symbol,Class] engine
+      #   Must be one of the following values:
+      #
+      #   * :oj
+      #   * :json
+      #
+      def engine=(engine)
+        @engine = Class === engine ? engine : load_engine(engine)
+      end
+
+      # @return [Class] Returns the default engine.
+      #   One of:
+      #
+      #   * {OjEngine}
+      #   * {JsonEngine}
+      #
+      def engine
+        set_default_engine unless @engine
+        @engine
       end
 
-      def load_file(path)
-        load(File.open(path, 'r', encoding: 'UTF-8', &:read))
+      def load(json)
+        @engine.load(json)
       end
 
       def dump(value)
-        ENGINE.dump(value)
+        @engine.dump(value)
+      end
+
+      def set_default_engine
+        [:oj, :json].each do |name|
+          @engine ||= try_load_engine(name)
+        end
+        unless @engine
+          raise 'Unable to find a compatible json library. ' \
+          'Ensure that you have installed or added to your Gemfile one of ' \
+          'oj or json'
+        end
       end
 
       private
 
-      def select_engine
-        require 'oj'
-        OjEngine
+      def load_engine(name)
+        require "aws-sdk-core/json/#{name}_engine"
+        const_name = name[0].upcase + name[1..-1] + 'Engine'
+        const_get(const_name)
+      end
+
+      def try_load_engine(name)
+        load_engine(name)
       rescue LoadError
-        JSONEngine
+        false
       end
     end
 
-    # @api private
-    ENGINE = select_engine
+    set_default_engine
   end
 end

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

@@ -201,7 +201,7 @@ module Aws
       def next_response(params)
         params = next_page_params(params)
         request = context.client.build_request(context.operation_name, params)
-        Aws::Plugins::UserAgent.feature('paginator') do
+        Aws::Plugins::UserAgent.metric('PAGINATOR') do
           request.send_request
         end
       end

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

@@ -11,6 +11,8 @@ module Aws
           # AttemptHandler comes just before we would retry an error.
           # Or before we would follow redirects.
           handlers.add(AttemptHandler, step: :sign, priority: 39)
+          # ErrorHandler comes after we have parsed an error.
+          handlers.add(ErrorHandler, step: :sign, priority: 95)
           # LatencyHandler is as close to sending as possible.
           handlers.add(LatencyHandler, step: :sign, priority: 0)
         end
@@ -62,17 +64,27 @@ module Aws
             call_attempt.x_amzn_request_id = headers["x-amzn-request-id"]
           end
           call_attempt.http_status_code = context.http_response.status_code
-          if e = resp.error
+          context.metadata[:current_call_attempt] = call_attempt
+          request_metrics.add_call_attempt(call_attempt)
+          resp
+        end
+      end
+
+      class ErrorHandler < Seahorse::Client::Handler
+        def call(context)
+          resp = @handler.call(context)
+          call_attempt = context.metadata[:current_call_attempt]
+          if (e = resp.error)
             e_name = _extract_error_name(e)
             e_msg = e.message
             call_attempt.aws_exception = "#{e_name}"
             call_attempt.aws_exception_msg = "#{e_msg}"
           end
-          request_metrics.add_call_attempt(call_attempt)
           resp
         end
 
         private
+
         def _extract_error_name(error)
           if error.is_a?(Aws::Errors::ServiceError)
             error.class.code

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

@@ -43,7 +43,7 @@ module Aws
     # @api private
     class GlobalConfiguration < Seahorse::Client::Plugin
 
-      @identifiers = Set.new()
+      @identifiers = Set.new
 
       # @api private
       def before_initialize(client_class, options)
@@ -55,17 +55,18 @@ module Aws
       private
 
       def apply_service_defaults(client_class, options)
-        if defaults = Aws.config[client_class.identifier]
-          defaults.each do |option_name, default|
-            options[option_name] = default unless options.key?(option_name)
-          end
+        return unless (defaults = Aws.config[client_class.identifier])
+
+        defaults.each do |option_name, default|
+          options[option_name] = default unless options.key?(option_name)
         end
       end
 
-      def apply_aws_defaults(client_class, options)
+      def apply_aws_defaults(_client_class, options)
         Aws.config.each do |option_name, default|
           next if self.class.identifiers.include?(option_name)
           next if options.key?(option_name)
+
           options[option_name] = default
         end
       end
@@ -80,9 +81,7 @@ module Aws
 
         # @return [Set<String>]
         # @api private
-        def identifiers
-          @identifiers
-        end
+        attr_reader :identifiers
 
       end
     end

data/lib/aws-sdk-core/plugins/protocols/api_gateway.rb

@@ -5,6 +5,8 @@ module Aws
     module Protocols
       class ApiGateway < Seahorse::Client::Plugin
 
+        option(:protocol, 'api-gateway')
+
         class ContentTypeHandler < Seahorse::Client::Handler
           def call(context)
             body = context.http_request.body
@@ -22,8 +24,8 @@ module Aws
         handler(Rest::Handler)
         handler(ContentTypeHandler, priority: 30)
         handler(Json::ErrorHandler, step: :sign)
-      end
 
+      end
     end
   end
 end

data/lib/aws-sdk-core/plugins/protocols/ec2.rb

@@ -1,35 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../query'
-
 module Aws
   module Plugins
     module Protocols
       class EC2 < Seahorse::Client::Plugin
 
-        class Handler < Aws::Query::Handler
-
-          def apply_params(param_list, params, rules)
-            Aws::Query::EC2ParamBuilder.new(param_list).apply(rules, params)
-          end
-
-          def parse_xml(context)
-            if rules = context.operation.output
-              parser = Xml::Parser.new(rules)
-              data = parser.parse(xml(context)) do |path, value|
-                if path.size == 2 && path.last == 'requestId'
-                  context.metadata[:request_id] = value
-                end
-              end
-              data
-            else
-              EmptyStructure.new
-            end
-          end
-
-        end
+        option(:protocol, 'ec2')
 
-        handler(Handler)
+        handler(Aws::Query::EC2Handler)
         handler(Xml::ErrorHandler, step: :sign)
 
       end

data/lib/aws-sdk-core/plugins/protocols/json_rpc.rb

@@ -5,18 +5,17 @@ module Aws
     module Protocols
       class JsonRpc < Seahorse::Client::Plugin
 
+        option(:protocol, 'json')
+
         option(:simple_json,
           default: false,
           doc_type: 'Boolean',
           docstring: <<-DOCS)
 Disables request parameter conversion, validation, and formatting.
-Also disable response data type conversions. This option is useful
-when you want to ensure the highest level of performance by
-avoiding overhead of walking request parameters and response data
-structures.
-
-When `:simple_json` is enabled, the request parameters hash must
-be formatted exactly as the DynamoDB API expects.
+Also disables response data type conversions. The request parameters
+hash must be formatted exactly as the API expects.This option is useful
+when you want to ensure the highest level of performance by avoiding
+overhead of walking request parameters and response data structures.
           DOCS
 
         option(:validate_params) { |config| !config.simple_json }
@@ -24,7 +23,6 @@ be formatted exactly as the DynamoDB API expects.
         option(:convert_params) { |config| !config.simple_json }
 
         handler(Json::Handler)
-
         handler(Json::ErrorHandler, step: :sign)
 
       end

data/lib/aws-sdk-core/plugins/protocols/query.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../../query'
-
 module Aws
   module Plugins
     module Protocols
       class Query < Seahorse::Client::Plugin
+
+        option(:protocol, 'query')
+
         handler(Aws::Query::Handler)
         handler(Xml::ErrorHandler, step: :sign)
+
       end
     end
   end

data/lib/aws-sdk-core/plugins/protocols/rest_json.rb

@@ -4,13 +4,14 @@ module Aws
   module Plugins
     module Protocols
       class RestJson < Seahorse::Client::Plugin
+
+        option(:protocol, 'rest-json')
+
         handler(Rest::Handler)
-        # Rest::Handler will set a default JSON body, so size can be checked
-        # if this handler is run after serialization.
         handler(Rest::ContentTypeHandler, priority: 30)
         handler(Json::ErrorHandler, step: :sign)
-      end
 
+      end
     end
   end
 end

data/lib/aws-sdk-core/plugins/protocols/rest_xml.rb

@@ -4,9 +4,13 @@ module Aws
   module Plugins
     module Protocols
       class RestXml < Seahorse::Client::Plugin
+
+        option(:protocol, 'rest-xml')
+
         handler(Rest::Handler)
-        handler(Rest::ContentTypeHandler)
+        handler(Rest::ContentTypeHandler, priority: 30)
         handler(Xml::ErrorHandler, step: :sign)
+
       end
     end
   end

data/lib/aws-sdk-core/plugins/protocols/rpc_v2.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    module Protocols
+      class RpcV2 < Seahorse::Client::Plugin
+
+        option(:protocol, 'smithy-rpc-v2-cbor')
+
+        handler(Aws::RpcV2::Handler)
+        handler(Aws::RpcV2::ContentTypeHandler, priority: 30)
+        handler(Aws::RpcV2::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

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

@@ -91,11 +91,20 @@ and 10485780 bytes inclusive.
               end
             end
           end
-          @handler.call(context)
+          with_metric(selected_encoding) { @handler.call(context) }
         end
 
         private
 
+        def with_metric(encoding, &block)
+          case encoding
+          when 'gzip'
+            Aws::Plugins::UserAgent.metric('GZIP_REQUEST_COMPRESSION', &block)
+          else
+            block.call
+          end
+        end
+
         def request_encoding_selection(context)
           encoding_list = context.operation.request_compression['encodings']
           encoding_list.find { |encoding| RequestCompression::SUPPORTED_ENCODINGS.include?(encoding) }