aws-sdk-core 2.0.48 → 2.1.0

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

@@ -6,7 +6,7 @@ module Aws
 
         def call(context)
           @handler.call(context).on(200) do |response|
-            response.data = Structure.new([:location_constraint])
+            response.data = S3::Types::GetBucketLocationOutput.new
             xml = context.http_response.body_contents
             matches = xml.match(/>(.+?)<\/LocationConstraint>/)
             response.data[:location_constraint] = matches ? matches[1] : ''

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

@@ -91,7 +91,7 @@ module Aws
         end
 
         def uploading_file?(context)
-          %w(put_object upload_part).include?(context.operation_name) &&
+          [:put_object, :upload_part].include?(context.operation_name) &&
             context.http_request.body.size > 0
         end
 
@@ -199,7 +199,6 @@ module Aws
         end
 
         def updgrade_to_v4(context, region)
-          bucket = context.params[:bucket]
           context.http_response.body.truncate(0)
           context.http_request.headers.delete('authorization')
           context.http_request.headers.delete('x-amz-security-token')

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

@@ -29,7 +29,6 @@ module Aws
       end
 
       def after_initialize(client)
-        # disable retries when stubbing responses
         if client.config.stub_responses
           client.handlers.remove(RetryErrors::Handler)
         end
@@ -38,41 +37,40 @@ module Aws
       class Handler < Seahorse::Client::Handler
 
         def call(context)
-          response = Seahorse::Client::Response.new(context: context)
-          apply_stub(response, context.client.next_stub(context.operation_name))
-          response
+          stub = context.client.next_stub(context.operation_name)
+          resp = Seahorse::Client::Response.new(context: context)
+          apply_stub(stub, resp)
+          resp
         end
 
-        private
-
-        def apply_stub(resp, stub)
-          if Exception === stub
-            resp.error = stub
-          elsif Class === stub && stub.ancestors.include?(Errors::ServiceError)
-            resp.error = stub.new(resp.context, 'stubbed error')
-          elsif Class === stub && stub.ancestors.include?(Exception)
-            resp.error = stub.new
-          else
-            resp.data = stub
-            stub_http_body(resp) if streaming?(resp)
+        def apply_stub(stub, response)
+          http_resp = response.context.http_response
+          case
+          when stub[:error] then signal_error(stub[:error], http_resp)
+          when stub[:http] then signal_http(stub[:http], http_resp)
+          when stub[:data] then response.data = stub[:data]
           end
         end
 
-        def streaming?(resp)
-          if output = resp.context.operation.output
-            payload = output.payload_member
-            payload && payload.definition['streaming'] == true
+        # @param [Exception] stub
+        # @param [Seahorse::Client::Http::Response] http_resp
+        def signal_error(error, http_resp)
+          if Exception === error
+            http_resp.signal_error(error)
           else
-            false
+            http_resp.signal_error(error.new)
           end
         end
 
-        def stub_http_body(resp)
-          payload = resp.context.operation.output.payload
-          resp.context.http_response.signal_headers(200, {})
-          resp.context.http_response.signal_data(resp.data[payload])
-          resp.context.http_response.signal_done
-          resp.data[payload] = resp.context.http_response.body
+        # @param [Seahorse::Client::Http::Response] stub
+        # @param [Seahorse::Client::Http::Response] http_resp
+        def signal_http(stub, http_resp)
+          http_resp.signal_headers(stub.status_code, stub.headers.to_h)
+          while chunk = stub.body.read(1024 * 1024)
+            http_resp.signal_data(chunk)
+          end
+          stub.body.rewind
+          http_resp.signal_done
         end
 
       end

data/lib/aws-sdk-core/query/ec2_param_builder.rb

@@ -4,69 +4,55 @@ module Aws
   module Query
     class EC2ParamBuilder
 
-      # @param [ParamList] param_list
+      include Seahorse::Model::Shapes
+
       def initialize(param_list)
         @params = param_list
       end
 
-      # @return [ParamList]
       attr_reader :params
 
-      # Serializes the `params` hash onto {#param_list} following the rules
-      # provided by `shape`.
-      # rules provided by `shape`.
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      # @param [Hash] params
-      # @return [void]
-      def apply(shape, params)
-        structure(shape, params, '')
+      def apply(ref, params)
+        structure(ref, params, '')
       end
 
       private
 
-      # @param [Seahorse::Model::Shapes::Structure] structure
-      # @param [Hash] values
-      # @param [String, nil] prefix
-      def structure(structure, values, prefix)
+      def structure(ref, values, prefix)
+        shape = ref.shape
         values.each do |name, value|
           unless value.nil?
-            member_shape = structure.member(name)
-            format(member_shape, value, prefix + query_name(member_shape))
+            member_ref = shape.member(name)
+            format(member_ref, value, prefix + query_name(member_ref))
           end
         end
       end
 
