aws-sdk-core 2.0.0.rc2 → 2.0.0.rc3

data/lib/aws/error_handler.rb

@@ -9,7 +9,7 @@ module Aws
     attr_accessor :handler
 
     def call(context)
-      @handler.call(context).on_status(300..599) do |response|
+      @handler.call(context).on(300..599) do |response|
         if empty_body?(response)
           error_code = error_code_for_empty_response(response)
           error_message = ''

data/lib/aws/json/builder.rb

@@ -42,8 +42,10 @@ module Aws
       def structure(shape, values)
         data = {}
         values.each do |key, value|
-          if member_shape = shape.members[key]
-            data[member_shape.serialized_name] = member(member_shape, value)
+          unless value.nil?
+            if member_shape = shape.members[key]
+              data[member_shape.serialized_name] = member(member_shape, value)
+            end
           end
         end
         data

data/lib/aws/pageable_response.rb

@@ -0,0 +1,230 @@
+require 'jamespath'
+
+module Aws
+
+  # A simple response pager.
+  #
+  # ## Basic Usage
+  #
+  # A pager is constructed with a response and a paging configuration.
+  # Typically, the paging configuration will already be present in
+  # the response context.
+  #
+  # The pager becomes a delegate to the response that allows you to
+  # discover if there are additional response pages to be requested.
+  #
+  #     page = PageableResponse.new(response)
+  #     page.last_page?(false)
+  #
+  #     # sends a request to receive the next response page
+  #     page = page.next_page
+  #     page.last_page?(true)
+  #
+  #     page.next_page
+  #     #=> raises PageableResponse::LastPageError
+  #
+  # You can still access all of the attributes and methods of the
+  # wrapped response.
+  #
+  #     # same
+  #     response.data
+  #     PageableResponse.new(response).data
+  #
+  # ## Paging Rules
+  #
+  # You can configure paging behavior by passing a `:paging_rules`
+  # hash to the constructor. If the hash is empty, then paging
+  # will be disabled.
+  #
+  #     # disables pagigng
+  #     page = PageableResponse.new(response, paging_rules: {})
+  #     page.last_page?
+  #     #=> true
+  #
+  # ### Tokens
+  #
+  # If you want to configure paging you must specify at least
+  # the `tokens` entry:
+  #
+  #     paging_rules = {
+  #       'tokens' => {
+  #         'input_param' => 'response_key',
+  #       }
+  #     }
+  #
+  # Tokens should be a hash of request parameter names as keys, and
+  # response data member names as values.  The `response.data` is
+  # inspected for a `response_key` member.  If it is present,
+  # it will be sent to the next page request as `:input_param`.
+  #
+  # If all of the configured tokens return `nil` values, the response
+  # is assumed to be the last page of results.
+  #
+  # ### Truncation Indicator
+  #
+  # Some services do not specify a token, but rather expect you to
+  # extract the final value from some list to request the next page.
+  # When this is the case, they will typically provide some boolean
+  # response data value that indicates if the response is truncated.
+  # You can configure this via `truncated_if`:
+  #
+  #     paging_rules['truncated_if'] = 'is_truncated'
+  #
+  # When `truncated_if` is configured, the tokens will not be checked,
+  # unless the configured member is `true`.
+  #
+  # @stability Unstable
+  #   PageableResponse public methods should be considered stable.
+  #   The structure of `:paging_rules` should be considered unstable
+  #   and subject to change.  If you are not providing custom
+  #   paging rules, then you should not worry about backwards
+  #   incompatible changes.
+  #
+  class PageableResponse < Seahorse::Client::Response
+
+    include Enumerable
+
+    # Raised when calling {PageableResponse#next_page} on a pager that
+    # is on the last page of results.  You can call {PageableResponse#last_page?}
+    # or {PageableResponse#next_page?} to know if there are more pages.
+    class LastPageError < RuntimeError
+
+      # @param [Seahorse::Client::Response] response
+      def initialize(response)
+        @response = response
+        super("unable to fetch next page, end of results reached")
+      end
+
+      # @return [Seahorse::Client::Response]
+      attr_reader :response
+
+    end
+
+    # @param [Seahorse::Client::Response] response
+    #
+    # @option options [Hash] :paging_rules Defaults to the `paging`
+    #   configuration in the response context.  If one is not configured
+    #   or you wish to override this paging configuration, you can
+    #   pass the `:paging_rules` option.  Passing an empty hash
+    #   disable paging for this operation.
+    #
+    #   See class level documentation above for more information about the
+    #   structure of `:paging_rules`.
+    #
+    # @stability Experimental
+    #   The structure of the `:paging_rules` option is subject to change.
+    #   Using this class without a custom set of paging rules should
+    #   be considered stable.
+    #
+    def initialize(response, options = {})
+      super(context:response.context, data:response.data, error:response.error)
+      @paging_rules = options[:paging_rules]
+    end
+
+    # 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?
+      !next_page?
+    end
+
+    # Returns `true` if there are more results.  Calling {#next_page} will
+    # return the next response.
+    # @return [Boolean]
+    def next_page?
+      @next_page = !!(pageable? && truncated?) if @next_page.nil?
+      @next_page
+    end
+
+    # @return [Seahorse::Client::Response]
+    def next_page(params = {})
+      if last_page?
+        raise LastPageError.new(self)
+      else
+        PageableResponse.new(next_response(params), paging_rules: paging_rules)
+      end
+    end
+
+    # Yields the current and each following response to the given block.
+    # @yieldparam [Response] response
+    # @return [Enumerable,nil] Returns a new Enumerable if no block is given.
+    def each_page(&block)
+      if block_given?
+        response = self
+        yield(response)
+        until response.last_page?
+          response = response.next_page
+          yield(response)
+        end
+      else
+        to_enum(__method__)
+      end
+    end
+    alias each each_page
+
+    # @api private
+    def eql?(other)
+      other.is_a?(Seahorse::Client::Response) &&
+      other.context == context &&
+      other.data == data &&
+      other.error == error
+    end
+    alias == eql?
+
+    private
+
+    # @return [Boolean] Returns `true` if the API operation is pageable.
+    #   Returns `false` if the API operation always returns ALL results.
+    def pageable?
+      paging_rules.key?('tokens')
+    end
+
+    # @return [Boolean] Returns `true` if the response is truncated and
+    #   there are more results to be had.
+    def truncated?
+      if condition = paging_rules['truncated_if']
+        Jamespath.search(condition, data)
+      else
+        !next_tokens.empty?
+      end
+    end
+
+    # @return [Hash] Extracts a hash of request parameters from
+    #   the response data that are needed to request the next response
+    #   page.
+    def next_tokens
+      @next_tokens ||= begin
+        paging_rules['tokens'].inject({}) do |tokens, (param, jamespath)|
+          value = Jamespath.search(jamespath, data)
+          tokens[param.to_sym] = value unless value.nil?
+          tokens
+        end
+      end
+    end
+
+    # @return [Hash, nil] Returns the rules for paging this response.
+    #   Returns `nil` when the response is not pageable.
+    def paging_rules
+      @paging_rules ||= context.operation.metadata['paging'] || {}
+    end
+
+    # @param [Hash] params A hash of additional request params to
+    #   merge into the next page request.
+    # @return [Seahorse::Client::Response] Returns the next page of
+    #   results.
+    def next_response(params)
+      c = context
+      req = c.client.build_request(c.operation_name, next_page_params(params))
+      req.send_request
+    end
+
+    # @param [Hash] params A hash of additional request params to
+    #   merge into the next page request.
+    # @return [Hash] Returns the hash of request parameters for the
+    #   next page, merging any given params.
+    def next_page_params(params)
+      context.params.merge(next_tokens.merge(params))
+    end
+
+  end
+end

