aws-sdk-core 3.197.1 → 3.199.0

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

@@ -7,10 +7,9 @@ module Aws
 
       def call(context)
         Rest::Request::Builder.new.apply(context)
-        resp = @handler.call(context)
-        resp.on(200..299) { |response| Response::Parser.new.apply(response) }
-        resp.on(200..599) { |response| apply_request_id(context) }
-        resp
+        response = @handler.call(context)
+        response.on(200..299) { |resp| Response::Parser.new.apply(resp) }
+        response.on(200..599) { |_resp| apply_request_id(context) }
       end
 
       private

data/lib/aws-sdk-core/rest/request/endpoint.rb

@@ -30,7 +30,9 @@ module Aws
         private
 
         def apply_path_params(uri, params)
-          path = uri.path.sub(%r{/$}, '') + @path_pattern.split('?')[0]
+          path = uri.path.sub(%r{/$}, '')
+          # handle trailing slash
+          path += @path_pattern.split('?')[0] if path.empty? || @path_pattern != '/'
           uri.path = path.gsub(/{.+?}/) do |placeholder|
             param_value_for_placeholder(placeholder, params)
           end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require_relative 'rest/handler'
+require_relative 'rest/content_type_handler'
 require_relative 'rest/request/body'
 require_relative 'rest/request/builder'
 require_relative 'rest/request/endpoint'
 require_relative 'rest/request/headers'
 require_relative 'rest/request/querystring_builder'
-require_relative 'rest/request/content_type'
 require_relative 'rest/response/body'
 require_relative 'rest/response/headers'
 require_relative 'rest/response/parser'

