aws-sdk-core 2.0.48 → 2.1.0

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

@@ -0,0 +1,22 @@
+module Aws
+  module Rest
+    class Handler < Seahorse::Client::Handler
+
+      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
+      end
+
+      private
+
+      def apply_request_id(context)
+        h = context.http_response.headers
+        context[:request_id] = h['x-amz-request-id'] || h['x-amzn-requestid']
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Aws
+  module Rest
+    module Request
+      class Body
+
+        include Seahorse::Model::Shapes
+
+        # @param [Class] serializer_class
+        # @param [Seahorse::Model::ShapeRef] rules
+        def initialize(serializer_class, rules)
+          @serializer_class = serializer_class
+          @rules = rules
+        end
+
+        # @param [Seahorse::Client::Http::Request] http_req
+        # @param [Hash] params
+        def apply(http_req, params)
+          http_req.body = build_body(params)
+        end
+
+        private
+
+        def build_body(params)
+          if streaming?
+            params[@rules[:payload]]
+          elsif @rules[:payload]
+            params = params[@rules[:payload]]
+            serialize(@rules[:payload_member], params) if params
+          else
+            params = body_params(params)
+            serialize(@rules, params) unless params.empty?
+          end
+        end
+
+        def streaming?
+          @rules[:payload] && (
+            BlobShape === @rules[:payload_member].shape ||
+            StringShape === @rules[:payload_member].shape
+          )
+        end
+
+        def serialize(rules, params)
+          @serializer_class.new(rules).serialize(params)
+        end
+
+        def body_params(params)
+          @rules.shape.members.inject({}) do |hash, (member_name, member_ref)|
+            if !member_ref.location && params.key?(member_name)
+              hash[member_name] = params[member_name]
+            end
+            hash
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Aws
+  module Rest
+    module Request
+      class Builder
+
+        def apply(context)
+          populate_http_method(context)
+          populate_endpoint(context)
+          populate_headers(context)
+          populate_body(context)
+        end
+
+        private
+
+        def populate_http_method(context)
+          context.http_request.http_method = context.operation.http_method
+        end
+
+        def populate_endpoint(context)
+          context.http_request.endpoint = Endpoint.new(
+            context.operation.input,
+            context.operation.http_request_uri,
+          ).uri(context.http_request.endpoint, context.params)
+        end
+
+        def populate_headers(context)
+          headers = Headers.new(context.operation.input)
+          headers.apply(context.http_request, context.params)
+        end
+
+        def populate_body(context)
+          Body.new(
+            serializer_class(context),
+            context.operation.input,
+          ).apply(context.http_request, context.params)
+        end
+
+        def serializer_class(context)
+          protocol = context.config.api.metadata['protocol']
+          case protocol
+          when 'rest-xml' then Xml::Builder
+          when 'rest-json' then Json::Builder
+          else raise "unsupported protocol #{protocol}"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'uri'
+
+module Aws
+  module Rest
+    module Request
+      class Endpoint
+
+        # @param [Seahorse::Model::Shapes::ShapeRef]
+        # @param [String] request_uri_pattern
+        def initialize(rules, request_uri_pattern)
+          @rules = rules
+          request_uri_pattern.split('?').tap do |path_part, query_part|
+            @path_pattern = path_part
+            @query_pattern = query_part
+          end
+        end
+
+        # @param [URI::HTTPS,URI::HTTP] base_uri
+        # @param [Hash,Struct] params
+        # @return [URI::HTTPS,URI::HTTP]
+        def uri(base_uri, params)
+          uri = URI.parse(base_uri.to_s)
+          apply_path_params(uri, params)
+          apply_querystring_params(uri, params)
+          uri
+        end
+
+        private
+
+        def apply_path_params(uri, params)
+          path = uri.path.sub(/\/$/, '') + @path_pattern.split('?')[0]
+          uri.path = path.gsub(/{\w+\+?}/) do |placeholder|
+            param_value_for_placeholder(placeholder, params)
+          end
+        end
+
+        def param_value_for_placeholder(placeholder, params)
+          value = params[param_name(placeholder)]
+          placeholder.include?('+') ?
+            value.gsub(/[^\/]+/) { |v| escape(v) } :
+            escape(value)
+        end
+
+        def param_name(placeholder)
+          location_name = placeholder.gsub(/[{}+]/,'')
+          param_name, _ = @rules.shape.member_by_location_name(location_name)
+          param_name
+        end
+
+        def apply_querystring_params(uri, params)
+          parts = []
+          parts << @query_pattern if @query_pattern
+          @rules.shape.members.each do |member_name, member|
+            if member.location == 'querystring' && !params[member_name].nil?
+              param_name = member.location_name
+              param_value = params[member_name]
+              parts << "#{param_name}=#{escape(param_value.to_s)}"
+            end
+          end
+          uri.query = parts.empty? ? nil : parts.join('&')
+        end
+
+        def escape(string)
+          Seahorse::Util.uri_escape(string)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'time'
+
+module Aws
+  module Rest
+    module Request
+      class Headers
+
+        include Seahorse::Model::Shapes
+
+        # @param [Seahorse::Model::ShapeRef] rules
+        def initialize(rules)
+          @rules = rules
+        end
+
+        # @param [Seahorse::Client::Http::Request] http_req
+        # @param [Hash] params
+        def apply(http_req, params)
+          @rules.shape.members.each do |name, ref|
+            value = params[name]
+            next if value.nil?
+            case ref.location
+            when 'header' then apply_header_value(http_req.headers, ref, value)
+            when 'headers' then apply_header_map(http_req.headers, ref, value)
+            end
+          end
+        end
+
+        private
+
+        def apply_header_value(headers, ref, value)
+          headers[ref.location_name] =
+            case ref.shape
+            when TimestampShape then value.utc.httpdate
+            else value.to_s
+            end
+        end
+
+        def apply_header_map(headers, ref, values)
+          prefix = ref.location_name || ''
+          values.each_pair do |name, value|
+            headers["#{prefix}#{name}"] = value.to_s
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Aws
+  module Rest
+    module Response
+      class Body
+
+        include Seahorse::Model::Shapes
+
+        # @param [Class] parser_class
+        # @param [Seahorse::Model::ShapeRef] rules
+        def initialize(parser_class, rules)
+          @parser_class = parser_class
+          @rules = rules
+        end
+
+        # @param [IO] body
+        # @param [Hash, Struct] data
+        def apply(body, data)
+          if streaming?
+            data[@rules[:payload]] = body
+          elsif @rules[:payload]
+            data[@rules[:payload]] = parse(body.read, @rules[:payload_member])
+          else
+            parse(body.read, @rules, data)
+          end
+        end
+
+        private
+
+        def streaming?
+          @rules[:payload] && (
+            BlobShape === @rules[:payload_member].shape ||
+            StringShape === @rules[:payload_member].shape
+          )
+        end
+
+        def parse(body, rules, target = nil)
+          @parser_class.new(rules).parse(body, target) if body.size > 0
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Aws
+  module Rest
+    module Response
+      class Headers
+
+        include Seahorse::Model::Shapes
+
+        # @param [Seahorse::Model::ShapeRef] rules
+        def initialize(rules)
+          @rules = rules
+        end
+
+        # @param [Seahorse::Client::Http::Response] http_resp
+        # @param [Hash, Struct] target
+        def apply(http_resp, target)
+          headers = http_resp.headers
+          @rules.shape.members.each do |name, ref|
+            case ref.location
+            when 'header' then extract_header_value(headers, name, ref, target)
+            when 'headers' then extract_header_map(headers, name, ref, target)
+            end
+          end
+        end
+
+        def extract_header_value(headers, name, ref, data)
+          if headers.key?(ref.location_name)
+            data[name] = cast_value(ref, headers[ref.location_name])
+          end
+        end
+
+        def cast_value(ref, value)
+          case ref.shape
+          when StringShape then value
+          when IntegerShape then value.to_i
+          when FloatShape then value.to_f
+          when BooleanShape then value == 'true'
+          when TimestampShape
+            if value =~ /\d+(\.\d*)/
+              Time.at(value.to_f)
+            else
+              Time.parse(value)
+            end
+          else raise "unsupported shape #{ref.shape.class}"
+          end
+        end
+
+        def extract_header_map(headers, name, ref, data)
+          data[name] = {}
+          prefix = ref.location_name || ''
+          headers.each do |header_name, header_value|
+            if match = header_name.match(/^#{prefix}(.+)/i)
+              data[name][match[1]] = header_value
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Aws
+  module Rest
+    module Response
+      class Parser
+
+        def apply(response)
+          # TODO : remove this unless check once response stubbing is fixed
+          unless response.data
+            response.data = response.context.operation.output[:struct_class].new
+          end
+          extract_status_code(response)
+          extract_headers(response)
+          extract_body(response)
+        end
+
+        private
+
+        def extract_status_code(response)
+          status_code = StatusCode.new(response.context.operation.output)
+          status_code.apply(response.context.http_response, response.data)
+        end
+
+        def extract_headers(response)
+          headers = Headers.new(response.context.operation.output)
+          headers.apply(response.context.http_response, response.data)
+        end
+
+        def extract_body(response)
+          Body.new(
+            parser_class(response),
+            response.context.operation.output,
+          ).apply(response.context.http_response.body, response.data)
+        end
+
+        def parser_class(response)
+          protocol = response.context.config.api.metadata['protocol']
+          case protocol
+          when 'rest-xml' then Xml::Parser
+          when 'rest-json' then Json::Parser
+          else raise "unsupported protocol #{protocol}"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Aws
+  module Rest
+    module Response
+      class StatusCode
+
+        # @param [Seahorse::Model::Shapes::ShapeRef] rules
+        def initialize(rules)
+          @rules = rules
+        end
+
+        # @param [Seahorse::Client::Http::Response] http_resp
+        # @param [Hash, Struct] data
+        def apply(http_resp, data)
+          @rules.shape.members.each do |member_name, member_ref|
+            if member_ref.location == 'statusCode'
+              data[member_name] = http_resp.status_code
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 module Aws
-  class SharedCredentials < Credentials
+  class SharedCredentials
+
+    include CredentialProvider
 
     # @api private
     KEY_MAP = {
@@ -33,6 +35,9 @@ module Aws
     # @return [String]
     attr_reader :profile_name
 
+    # @return [Credentials]
+    attr_reader :credentials
+
     # @api private
     def inspect
       parts = [
@@ -62,11 +67,11 @@ module Aws
 
     def load_from_path
       profile = load_profile
-      KEY_MAP.each do |source, target|
-        if profile.key?(source)
-          instance_variable_set("@#{target}", profile[source])
-        end
-      end
+      @credentials = Credentials.new(
+        profile['aws_access_key_id'],
+        profile['aws_secret_access_key'],
+        profile['aws_session_token']
+      )
     end
 
     def load_profile