data/lib/aws/plugins/glacier_checksums.rb

@@ -23,7 +23,6 @@ module Aws
     class GlacierChecksums < Seahorse::Client::Plugin
 
       CHECKSUM_OPERATIONS = [
-        :complete_multipart_upload,
         :upload_archive,
         :upload_multipart_part,
       ]
@@ -35,17 +34,18 @@ module Aws
 
         def call(context)
           unless context.http_request.headers[TREE_HASH]
-            populate_checksum_headers(context.http_request)
+            populate_checksum_headers(context)
           end
           @handler.call(context)
         end
 
         private
 
-        def populate_checksum_headers(http_req)
-          compute_checksums(http_req.body) do |hash, tree_hash|
-            http_req.headers[HASH] = hash
-            http_req.headers[TREE_HASH] = tree_hash
+        def populate_checksum_headers(context)
+          compute_checksums(context.http_request.body) do |hash, tree_hash|
+            context.http_request.headers[HASH] = hash
+            context.http_request.headers[TREE_HASH] = tree_hash.digest
+            context[:tree_hash] = tree_hash
           end
         end
 
@@ -55,46 +55,27 @@ module Aws
         # here so the sigv4 signer does not need to re-read the body.
         def compute_checksums(body, &block)
 
+          tree_hash = TreeHash.new
           digest = OpenSSL::Digest::Digest.new('sha256')
-          tree_digest = OpenSSL::Digest::Digest.new('sha256')
-          tree_parts = []
 
           # if the body is empty/EOF, then we should compute the
           # digests of the empty string
           if body.size == 0