-      # @param [Seahorse::Model::Shapes::List] list
-      # @param [Array] values
-      # @param [String] prefix
-      def list(list, values, prefix)
+      def list(ref, values, prefix)
         if values.empty?
           set(prefix, '')
         else
+          member_ref = ref.shape.member
           values.each.with_index do |value, n|
-            format(list.member, value, "#{prefix}.#{n+1}")
+            format(member_ref, value, "#{prefix}.#{n+1}")
           end
         end
       end
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Object] value
-      # @param [String] prefix
-      def format(shape, value, prefix)
-        case shape.type
-        when 'structure' then structure(shape, value, prefix + '.')
-        when 'list'      then list(shape, value, prefix)
-        when 'map'       then raise NotImplementedError
-        when 'blob'      then set(prefix, Base64.strict_encode64(value.read))
-        when 'timestamp'
-          set(prefix, shape.format_time(value, 'iso8601').to_s)
+      def format(ref, value, prefix)
+        case ref.shape
+        when StructureShape then structure(ref, value, prefix + '.')
+        when ListShape      then list(ref, value, prefix)
+        when MapShape       then raise NotImplementedError
+        when BlobShape      then set(prefix, blob(value))
+        when TimestampShape then set(prefix, timestamp(value))
         else
           set(prefix, value.to_s)
         end
       end
 
-      def query_name(shape)
-        shape.metadata('queryName') || ucfirst(shape.location_name)
+      def query_name(ref)
+        ref['queryName'] || ucfirst(ref.location_name)
       end
 
       def set(name, value)
@@ -77,6 +63,15 @@ module Aws
         str[0].upcase + str[1..-1]
       end
 
+      def blob(value)
+        value = value.read unless String === value
+        Base64.strict_encode64(value)
+      end
+
+      def timestamp(value)
+        value.utc.iso8601
+      end
+
     end
   end
 end

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

@@ -2,8 +2,24 @@ module Aws
   module Query
     class Handler < Seahorse::Client::Handler
 
+      include Seahorse::Model::Shapes
+
       CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=utf-8'
 
+      WRAPPER_STRUCT = Structure.new(:result, :response_metadata)
+
+      METADATA_STRUCT = Structure.new(:request_id)
+
+      METADATA_REF = begin
+        request_id = ShapeRef.new(
+          shape: StringShape.new,
+          location_name: 'RequestId')
+        response_metadata = StructureShape.new
+        response_metadata[:struct_class] = METADATA_STRUCT
+        response_metadata.add_member(:request_id, request_id)
+        ShapeRef.new(shape: response_metadata, location_name: 'ResponseMetadata')
+      end
+
       # @param [Seahorse::Client::RequestContext] context
       # @return [Seahorse::Client::Response]
       def call(context)
@@ -17,6 +33,7 @@ module Aws
       private
 
       def build_request(context)
+        context.http_request.http_method = 'POST'
         context.http_request.headers['Content-Type'] = CONTENT_TYPE
         param_list = ParamList.new
         param_list.set('Version', context.config.api.version)
@@ -32,9 +49,9 @@ module Aws
       end
 
       def parse_xml(context)
-        if rules = context.operation.output
-          data = Xml::Parser.new(apply_wrapper(rules)).parse(xml(context))
-          remove_wrapper(data, context, rules)
+        if context.operation.output
+          data = Xml::Parser.new(rules(context)).parse(xml(context))
+          remove_wrapper(data, context)
         else
           EmptyStructure.new
         end
@@ -44,24 +61,21 @@ module Aws
         context.http_response.body_contents
       end
 
-      def apply_wrapper(shape)
-        Seahorse::Model::Shapes::Structure.new({
-          'members' => {
-            shape.metadata('resultWrapper') => shape.definition,
-            'ResponseMetadata' => {
-              'type' => 'structure',
-              'members' => {
-                'RequestId' => { 'type' => 'string' }
-              }
-            }
-          }
-        }, shape_map: shape.shape_map)
+      def rules(context)
+        shape = Seahorse::Model::Shapes::StructureShape.new
+        shape.add_member(:result, ShapeRef.new(
+          shape: context.operation.output.shape,
+          location_name: context.operation.name + 'Result'
+        ))
+        shape[:struct_class] = WRAPPER_STRUCT
+        shape.add_member(:response_metadata, METADATA_REF)
+        ShapeRef.new(shape: shape)
       end
 
-      def remove_wrapper(data, context, rules)
-        if context.operation.output.metadata('resultWrapper')
+      def remove_wrapper(data, context)
+        if context.operation.output
           context[:request_id] = data.response_metadata.request_id
-          data[data.members.first] || Structure.new(rules.member_names)
+          data.result || Structure.new(context.operation.output.shape.member_names)
         else
           data
         end

data/lib/aws-sdk-core/query/param_builder.rb

@@ -4,100 +4,92 @@ module Aws
   module Query
     class ParamBuilder
 
