aws-sdk-core 2.0.48 → 2.1.0

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

@@ -0,0 +1,67 @@
+module Aws
+  module Json
+    class Handler < Seahorse::Client::Handler
+
+      CONTENT_TYPE = 'application/x-amz-json-%s'
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @return [Seahorse::Client::Response]
+      def call(context)
+        build_request(context)
+        resp = @handler.call(context)
+        resp.on(200..299) { |resp| parse_response(resp) }
+        resp.on(200..599) { |resp| apply_request_id(context) }
+        resp
+      end
+
+      private
+
+      def build_request(context)
+        context.http_request.http_method = 'POST'
+        context.http_request.headers['Content-Type'] = content_type(context)
+        context.http_request.headers['X-Amz-Target'] = target(context)
+        context.http_request.body = build_body(context)
+      end
+
+      def build_body(context)
+        if simple_json?(context)
+          Json.dump(context.params)
+        else
+          Builder.new(context.operation.input).serialize(context.params)
+        end
+      end
+
+      def parse_response(response)
+        response.data = parse_body(response.context)
+      end
+
+      def parse_body(context)
+        if simple_json?(context)
+          Json.load(context.http_response.body_contents)
+        else
+          rules = context.operation.output
+          json = context.http_response.body_contents
+          Parser.new(rules).parse(json == '' ? '{}' : json)
+        end
+      end
+
+      def content_type(context)
+        CONTENT_TYPE % [context.config.api.metadata['jsonVersion']]
+      end
+
+      def target(context)
+        prefix = context.config.api.metadata['targetPrefix']
+        "#{prefix}.#{context.operation.name}"
+      end
+
+      def apply_request_id(context)
+        context[:request_id] = context.http_response.headers['x-amzn-requestid']
+      end
+
+      def simple_json?(context)
+        context.config.simple_json
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Aws
+  module Json
+    class OjEngine
+
+      def self.load(json)
+        Oj.load(json)
+      end
+
+      def self.dump(value)
+        Oj.dump(value)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Aws
+  module Json
+    class JSONEngine
+
+      def self.load(json)
+        JSON.load(json)
+      end
+
+      def self.dump(value)
+        JSON.dump(value)
+      end
+
+    end
+  end
+end

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

@@ -5,67 +5,59 @@ module Aws
   module Json
     class Parser
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
+      include Seahorse::Model::Shapes
+
+      # @param [Seahorse::Model::ShapeRef] rules
+      def initialize(rules)
+        @rules = rules
+      end
+
       # @param [String<JSON>] json
-      # @param [Hash, Array, nil] target
-      # @return [Hash]
-      def parse(shape, json, target = nil)
-        parse_shape(shape, MultiJson.load(json, max_nesting: false), target)
+      def parse(json, target = nil)
+        parse_ref(@rules, Json.load(json), target)
       end
 
       private
 
-      # @param [Seahorse::Model::Shapes::Structure] structure
-      # @param [Hash] values
-      # @param [Hash, nil] target
-      # @return [Struct]
-      def structure(structure, values, target = nil)
-        target = Structure.new(structure.member_names) if target.nil?
-        values.each do |serialized_name, value|
-          member_name, shape = structure.member_by_location_name(serialized_name)
-          if shape
-            target[member_name] = parse_shape(shape, value)
+      def structure(ref, values, target = nil)
+        shape = ref.shape
+        target = ref[: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)
           end
         end
         target
       end
 
-      # @param [Seahorse::Model::Shapes::List] list
-      # @param [Array] values
-      # @param [Array, nil] target
-      # @return [Array]
-      def list(list, values, target = nil)
+      def list(ref, values, target = nil)
         target = [] if target.nil?
-        values.each { |value| target << parse_shape(list.member, value) }
+        values.each do |value|
+          target << parse_ref(ref.shape.member, value)
+        end
         target
       end
 
-      # @param [Seahorse::Model::Shapes::Map] map
-      # @param [Hash] values
-      # @return [Hash]
-      def map(map, values, target = nil)
+      def map(ref, values, target = nil)
         target = {} if target.nil?
         values.each do |key, value|
-          target[key] = parse_shape(map.value, value)
+          target[key] = parse_ref(ref.shape.value, value)
         end
         target
       end
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Object] value
-      # @param [Hash, Array, nil] target
-      # @return [Object]
-      def parse_shape(shape, value, target = nil)
+      def parse_ref(ref, value, target = nil)
         if value.nil?
           nil
         else