data/lib/aws-sdk-core/rpc_v2/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Aws
+  module RpcV2
+    class Builder
+      include Seahorse::Model::Shapes
+
+      def initialize(rules, _options = {})
+        @rules = rules
+      end
+
+      def serialize(params)
+        # If the input shape is empty, do not set a body. This is
+        # different than if the input shape is a structure with no members.
+        return nil if @rules.shape.struct_class == EmptyStructure
+
+        Cbor.encode(format(@rules, params))
+      end
+
+      private
+
+      def structure(ref, values)
+        shape = ref.shape
+        values.each_pair.with_object({}) do |(key, value), data|
+          if shape.member?(key) && !value.nil?
+            member_ref = shape.member(key)
+            member_name = member_ref.location_name || key
+            data[member_name] = format(member_ref, value)
+          end
+        end
+      end
+
+      def list(ref, values)
+        member_ref = ref.shape.member
+        values.collect { |value| format(member_ref, value) }
+      end
+
+      def map(ref, values)
+        value_ref = ref.shape.value
+        values.each.with_object({}) do |(key, value), data|
+          data[key] = format(value_ref, value)
+        end
+      end
+
+      def blob(value)
+        (String === value ? value : value.read).force_encoding(Encoding::BINARY)
+      end
+
+      def format(ref, value)
+        case ref.shape
+        when StructureShape then structure(ref, value)
+        when ListShape      then list(ref, value)
+        when MapShape       then map(ref, value)
+        when BlobShape      then blob(value)
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/content_type_handler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class ContentTypeHandler < Seahorse::Client::Handler
+      def call(context)
+        content_type =
+          if eventstream_input?(context)
+            'application/vnd.amazon.eventstream'
+          elsif !empty_input_structure?(context)
+            'application/cbor'
+          end
+        accept =
+          if eventstream_output?(context)
+            'application/vnd.amazon.eventstream'
+          end
+
+        headers = context.http_request.headers
+        headers['Content-Type'] ||= content_type if content_type
+        headers['Accept'] ||= accept if accept
+        @handler.call(context)
+      end
+
+      private
+
+      def eventstream_input?(context)
+        context.operation.input.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      def eventstream_output?(context)
+        context.operation.output.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      def empty_input_structure?(context)
+        context.operation.input.shape.struct_class == EmptyStructure
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class ErrorHandler < Aws::ErrorHandler
+
+      def call(context)
+        # Malformed responses should throw an http based error, so we check
+        # 200 range for error handling only for this case.
+        @handler.call(context).on(200..599) do |response|
+          if !valid_response?(context)
+            code, message, data = http_status_error(context)
+            response.error = build_error(context, code, message, data)
+          elsif (300..599).cover?(context.http_response.status_code)
+            response.error = error(context)
+          end
+          response.data = nil
+        end
+      end
+
+      private
+
+      def valid_response?(context)
+        req_header = context.http_request.headers['smithy-protocol']
+        resp_header = context.http_response.headers['smithy-protocol']
+        req_header == resp_header
+      end
+
+      def extract_error(body, context)
+        data = Cbor.decode(body)
+        code = error_code(data, context)
+        message = data['message']
+        data = parse_error_data(context, body, code)
+        [code, message, data]
+      rescue Cbor::Error
+        [http_status_error_code(context), '', EmptyStructure.new]
+      end
+
+      def error_code(data, context)
+        code =
+          if aws_query_error?(context)
+            error = context.http_response.headers['x-amzn-query-error'].split(';')[0]
+            remove_prefix(error, context)
+          else
+            data['__type']
+          end
+        if code
+          code.split('#').last
+        else
+          http_status_error_code(context)
+        end
+      end
+
+      def parse_error_data(context, body, code)
+        data = EmptyStructure.new
+        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
+            # such as ':' (efs) etc
+            match = rule.shape.name == code.gsub(/[^^a-zA-Z0-9]/, '')
+            next unless match && rule.shape.members.any?
+
+            data = Parser.new(rule).parse(body)
+          end
+        end
+        data
+      end
+
+      def aws_query_error?(context)
+        context.config.api.metadata['awsQueryCompatible'] &&
+          context.http_response.headers['x-amzn-query-error']
+      end
+
+      def remove_prefix(error_code, context)
+        if (prefix = context.config.api.metadata['errorPrefix'])
+          error_code.sub(/^#{prefix}/, '')
+        else
+          error_code
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class Handler < Seahorse::Client::Handler
+      # @param [Seahorse::Client::RequestContext] context
+      # @return [Seahorse::Client::Response]
+      def call(context)
+        build_request(context)
+        response = @handler.call(context)
+        response.on(200..299) { |resp| resp.data = parse_body(context) }
+        response.on(200..599) { |_resp| apply_request_id(context) }
+        response
+      end
+
+      private
+
+      def build_request(context)
+        context.http_request.headers['smithy-protocol'] = 'rpc-v2-cbor'
+        context.http_request.http_method = 'POST'
+        context.http_request.body = build_body(context)
+        build_url(context)
+      end
+
+      def build_url(context)
+        base = context.http_request.endpoint
+        service_name = context.config.api.metadata['targetPrefix']
+        base.path += "/service/#{service_name}/operation/#{context.operation.name}"
+      end
+
+      def build_body(context)
+        Builder.new(context.operation.input).serialize(context.params)
+      end
+
+      def parse_body(context)
+        cbor = context.http_response.body_contents
+        if (rules = context.operation.output)
+          if cbor.is_a?(Array)
+            # an array of emitted events
+            if cbor[0].respond_to?(:response)
+              # initial response exists
+              # it must be the first event arrived
+              resp_struct = cbor.shift.response
+            else
+              resp_struct = context.operation.output.shape.struct_class.new
+            end
+
+            rules.shape.members.each do |name, ref|
+              if ref.eventstream
+                resp_struct.send("#{name}=", cbor.to_enum)
+              end
+            end
+            resp_struct
+          else
+            Parser.new(
+              rules,
+              query_compatible: query_compatible?(context)
+            ).parse(cbor)
+          end
+        else
+          EmptyStructure.new
+        end
+      end
+
+      def apply_request_id(context)
+        context[:request_id] = context.http_response.headers['x-amzn-requestid']
+      end
+
+      def query_compatible?(context)
+        context.config.api.metadata.key?('awsQueryCompatible')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Aws
+  module RpcV2
+    class Parser
+      include Seahorse::Model::Shapes
+
+      # @param [Seahorse::Model::ShapeRef] rules
+      def initialize(rules, query_compatible: false)
+        @rules = rules
+        @query_compatible = query_compatible
+      end
+
+      def parse(cbor, target = nil)
+        return {} if cbor.empty?
+
+        parse_ref(@rules, Cbor.decode(cbor), target)
+      end
+
+      private
+
+      def structure(ref, values, target = nil)
+        shape = ref.shape
+        target = ref.shape.struct_class.new if target.nil?
+        values.each do |key, value|
+          member_name, member_ref = shape.member_by_location_name(key)
+          if member_ref
+            target[member_name] = parse_ref(member_ref, value)
+          elsif shape.union && key != '__type'
+            target[:unknown] = { 'name' => key, 'value' => value }
+          end
+        end
+        # In services that were previously Query/XML, members that were
+        # "flattened" defaulted to empty lists. In JSON, these values are nil,
+        # which is backwards incompatible. To preserve backwards compatibility,
+        # we set a default value of [] for these members.
+        if @query_compatible
+          ref.shape.members.each do |member_name, member_target|
+            next unless target[member_name].nil?
+
+            if flattened_list?(member_target.shape)
+              target[member_name] = []
+            elsif flattened_map?(member_target.shape)
+              target[member_name] = {}
+            end
+          end
+        end
+
+        if shape.union
+          # convert to subclass
+          member_subclass = shape.member_subclass(target.member).new
+          member_subclass[target.member] = target.value
+          target = member_subclass
+        end
+        target
+      end
+
+      def list(ref, values, target = nil)
+        target = [] if target.nil?
+        values.each do |value|
+          target << parse_ref(ref.shape.member, value)
+        end
+        target
+      end
+
+      def map(ref, values, target = nil)
+        target = {} if target.nil?
+        values.each do |key, value|
+          target[key] = parse_ref(ref.shape.value, value) unless value.nil?
+        end
+        target
+      end
+
+      def parse_ref(ref, value, target = nil)
+        if value.nil?
+          nil
+        else
+          case ref.shape
+          when StructureShape then structure(ref, value, target)
+          when ListShape then list(ref, value, target)
+          when MapShape then map(ref, value, target)
+          else value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require_relative 'cbor'
+require_relative 'rpc_v2/handler'
+require_relative 'rpc_v2/content_type_handler'
+require_relative 'rpc_v2/error_handler'
+require_relative 'rpc_v2/builder'
+require_relative 'rpc_v2/parser'

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Aws
+  module Stubbing
+    module Protocols
+      class RpcV2
+
+        def stub_data(api, operation, data)
+          resp = Seahorse::Client::Http::Response.new
+          resp.status_code = 200
+          resp.headers['Content-Type'] = content_type(api)
+          resp.headers['x-amzn-RequestId'] = 'stubbed-request-id'
+          resp.body = build_body(operation, data)
+          resp
+        end
+
+        def stub_error(error_code)
+          http_resp = Seahorse::Client::Http::Response.new
+          http_resp.status_code = 400
+          http_resp.body = <<-JSON.strip
+{
+  "code": #{error_code.inspect},
+  "message": "stubbed-response-error-message"
+}
+          JSON
+          http_resp
+        end
+
+        private
+
+        def content_type(api)
+          'application/cbor'
+        end
+
+        def build_body(operation, data)
+          Aws::RpcV2::Builder.new(operation.output).serialize(data)
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ require 'cgi'
 
 module Aws
   module Xml
-    class ErrorHandler < Seahorse::Client::Handler
+    class ErrorHandler < Aws::ErrorHandler
 
       def call(context)
         @handler.call(context).on(300..599) do |response|
@@ -15,32 +15,19 @@ module Aws
 
       private
 
-      def error(context)
-        body = context.http_response.body_contents
-        if body.empty?
-          code = http_status_error_code(context)
-          message = ''
-          data = EmptyStructure.new
-        else
-          code, message, data = extract_error(body, context)
-        end
-        context[:request_id] = request_id(body)
-        errors_module = context.client.class.errors_module
-        errors_module.error_class(code).new(context, message, data)
-      end
-
       def extract_error(body, context)
+        context[:request_id] = request_id(body)
         code = error_code(body, context)
         [
           code,
           error_message(body),
-          error_data(context, code)
+          error_data(context, body, code)
         ]
       end
 
-      def error_data(context, code)
+      def 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|
             # query protocol may have custom error code
             # reference: https://smithy.io/2.0/aws/protocols/aws-query-protocol.html#error-code-resolution
@@ -48,7 +35,7 @@ module Aws
             match = (code == error_shape_code || code == rule.shape.name)
             next unless match && rule.shape.members.any?
 
-            data = parse_error_data(rule, context.http_response.body_contents)
+            data = parse_error_data(rule, body)
             # supporting HTTP bindings
             apply_error_headers(rule, context, data)
           end
@@ -62,7 +49,7 @@ module Aws
         # errors may nested under <Errors><Error>structure_data</Error></Errors>
         # Or may be flat and under <Error>structure_data</Error>
         body = body.tr("\n", '')
-        if matches = body.match(/<Error>(.+?)<\/Error>/)
+        if (matches = body.match(/<Error>(.+?)<\/Error>/))
           Parser.new(rule).parse("<#{rule.shape.name}>#{matches[1]}</#{rule.shape.name}>")
         else
           EmptyStructure.new
@@ -75,28 +62,15 @@ module Aws
       end
 
       def error_code(body, context)
-        if matches = body.match(/<Code>(.+?)<\/Code>/)
+        if (matches = body.match(/<Code>(.+?)<\/Code>/))
           remove_prefix(unescape(matches[1]), context)
         else
           http_status_error_code(context)
         end
       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
-
       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
@@ -104,7 +78,7 @@ module Aws
       end
 
       def error_message(body)
-        if matches = body.match(/<Message>(.+?)<\/Message>/m)
+        if (matches = body.match(/<Message>(.+?)<\/Message>/m))
           unescape(matches[1])
         else
           ''
@@ -112,7 +86,7 @@ module Aws
       end
 
       def request_id(body)
-        if matches = body.match(/<RequestId>(.+?)<\/RequestId>/m)
+        if (matches = body.match(/<RequestId>(.+?)<\/RequestId>/m))
           matches[1]
         end
       end

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

@@ -5,7 +5,6 @@ module Aws
   module Xml
     # A SAX-style XML parser that uses a shape context to handle types.
     class Parser
-
       # @param [Seahorse::Model::ShapeRef] rules
       def initialize(rules, options = {})
         @rules = rules
@@ -47,8 +46,7 @@ module Aws
         #   * :libxml
         #   * :nokogiri
         #   * :rexml
-        #
-        def engine= engine
+        def engine=(engine)
           @engine = Class === engine ? engine : load_engine(engine)
         end
 
@@ -60,7 +58,6 @@ module Aws
         #   * {LibxmlEngine}
         #   * {NokogiriEngine}
         #   * {RexmlEngine}
-        #
         def engine
           set_default_engine unless @engine
           @engine
@@ -80,7 +77,7 @@ module Aws
         private
 
         def load_engine(name)
-          require "aws-sdk-core/xml/parser/engines/#{name}"
+          require "aws-sdk-core/xml/parser/#{name}_engine"
           const_name = name[0].upcase + name[1..-1] + 'Engine'
           const_get(const_name)
         end
@@ -94,7 +91,6 @@ module Aws
       end
 
       set_default_engine
-
     end
   end
 end

data/lib/aws-sdk-core.rb

@@ -63,19 +63,23 @@ require_relative 'aws-sdk-core/stubbing/xml_error'
 
 # stubbing protocols
 
-require_relative 'aws-sdk-core/stubbing/protocols/ec2'
 require_relative 'aws-sdk-core/stubbing/protocols/json'
-require_relative 'aws-sdk-core/stubbing/protocols/query'
 require_relative 'aws-sdk-core/stubbing/protocols/rest'
 require_relative 'aws-sdk-core/stubbing/protocols/rest_json'
 require_relative 'aws-sdk-core/stubbing/protocols/rest_xml'
+require_relative 'aws-sdk-core/stubbing/protocols/query'
+require_relative 'aws-sdk-core/stubbing/protocols/ec2'
+require_relative 'aws-sdk-core/stubbing/protocols/rpc_v2'
 require_relative 'aws-sdk-core/stubbing/protocols/api_gateway'
 
 # protocols
 
+require_relative 'aws-sdk-core/error_handler'
 require_relative 'aws-sdk-core/rest'
 require_relative 'aws-sdk-core/xml'
 require_relative 'aws-sdk-core/json'
+require_relative 'aws-sdk-core/query'
+require_relative 'aws-sdk-core/rpc_v2'
 
 # event stream
 

data/lib/aws-sdk-sso/client.rb

@@ -89,6 +89,11 @@ module Aws::SSO
 
     # @overload initialize(options)
     #   @param [Hash] options
+    #
+    #   @option options [Array<Seahorse::Client::Plugin>] :plugins ([]])
+    #     A list of plugins to apply to the client. Each plugin is either a
+    #     class name or an instance of a plugin class.
+    #
     #   @option options [required, Aws::CredentialProvider] :credentials
     #     Your AWS credentials. This can be an instance of any one of the
     #     following classes:
@@ -209,7 +214,6 @@ module Aws::SSO
     #         'https://example.com'
     #         'http://example.com:123'
     #
-    #
     #   @option options [Integer] :endpoint_cache_max_entries (1000)
     #     Used for the maximum size limit of the LRU cache storing endpoints data
     #     for endpoint discovery enabled operations. Defaults to 1000.
@@ -298,7 +302,6 @@ module Aws::SSO
     #       throttling.  This is a provisional mode that may change behavior
     #       in the future.
     #
-    #
     #   @option options [String] :sdk_ua_app_id
     #     A unique and opaque application ID that is appended to the
     #     User-Agent header as app/sdk_ua_app_id. It should have a
@@ -630,7 +633,7 @@ module Aws::SSO
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-core'
-      context[:gem_version] = '3.197.1'
+      context[:gem_version] = '3.199.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/aws-sdk-sso.rb

@@ -54,6 +54,6 @@ require_relative 'aws-sdk-sso/customizations'
 # @!group service
 module Aws::SSO
 
-  GEM_VERSION = '3.197.1'
+  GEM_VERSION = '3.199.0'
 
 end