-      # @param [ParamList] param_list
+      include Seahorse::Model::Shapes
+
       def initialize(param_list)
         @params = param_list
       end
 
-      # @return [ParamList]
       attr_reader :params
 
-      # Serializes the `params` hash onto {#param_list} following the rules
-      # provided by `shape`.
-      # rules provided by `shape`.
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      # @param [Hash] params
-      # @return [void]
-      def apply(shape, params)
-        structure(shape, params, '')
+      def apply(ref, params)
+        structure(ref, params, '')
       end
 
       private
 
-      # @param [Seahorse::Model::Shapes::Structure] structure
-      # @param [Hash] values
-      # @param [String, nil] prefix
-      def structure(structure, values, prefix)
-        values.each do |name, value|
-          unless value.nil?
-            member_shape = structure.member(name)
-            format(member_shape, value, prefix + query_name(member_shape))
-          end
+      def structure(ref, values, prefix)
+        shape = ref.shape
+        values.each_pair do |name, value|
+          next if value.nil?
+          member_ref = shape.member(name)
+          format(member_ref, value, prefix + query_name(member_ref))
         end
       end
 
-      # @param [Seahorse::Model::Shapes::List] list
-      # @param [Array] values
-      # @param [String] prefix
-      def list(list, values, prefix)
+      def list(ref, values, prefix)
+        member_ref = ref.shape.member
         if values.empty?
           set(prefix, '')
           return
         end
-        if flat?(list)
-          if name = query_name(list.member)
+        if flat?(ref)
+          if name = query_name(member_ref)
             parts = prefix.split('.')
             parts.pop
             parts.push(name)
             prefix = parts.join('.')
           end
         else
-          prefix += '.member'
+          prefix += '.' + (member_ref.location_name || 'member')
         end
         values.each.with_index do |value, n|
-          format(list.member, value, "#{prefix}.#{n+1}")
+          format(member_ref, value, "#{prefix}.#{n+1}")
         end
       end
 
-      # @param [Seahorse::Model::Shapes::Map] map
-      # @param [Hash] values
-      # @param [String] prefix
-      def map(map, values, prefix)
-        prefix += '.entry' unless flat?(map)
-        key_name = "%s.%d.#{query_name(map.key, 'key')}"
-        value_name  = "%s.%d.#{query_name(map.value, 'value')}"
+      def map(ref, values, prefix)
+        key_ref = ref.shape.key
+        value_ref = ref.shape.value
+        prefix += '.entry' unless flat?(ref)
+        key_name = "%s.%d.#{query_name(key_ref, 'key')}"
+        value_name  = "%s.%d.#{query_name(value_ref, 'value')}"
         values.each.with_index do |(key, value), n|
-          format(map.key, key, key_name % [prefix, n + 1])
-          format(map.value, value, value_name % [prefix, n + 1])
+          format(key_ref, key, key_name % [prefix, n + 1])
+          format(value_ref, value, value_name % [prefix, n + 1])
         end
       end
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Object] value
-      # @param [String] prefix
-      def format(shape, value, prefix)
-        case shape.type
-        when 'structure' then structure(shape, value, prefix + '.')
-        when 'list'      then list(shape, value, prefix)
-        when 'map'       then map(shape, value, prefix)
-        when 'blob'      then set(prefix, Base64.strict_encode64(value.read))
-        when 'timestamp'
-          set(prefix, shape.format_time(value, 'iso8601').to_s)
-        else
-          set(prefix, value.to_s)
+      def format(ref, value, prefix)
+        case ref.shape
+        when StructureShape then structure(ref, value, prefix + '.')
+        when ListShape      then list(ref, value, prefix)
+        when MapShape       then map(ref, value, prefix)
+        when BlobShape      then set(prefix, blob(value))
+        when TimestampShape then set(prefix, timestamp(value))
+        else set(prefix, value.to_s)
         end
       end
 
-      def query_name(shape, default = nil)
-        shape.location_name || default
+      def query_name(ref, default = nil)
+        ref.location_name || default
       end
 
       def set(name, value)
         params.set(name, value)
       end
 
-      def flat?(shape)
-        !!shape.metadata('flattened')
+      def flat?(ref)
+        ref['flattened']
+      end
+
+      def timestamp(value)
+        value.utc.iso8601
+      end
+
+      def blob(value)
+        value = value.read unless String === value
+        Base64.strict_encode64(value)
       end
 
     end

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

@@ -20,22 +20,10 @@ module Aws
       refresh
     end
 
-    # @return [String,nil]
-    def access_key_id
+    # @return [Credentials]
+    def credentials
       refresh_if_near_expiration
-      @access_key_id
-    end
-
-    # @return [String,nil]
-    def secret_access_key
-      refresh_if_near_expiration
-      @secret_access_key
-    end
-
-    # @return [String,nil]
-    def session_token
-      refresh_if_near_expiration
-      @session_token
+      @credentials
     end
 
     # @return [Time,nil]