aws-sdk-core 2.0.33 → 2.0.34

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

@@ -62,7 +62,7 @@ module Aws
       end
 
       def empty_value?(value)
-        value.nil? || value == [] || value == {}
+        value.nil? || value == '' || value == [] || value == {}
       end
 
     end

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

@@ -1,5 +1,3 @@
-require 'multi_xml'
-
 module Aws
   module Plugins
     class S3CompleteMultipartUploadFix < Seahorse::Client::Plugin
@@ -17,10 +15,10 @@ module Aws
         end
 
         def check_for_error(context)
-          xml = MultiXml.parse(context.http_response.body_contents)
-          if xml['Error']
-            error_code = xml['Error']['Code']
-            error_message = xml['Error']['Message']
+          xml = context.http_response.body_contents
+          if xml.match(/<Error>/)
+            error_code = xml.match(/<Code>(.+?)<\/Code>/)[1]
+            error_message = xml.match(/<Message>(.+?)<\/Message>/)[1]
             S3::Errors.error_class(error_code).new(context, error_message)
           end
         end

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

@@ -7,16 +7,9 @@ module Aws
         def call(context)
           @handler.call(context).on(200) do |response|
             response.data = Structure.new([:location_constraint])
-            xml = MultiXml.parse(context.http_response.body_contents)
-            if constraint = xml['LocationConstraint']
-              response.data[:location_constraint] =
-                case constraint
-                when String then constraint
-                when Hash then constraint['__content__'].to_s
-                end
-            else
-              response.data[:location_constraint] = ''
-            end
+            xml = context.http_response.body_contents
+            matches = xml.match(/>(.+?)<\/LocationConstraint>/)
+            response.data[:location_constraint] = matches ? matches[1] : ''
           end
         end
       end

data/lib/aws-sdk-core/signers/v4.rb

@@ -51,25 +51,17 @@ module Aws
         now = Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
         body_digest = options[:body_digest] || hexdigest(request.body)
 
-        params = Query::ParamList.new
-
-        request.headers['Host'] ||= request.endpoint.host
-        request.headers.each do |header_name, header_value|
-          if header_name.match(/^x-amz/)
-            params.set(header_name, header_value)
-          end
-          unless %w(host content-type content-md5).include?(header_name)
-            request.headers.delete(header_name)
-          end
-        end
+        request.headers['Host'] = request.endpoint.host
+        request.headers.delete('User-Agent')
 
+        params = Aws::Query::ParamList.new
         params.set("X-Amz-Algorithm", "AWS4-HMAC-SHA256")
+        params.set("X-Amz-Credential", credential(now))
         params.set("X-Amz-Date", now)
-        params.set("X-Amz-SignedHeaders", signed_headers(request))
         params.set("X-Amz-Expires", options[:expires_in].to_s)
+        params.set("X-Amz-SignedHeaders", signed_headers(request))
         params.set('X-Amz-Security-Token', credentials.session_token) if
           credentials.session_token
-        params.set("X-Amz-Credential", credential(now))
 
         endpoint = request.endpoint
         if endpoint.query

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

@@ -63,7 +63,7 @@ module Aws
       when Struct
         obj.members.each.with_object({}) do |member, hash|
           value = obj[member]
-          hash[member] = to_hash(value) unless value.nil?
+          hash[member] = to_hash(value) unless value == nil
         end
       when Hash
         obj.each.with_object({}) do |(key, value), hash|

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

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.0.33'
+  VERSION = '2.0.34'
 end

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

@@ -1,4 +1,4 @@
-require 'multi_xml'
+require 'cgi'
 
 module Aws
   module Xml
@@ -14,22 +14,29 @@ module Aws
       private
 
       def error(context)
-        if empty_body?(context)
-          error_code = empty_body_error_code(context)
-          error_message = ''
-        else
-          error_code, error_message = extract_error(context)
-        end
+        body = context.http_response.body_contents
+        code, message = extract_error(body, context)
         svc = context.client.class.name.split('::')[1]
         errors_module = Aws.const_get(svc).const_get(:Errors)
-        errors_module.error_class(error_code).new(context, error_message)
+        errors_module.error_class(code).new(context, message)
+      end
+
+      def extract_error(body, context)
+        [
+          error_code(body, context),
+          error_message(body),
+        ]
       end
 
-      def empty_body?(context)
-        context.http_response.body_contents.empty?
+      def error_code(body, context)
+        if matches = body.match(/<Code>(.+?)<\/Code>/)
+          remove_prefix(unescape(matches[1]), context)
+        else
+          http_status_error_code(context)
+        end
       end
 