-            tree_parts << tree_digest.update('').digest
+            tree_hash.update('')
             digest.update('')
           end
 
           until body.eof?
             chunk = body.read(1024 * 1024) # read 1MB
-            tree_parts << tree_digest.update(chunk).digest
-            tree_digest.reset
+            tree_hash.update(chunk)
             digest.update(chunk)
           end
 
           body.rewind
 
-          yield(digest.to_s, compute_tree_hash(tree_parts))
+          yield(digest.to_s, tree_hash)
 
         end
-
-        def compute_tree_hash hashes
-          digest = OpenSSL::Digest::Digest.new('sha256')
-          until hashes.count == 1
-            hashes = hashes.each_slice(2).map do |h1,h2|
-              digest.reset
-              if h2
-                digest.update(h1)
-                digest.update(h2)
-                digest.digest
-              else
-                h1
-              end
-            end
-          end
-          hashes.first.bytes.map{|x| x.to_i.to_s(16).rjust(2,'0')}.join('')
-        end
       end
 
       handler(Handler, operations: CHECKSUM_OPERATIONS)

data/lib/aws/plugins/response_paging.rb

@@ -0,0 +1,18 @@
+module Aws
+  module Plugins
+    class ResponsePaging < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          PageableResponse.new(@handler.call(context))
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws/plugins/retry_errors.rb

@@ -61,7 +61,9 @@ module Aws
         end
 
         def networking?
-          NETWORKING_ERRORS.include?(@name) || @http_status_code == 0
+          @error.is_a?(Seahorse::Client::Http::Error) ||
+          NETWORKING_ERRORS.include?(@name) ||
+          @http_status_code == 0
         end
 
         def server?

data/lib/aws/plugins/s3_complete_multipart_upload_fix.rb

@@ -7,7 +7,7 @@ module Aws
       class Handler < Seahorse::Client::Handler
 
         def call(context)
-          @handler.call(context).on_success do |response|
+          @handler.call(context).on(200) do |response|
             if error = check_for_error(response)
               response.http_response.status_code = 500
               response.data = nil

data/lib/aws/plugins/s3_get_bucket_location_fix.rb

@@ -5,10 +5,16 @@ module Aws
       class Handler < Seahorse::Client::Handler
 
         def call(context)
-          @handler.call(context).on_success do |response|
+          @handler.call(context).on(200) do |response|
             xml = MultiXml.parse(response.http_response.body_contents)
-            if constraint = xml['LocationConstraint']
-              response.data[:location_constraint] = constraint['__content__'].to_s
+            if xml.key?('LocationConstraint')
+              constraint = xml['LocationConstraint']
+              response.data[:location_constraint] =
+                case constraint
+                when String then constraint
+                when Hash then constraint['__content__'].to_s
+                when nil then ''
+                end
             end
           end
         end

data/lib/aws/plugins/signature_v4.rb

@@ -8,7 +8,8 @@ module Aws
     class SignatureV4 < Seahorse::Client::Plugin
 
       option(:sigv4_name) do |config|
-        config.api.metadata['endpoint_prefix']
+        config.api.metadata['signing_name'] ||
+          config.api.metadata['endpoint_prefix']
       end
 
       option(:sigv4_region) do |config|

data/lib/aws/plugins/sqs_queue_urls.rb

@@ -18,10 +18,13 @@ module Aws
         end
 
         def update_region(context, url)
-          region = url.split('.')[1]
-          context.config = context.config.dup
-          context.config.region = region
-          context.config.sigv4_region = region
+          if region = url.split('.')[1]
+            context.config = context.config.dup
+            context.config.region = region
+            context.config.sigv4_region = region
+          else
+            raise ArgumentError, "invalid queue url `#{url}'"
+          end
         end
 
       end

data/lib/aws/plugins/user_agent.rb

@@ -2,7 +2,7 @@ module Aws
   module Plugins
     class UserAgent < Seahorse::Client::Plugin
 
-      option(:user_agent_prefix)
+      option(:user_agent_suffix)
 
       # @api private
       class Handler < Seahorse::Client::Handler
@@ -13,12 +13,12 @@ module Aws
         end
 
         def set_user_agent(context)
-          ua = "%s aws-sdk-ruby/#{VERSION} %s/%s %s Seahorse/%s" % [
-            context.config.user_agent_prefix,
+          ua = "aws-sdk-ruby2/#{VERSION} %s/%s %s Seahorse/%s %s" % [
             (RUBY_ENGINE rescue nil or "ruby"),
             RUBY_VERSION,
             RUBY_PLATFORM,
             Seahorse::VERSION,
+            context.config.user_agent_suffix,
           ]
           context.http_request.headers['User-Agent'] = ua.strip
         end