-          case shape
-          when Seahorse::Model::Shapes::Structure then structure(shape, value, target)
-          when Seahorse::Model::Shapes::List then list(shape, value, target)
-          when Seahorse::Model::Shapes::Map then map(shape, value, target)
-          when Seahorse::Model::Shapes::Timestamp then time(value)
-          when Seahorse::Model::Shapes::Blob then Base64.decode64(value)
-          when Seahorse::Model::Shapes::Boolean then value.to_s == 'true'
+          case ref.shape
+          when StructureShape then structure(ref, value, target)
+          when ListShape then list(ref, value, target)
+          when MapShape then map(ref, value, target)
+          when TimestampShape then time(value)
+          when BlobShape then Base64.decode64(value)
+          when BooleanShape then value.to_s == 'true'
           else value
           end
         end

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

@@ -30,25 +30,22 @@ module Aws
   #   directly. The {Plugins::ResponsePaging} plugin automatically
   #   decorates all responses with a {PageableResponse}.
   #
-  class PageableResponse < Seahorse::Client::Response
+  module PageableResponse
 
-    include Enumerable
-
-    # @param [Seahorse::Client::Response] response
-    # @param [Paging::Pager] pager
-    def initialize(response, pager)
-      @pager = pager
-      super(context:response.context, data:response.data, error:response.error)
+    def self.included(base)
+      base.send(:include, Enumerable)
     end
 
     # @return [Paging::Pager]
-    attr_reader :pager
+    attr_accessor :pager
 
     # Returns `true` if there are no more results.  Calling {#next_page}
     # when this method returns `false` will raise an error.
     # @return [Boolean]
     def last_page?
-      @last_page = !@pager.truncated?(self)
+      if @last_page.nil?
+        @last_page = !@pager.truncated?(self)
+      end
       @last_page
     end
 
@@ -64,7 +61,7 @@ module Aws
       if last_page?
         raise LastPageError.new(self)
       else
-        PageableResponse.new(next_response(params), pager)
+        next_response(params)
       end
     end
 
@@ -117,7 +114,7 @@ module Aws
     # @return [Hash] Returns the hash of request parameters for the
     #   next page, merging any given params.
     def next_page_params(params)
-      context[:original_params].merge(@pager.next_tokens(self).merge(params))
+      context.params.merge(@pager.next_tokens(self).merge(params))
     end
 
     # Raised when calling {PageableResponse#next_page} on a pager that

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

@@ -0,0 +1,69 @@
+module Aws
+  # @api private
+  class Pager
+
+    def initialize(rules)
+      if rules['more_results']
+        @more_results = underscore(rules['more_results'])
+      end
+      if rules['limit_key']
+        @limit_key = underscore(rules['limit_key']).to_sym
+      end
+      map_tokens(rules)
+    end
+
+    # @return [Symbol, nil]
+    attr_reader :limit_key
+
+    # @param [Seahorse::Client::Response] response
+    # @return [Hash]
+    def next_tokens(response)
+      @tokens.each.with_object({}) do |(source, target), next_tokens|
+        value = JMESPath.search(source, response.data)
+        next_tokens[target.to_sym] = value unless empty_value?(value)
+      end
+    end
+
+    # @api private
+    def prev_tokens(response)
+      @tokens.each.with_object({}) do |(_, target), tokens|
+        value = JMESPath.search(target, response.context.params)
+        tokens[target.to_sym] = value unless empty_value?(value)
+      end
+    end
+
+    # @param [Seahorse::Client::Response] response
+    # @return [Boolean]
+    def truncated?(response)
+      if @more_results
+        JMESPath.search(@more_results, response.data)
+      else
+        next_tokens = self.next_tokens(response)
+        prev_tokens = self.prev_tokens(response)
+        !(next_tokens.empty? || next_tokens == prev_tokens)
+      end
+    end
+
+    private
+
+    def map_tokens(rules)
+      input = Array(rules['input_token'])
+      output = Array(rules['output_token'])
+      @tokens = {}
+      input.each.with_index do |key, n|
+        @tokens[underscore(output[n])] = underscore(key)
+      end
+    end
+
+    def underscore(str)
+      str.
+        gsub(' or ', '||').
+        gsub(/\w+/) { |part| Seahorse::Util.underscore(part) }
+    end
+
+    def empty_value?(value)
+      value.nil? || value == '' || value == [] || value == {}
+    end
+
+  end
+end

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