-      def empty_body_error_code(context)
+      def http_status_error_code(context)
         status_code = context.http_response.status_code
         {
           302 => 'MovedTemporarily',
@@ -42,15 +49,7 @@ module Aws
         }[status_code] || "Http#{status_code}Error"
       end
 
-      def extract_error(context)
-        error = MultiXml.parse(context.http_response.body_contents)
-        %w(Response ErrorResponse Errors Error).each do |wrapper|
-          error = error[wrapper] if error[wrapper]
-        end
-        [remove_prefix(context, error['Code']), error['Message']]
-      end
-
-      def remove_prefix(context, error_code)
+      def remove_prefix(error_code, context)
         if prefix = context.config.api.metadata('errorPrefix')
           error_code.sub(/^#{prefix}/, '')
         else
@@ -58,6 +57,18 @@ module Aws
         end
       end
 
+      def error_message(body)
+        if matches = body.match(/<Message>(.+?)<\/Message>/)
+          unescape(matches[1])
+        else
+          ''
+        end
+      end
+
+      def unescape(str)
+        CGI.unescapeHTML(str)
+      end
+
     end
   end
 end

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

@@ -1,139 +1,78 @@
-require 'multi_xml'
-require 'time'
-require 'base64'
-
 module Aws
   module Xml
+
+    # A SAX-style XML parser that uses a shape context to handle types.
     class Parser
 
+      autoload :Stack, 'aws-sdk-core/xml/parser/stack'
+      autoload :Frame, 'aws-sdk-core/xml/parser/frame'
+      autoload :ParsingError, 'aws-sdk-core/xml/parser/parsing_error'
+
+      autoload :LibxmlEngine, 'aws-sdk-core/xml/parser/engines/libxml'
+      autoload :NokogiriEngine, 'aws-sdk-core/xml/parser/engines/nokogiri'
+      autoload :OxEngine, 'aws-sdk-core/xml/parser/engines/ox'
+      autoload :RexmlEngine, 'aws-sdk-core/xml/parser/engines/rexml'
+
       # @param [Seahorse::Model::Shapes::Structure] shape
       def initialize(shape)
         @shape = shape
+        @engine = self.class.engine
       end
 
-      # @param [String<xml>] xml
-      # @param [Hash, nil] target
+      # @param [String] xml An XML document string to parse.
+      # @param [Structure] target (nil)
       # @return [Structure]
-      def parse(xml, target = nil, &block)
-        xml = MultiXml.parse(xml).values.first || {}
-        yield(xml) if block_given?
-        structure(@shape, xml, target)
-      end
-
-      private
-
-      # @param [Seahorse::Model::Shapes::Structure] structure
-      # @param [Hash] values
-      # @param [Hash, nil] target
-      # @return [Structure]
-      def structure(structure, values, target = nil)
-        target = Structure.new(structure.member_names) if target.nil?
-        structure.members.each do |member_name, member_shape|
-          value_key = member_key(member_shape) || member_name.to_s
-          if values.key?(value_key)
-            target[member_name] = parse_shape(member_shape, values[value_key])
-          elsif member_shape.is_a?(Seahorse::Model::Shapes::List)
-            target[member_name] = DefaultList.new
-          elsif member_shape.is_a?(Seahorse::Model::Shapes::Map)
-            target[member_name] = {}
-          end
-        end
-        target
+      def parse(xml, target = nil)
+        xml = '<xml/>' if xml.nil? or xml.empty?
+        stack = Stack.new(@shape, target)
+        @engine.new(stack).parse(xml.to_s)
+        stack.result
       end
 
-      def member_key(shape)
-        if Seahorse::Model::Shapes::List === shape && flat?(shape)
-          shape.member.location_name || shape.location_name
-        else
-          shape.location_name
-        end
-      end
+      class << self
 
-      # @param [Seahorse::Model::Shapes::List] list
-      # @param [Array] values
-      # @return [Array]
-      def list(list, values)
-        unless flat?(list)
-          values = values[list.member.location_name || 'member']
+        # @param [Symbol,Class] engine
+        #   Must be one of the following values:
+        #
+        #   * :ox
+        #   * :libxml
+        #   * :nokogiri
+        #   * :rexml
+        #
+        def engine= engine
+          @engine = Class === engine ? engine : load_engine(engine)
         end
-        values = [values] unless values.is_a?(Array)
-        values.collect { |value| parse_shape(list.member, value) }
-      end
 
-      # @param [Seahorse::Model::Shapes::Map] map
-      # @param [Hash] entries
-      # @return [Hash]
-      def map(map, entries)
-        data = {}
-        entries = entries['entry'] unless flat?(map)
-        entries = [entries] unless entries.is_a?(Array)
-        entries.each do |entry|
-          key = entry[map.key.location_name || 'key']
-          value = entry[map.value.location_name || 'value']
-          data[parse_shape(map.key, key)] = parse_shape(map.value, value)
+        # @return [Class] Returns the default parsing engine.
+        #   One of:
+        #
+        #   * {OxEngine}
+        #   * {LibxmlEngine}
+        #   * {NokogiriEngine}
+        #   * {RexmlEngine}
+        #
+        def engine
+          @engine
         end
-        data
-      end
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Object] value
-      # @return [Object]
-      def parse_shape(shape, value)
-        if value.nil?
-          case shape
-          when Seahorse::Model::Shapes::Structure then structure(shape, {})
-          when Seahorse::Model::Shapes::Map then {}
-          when Seahorse::Model::Shapes::List then []
-          when Seahorse::Model::Shapes::String then ''
-          else nil
-          end
-        else
-          case shape
-          when Seahorse::Model::Shapes::String then string(shape, value)
-          when Seahorse::Model::Shapes::Structure then structure(shape, value)
-          when Seahorse::Model::Shapes::List then list(shape, value)
-          when Seahorse::Model::Shapes::Map then map(shape, value)
-          when Seahorse::Model::Shapes::Boolean then value == 'true'
-          when Seahorse::Model::Shapes::Integer then value.to_i
-          when Seahorse::Model::Shapes::Float then value.to_f
-          when Seahorse::Model::Shapes::Timestamp then timestamp(value)
-          when Seahorse::Model::Shapes::Blob then Base64.decode64(value)
-          else
-            raise "unhandled shape type: `#{shape.type}'"
-          end
-        end
-      end
+        private
 