@@ -0,0 +1,203 @@
+require 'stringio'
+require 'date'
+require 'time'
+require 'tempfile'
+require 'thread'
+
+module Aws
+  # @api private
+  class ParamConverter
+
+    include Seahorse::Model::Shapes
+
+    @mutex = Mutex.new
+    @converters = Hash.new { |h,k| h[k] = {} }
+
+    def initialize(rules)
+      @rules = rules
+    end
+
+    # @param [Hash] params
+    # @return [Hash]
+    def convert(params)
+      structure(@rules, params)
+    end
+
+    private
+
+    def structure(ref, values)
+      values = c(ref, values)
+      if Struct === values || Hash === values
+        values.each_pair do |k, v|
+          unless v.nil?
+            if ref.shape.member?(k)
+              values[k] = member(ref.shape.member(k), v)
+            end
+          end
+        end
+      end
+      values
+    end
+
+    def list(ref, values)
+      values = c(ref, values)
+      if values.is_a?(Array)
+        values.map { |v| member(ref.shape.member, v) }
+      else
+        values
+      end
+    end
+
+    def map(ref, values)
+      values = c(ref, values)
+      if values.is_a?(Hash)
+        values.each.with_object({}) do |(key, value), hash|
+          hash[member(ref.shape.key, key)] = member(ref.shape.value, value)
+        end
+      else
+        values
+      end
+    end
+
+    def member(ref, value)
+      case ref.shape
+      when StructureShape then structure(ref, value)
+      when ListShape then list(ref, value)
+      when MapShape then map(ref, value)
+      else c(ref, value)
+      end
+    end
+
+    def c(ref, value)
+      self.class.c(ref.shape.class, value)
+    end
+
+    class << self
+
+      def convert(shape, params)
+        new(shape).convert(params)
+      end
+
+      # Registers a new value converter.  Converters run in the context
+      # of a shape and value class.
+      #
+      #     # add a converter that stringifies integers
+      #     shape_class = Seahorse::Model::Shapes::StringShape
+      #     ParamConverter.add(shape_class, Integer) { |i| i.to_s }
+      #
+      # @param [Class<Model::Shapes::Shape>] shape_class
+      # @param [Class] value_class
+      # @param [#call] converter (nil) An object that responds to `#call`
+      #    accepting a single argument.  This function should perform
+      #    the value conversion if possible, returning the result.
+      #    If the conversion is not possible, the original value should
+      #    be returned.
+      # @return [void]
+      def add(shape_class, value_class, converter = nil, &block)
+        @converters[shape_class][value_class] = converter || block
+      end
+
+      # @api private
+      def c(shape, value)
+        if converter = converter_for(shape, value)
+          converter.call(value)
+        else
+          value
+        end
+      end
+
+      private
+
+      def converter_for(shape_class, value)
+        unless @converters[shape_class].key?(value.class)
+          @mutex.synchronize {
+            unless @converters[shape_class].key?(value.class)
+              @converters[shape_class][value.class] = find(shape_class, value)
+            end
+          }
+        end
+        @converters[shape_class][value.class]
+      end
+
+      def find(shape_class, value)
+        converter = nil
+        each_base_class(shape_class) do |klass|
+          @converters[klass].each do |value_class, block|
+            if value_class === value
+              converter = block
+              break
+            end
+          end
+          break if converter
+        end
+        converter
+      end
+
+      def each_base_class(shape_class, &block)
+        shape_class.ancestors.each do |ancestor|
+          yield(ancestor) if @converters.key?(ancestor)
+        end
+      end
+
+    end
+
+    add(StructureShape, Hash) { |h| h.dup }
+    add(StructureShape, Struct)
+
+    add(MapShape, Hash) { |h| h.dup }
+    add(MapShape, Struct) do |s|
+      s.members.each.with_object({}) {|k,h| h[k] = s[k] }
+    end
+
+    add(ListShape, Array) { |a| a.dup }
+    add(ListShape, Enumerable) { |value| value.to_a }
+
+    add(StringShape, String)
+    add(StringShape, Symbol) { |sym| sym.to_s }
+
+    add(IntegerShape, Integer)
+    add(IntegerShape, Float) { |f| f.to_i }
+    add(IntegerShape, String) do |str|
+      begin
+        Integer(str)
+      rescue ArgumentError
+        str
+      end
+    end
+
+    add(FloatShape, Float)
+    add(FloatShape, Integer) { |i| i.to_f }
+    add(FloatShape, String) do |str|
+      begin
+        Float(str)
+      rescue ArgumentError
+        str
+      end
+    end
+
+    add(TimestampShape, Time)
+    add(TimestampShape, Date) { |d| d.to_time }
+    add(TimestampShape, DateTime) { |dt| dt.to_time }
+    add(TimestampShape, Integer) { |i| Time.at(i) }
+    add(TimestampShape, Float) { |f| Time.at(f) }
+    add(TimestampShape, String) do |str|
+      begin
+        Time.parse(str)
+      rescue ArgumentError
+        str
+      end
+    end
+
+    add(BooleanShape, TrueClass)
+    add(BooleanShape, FalseClass)
+    add(BooleanShape, String) do |str|
+      { 'true' => true, 'false' => false }[str]
+    end
+
+    add(BlobShape, IO)
+    add(BlobShape, Tempfile)
+    add(BlobShape, StringIO)
+    add(BlobShape, String)
+
+  end
+end