-      def string(shape, value)
-        if value.is_a?(Hash)
-          decode_string(value)
-        else
-          value
+        def load_engine(name)
+          require "aws-sdk-core/xml/parser/engines/#{name}"
+          const_name = name[0].upcase + name[1..-1] + 'Engine'
+          const_get(const_name)
         end
-      end
 
-      def decode_string(value)
-        case value['encoding']
-        when 'base64' then Base64.decode64(value['__content__'])
-        else value['__content__']
+        def try_load_engine(name)
+          load_engine(name)
+        rescue LoadError
+          false
         end
-      end
 
-      def timestamp(value)
-        case value
-        when nil then nil
-        when /^\d+$/ then Time.at(value.to_i)
-        else
-          begin
-            Time.parse(value)
-          rescue ArgumentError
-            raise "unhandled timestamp format `#{value}'"
-          end
-        end
       end
 
-      def flat?(shape)
-        !!shape.metadata('flattened')
+      self.engine = [:ox, :libxml, :nokogiri, :rexml].find do |name|
+        try_load_engine(name)
       end
 
     end

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

@@ -0,0 +1,42 @@
+require 'libxml'
+
+module Aws
+  module Xml
+    class Parser
+      class LibxmlEngine
+
+        include LibXML::XML::SaxParser::Callbacks
+
+        def initialize(stack)
+          @stack = stack
+        end
+
+        def parse(xml)
+          parser = ::LibXML::XML::SaxParser.string(xml)
+          parser.callbacks = self
+          parser.parse
+        end
+
+        def on_start_element_ns(element_name, attributes, *ignored)
+          @stack.start_element(element_name)
+          attributes.each do |attr_name, attr_value|
+            @stack.attr(attr_name, attr_value)
+          end
+        end
+
+        def on_end_element_ns(*ignored)
+          @stack.end_element
+        end
+
+        def on_characters(chars)
+          @stack.text(chars)
+        end
+
+        def on_error(msg)
+          @stack.error(msg)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'nokogiri'
+
+module Aws
+  module Xml
+    class Parser
+      class NokogiriEngine
+
+        def initialize(stack)
+          @stack = stack
+        end
+
+        def parse(xml)
+          Nokogiri::XML::SAX::Parser.new(self).parse(xml)
+        end
+
+        def xmldecl(*args); end
+        def start_document; end
+        def end_document; end
+        def comment(*args); end
+
+        def start_element_namespace(element_name, attributes = [], *ignored)
+          @stack.start_element(element_name)
+          attributes.each do |attr|
+            @stack.attr(attr.localname, attr.value)
+          end
+        end
+
+        def characters(chars)
+          @stack.text(chars)
+        end
+
+        def end_element_namespace(*ignored)
+          @stack.end_element
+        end
+
+        def error(msg)
+          @stack.error(msg)
+        end
+
+      end
+    end
+  end
+end