aws-sdk-core 2.0.0.rc15 → 2.0.0.rc16

data/lib/aws/credential_provider_chain.rb

@@ -9,7 +9,7 @@ module Aws
     def resolve
       providers.each do |method_name, options|
         credentials = send(method_name, options.merge(config: @config))
-        return credentials if credentials.set?
+        return credentials if credentials && credentials.set?
       end
       nil
     end
@@ -50,6 +50,8 @@ module Aws
 
     def shared_credentials(options = {})
       SharedCredentials.new(profile_name: options[:config].profile)
+    rescue Errors::NoSuchProfileError
+      nil
     end
 
     def instance_profile_credentials(*args)

data/lib/aws/errors.rb

@@ -34,10 +34,6 @@ module Aws
     # This error indicates a checksum failed.
     class ChecksumError < RuntimeError; end
 
-    # Raised when a {Service} is constructed an no suitable API
-    # version is found based on configuration.
-    class NoSuchApiVersionError < RuntimeError; end
-
     # Raised when a {Service} is constructed and the specified shared
     # credentials profile does not exist.
     class NoSuchProfileError < RuntimeError; end
@@ -80,9 +76,7 @@ module Aws
       #
       # @api private
       def error_class(error_code)
-        constant = error_code.to_s
-        constant = constant.gsub(/http:\/\/.*$/, '') # remove http namespaces
-        constant = constant.gsub(/[^a-zA-Z0-9]/, '').to_sym
+        constant = error_class_constant(error_code)
         if error_const_set?(constant)
           const_get(constant)
         else
@@ -92,6 +86,21 @@ module Aws
 
       private
 
+      # Convert an error code to an error class name/constant.
+      # This requires filtering non-safe characters from the constant
+      # name and ensuring it begins with an uppercase letter.
+      # @param [String] error_code
+      # @return [Symbol] Returns a symbolized constant name for the given
+      #   `error_code`.
+      def error_class_constant(error_code)
+        constant = error_code.to_s
+        constant = constant.gsub(/https?:.*$/, '')
+        constant = constant.gsub(/[^a-zA-Z0-9]/, '')
+        constant = 'Error' + constant unless constant.match(/^[a-z]/i)
+        constant = constant[0].upcase + constant[1..-1]
+        constant.to_sym
+      end
+
       def set_error_constant(constant)
         @const_set_mutex.synchronize do
           # Ensure the const was not defined while blocked by the mutex

data/lib/aws/pageable_response.rb

@@ -101,7 +101,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.params.merge(@pager.next_tokens(self).merge(params))
+      context[:original_params].merge(@pager.next_tokens(self).merge(params))
     end
 
     # Raised when calling {PageableResponse#next_page} on a pager that

data/lib/aws/plugins/csd_conditional_signing.rb

@@ -11,6 +11,11 @@ module Aws
     #
     class CSDConditionalSigning < Seahorse::Client::Plugin
 
+      # Adding region as an option to avoid an issue when `Aws.config[:region]`
+      # is populated and the global configuration plugin merges options onto
+      # this client.
+      option(:region)
+
       option(:sigv4_region) do |cfg|
         # extract the region name from the cloud search domain endpoint
         if cfg.endpoint

data/lib/aws/plugins/response_paging.rb

@@ -6,13 +6,19 @@ module Aws
       class Handler < Seahorse::Client::Handler
 
         def call(context)
-          pager = context.client.class.paginators.pager(context.operation.name)
-          PageableResponse.new(@handler.call(context), pager)
+          context[:original_params] = context.params
+          PageableResponse.new(@handler.call(context), pager(context))
+        end
+
+        private
+
+        def pager(context)
+          context.client.class.paginators.pager(context.operation.name)
         end
 
       end
 
-      handler(Handler)
+      handler(Handler, step: :initialize, priority: 90)
 
     end
   end

data/lib/aws/plugins/s3_url_encoded_keys.rb

@@ -46,8 +46,8 @@ module Aws
           decode(:next_marker, data)
           decode(:prefix, data)
           decode(:delimiter, data)
-          data.contents.each { |o| decode(:key, o) }
-          data.common_prefixes.each { |o| decode(:prefix, o) }
+          data.contents.each { |o| decode(:key, o) } if data.contents
+          data.common_prefixes.each { |o| decode(:prefix, o) } if data.common_prefixes
         end
 
         def decode_list_object_versions_keys(data)
@@ -55,9 +55,9 @@ module Aws
           decode(:next_key_marker, data)
           decode(:prefix, data)
           decode(:delimiter, data)
-          data.versions.each { |o| decode(:key, o) }
-          data.delete_markers.each { |o| decode(:key, o) }
-          data.common_prefixes.each { |o| decode(:prefix, o) }
+          data.versions.each { |o| decode(:key, o) } if data.versions
+          data.delete_markers.each { |o| decode(:key, o) } if data.delete_markers
+          data.common_prefixes.each { |o| decode(:prefix, o) } if data.common_prefixes
         end
 
         def decode_list_multipart_uploads_keys(data)
@@ -65,8 +65,8 @@ module Aws
           decode(:next_key_marker, data)
           decode(:prefix, data)
           decode(:delimiter, data)
-          data.uploads.each { |o| decode(:key, o) }
-          data.common_prefixes.each { |o| decode(:prefix, o) }
+          data.uploads.each { |o| decode(:key, o) } if data.uploads
+          data.common_prefixes.each { |o| decode(:prefix, o) } if data.common_prefixes
         end
 
         def decode(member, struct)

data/lib/aws/query/handler.rb

@@ -33,9 +33,8 @@ module Aws
 
       def parse_xml(context)
         if rules = context.operation.output
-          rules = apply_wrapper(rules)
-          data = Xml::Parser.new(rules).parse(xml(context))
-          remove_wrapper(data, context)
+          data = Xml::Parser.new(apply_wrapper(rules)).parse(xml(context))
+          remove_wrapper(data, context, rules)
         else
           EmptyStructure.new
         end
@@ -59,10 +58,10 @@ module Aws
         }, shape_map: shape.shape_map)
       end
 
-      def remove_wrapper(data, context)
+      def remove_wrapper(data, context, rules)
         if context.operation.output.metadata('resultWrapper')
           context[:request_id] = data.response_metadata.request_id
-          data[data.members.first]
+          data[data.members.first] || Structure.new(rules.member_names)
         else
           data
         end

data/lib/aws/version.rb

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.0.0.rc15'
+  VERSION = '2.0.0.rc16'
 end

data/lib/aws/waiters/errors.rb

@@ -0,0 +1,30 @@
+require 'jamespath'
+
+module Aws
+  module Waiters
+    module Errors
+
+      # Raised when a waiter detects a condition where the waiter can never
+      # succeed.
+      class WaiterFailed < StandardError; end
+
+      # Raised when attempting to get a waiter by name and the waiter has not
+      # been defined.
+      class NoSuchWaiter < ArgumentError
+        def initialize(waiter_name, waiter_names)
+          msg = "no definition found for #{waiter_name.inspect}"
+          msg << "; valid waiter names are:"
+          waiter_names.sort.each.with_index do |name, n|
+            if n % 3 == 0
+              msg << "\n  #{name.inspect}"
+            else
+              msg << ", #{name.inspect}"
+            end
+          end
+          super(msg)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/waiters/null_provider.rb

@@ -0,0 +1,12 @@
+module Aws
+  module Waiters
+    # @api private
+    class NullProvider < Provider
+
+      def initialize
+        super('waiters' => {})
+      end
+
+    end
+  end
+end

data/lib/aws/waiters/provider.rb

@@ -0,0 +1,54 @@
+require 'set'
+
+module Aws
+  module Waiters
+    # @api private
+    class Provider
+
+      def initialize(definitions)
+        @waiter_names = Set.new
+        @definitions = definitions['waiters'].each.with_object({}) do |(k,v),h|
+          if k.match(/^__/)
+            h[k] = v
+          else
+            underscore(k).to_sym.tap do |name|
+              @waiter_names << name
+              h[name] = v
+            end
+          end
+        end
+      end
+
+      # @return [Array<Symbol>]
+      def waiter_names
+        @waiter_names.to_a
+      end
+
+      # @param [Symbol] waiter_name
+      # @return [Waiter]
+      # @raise [ArgumentError]
+      def waiter(waiter_name)
+        if @waiter_names.include?(waiter_name)
+          Waiter.new(resolve('extends' => waiter_name))
+        else
+          raise Errors::NoSuchWaiter.new(waiter_name, waiter_names)
+        end
+      end
+
+      private
+
+      def resolve(definition)
+        if extends = definition.delete('extends')
+          resolve(@definitions[extends].merge(definition))
+        else
+          (@definitions['__default__'] || {}).merge(definition)
+        end
+      end
+
+      def underscore(str)
+        str.gsub(/\w+/) { |part| Seahorse::Util.underscore(part) }
+      end
+
+    end
+  end
+end

data/lib/aws/waiters/waiter.rb

@@ -0,0 +1,194 @@
+require 'jamespath'
+
+module Aws
+  module Waiters
+    class Waiter
+
+      # @api private
+      RAISE_HANDLER = Seahorse::Client::Plugins::RaiseResponseErrors::Handler
+
+      # @api private
+      def initialize(definition = {})
+        @definition = definition
+        @interval = definition['interval']
+        @max_attempts = definition['max_attempts']
+        @before_attempt = []
+        @before_wait = []
+      end
+
+      # Register a callback that is invoked before every polling attempt.
+      # Yields the number of attempts made so far.
+      #
+      #     waiter.before_attempt do |attempts|
+      #       puts "#{attempts} made, about to make attempt #{attempts + 1}"
+      #     end
+      #
+      # Throwing `:success` or `:failure` from the given block will stop
+      # the waiter and return or raise. You can pass a custom message to the
+      # throw:
+      #
+      #     # raises Aws::Waiters::Errors::WaiterFailed
+      #     waiter.before_attempt do |attempts|
+      #       throw :failure, 'custom-error-message'
+      #     end
+      #
+      #     # cause the waiter to stop polling and return
+      #     waiter.before_attempt do |attempts|
+      #       throw :success
+      #     end
+      #
+      # @yieldparam [Integer] attempts The number of attempts made.
+      def before_attempt(&block)
+        @before_attempt << Proc.new
+      end
+
+      # Register a callback that is invoked after an attempt but before
+      # sleeping. Yields the number of attempts made and the previous response.
+      #
+      #     waiter.before_wait do |attempts, response|
+      #       puts "#{attempts} made"
+      #       puts response.error.inspect
+      #       puts response.data.inspect
+      #     end
+      #
+      # Throwing `:success` or `:failure` from the given block will stop
+      # the waiter and return or raise. You can pass a custom message to the
+      # throw:
+      #
+      #     # raises Aws::Waiters::Errors::WaiterFailed
+      #     waiter.before_attempt do |attempts|
+      #       throw :failure, 'custom-error-message'
+      #     end
+      #
+      #     # cause the waiter to stop polling and return
+      #     waiter.before_attempt do |attempts|
+      #       throw :success
+      #     end
+      #
+      #
+      # @yieldparam [Integer] attempts The number of attempts already made.
+      # @yieldparam [Seahorse::Client::Response] response The response from
+      #   the previous polling attempts.
+      def before_wait(&block)
+        @before_wait << Proc.new
+      end
+
+      # @return [Float]
+      attr_accessor :interval
+
+      # @return [Integer]
+      attr_accessor :max_attempts
+
+      # @param [Client] client
+      # @param [Hash] params
+      def wait(client, params)
+        attempts = 0
+        catch(:success) do
+          failure = catch(:failure) do
+            loop do
+              trigger_callbacks(@before_attempt, attempts)
+              attempts += 1
+              resp = send_request(client, params)
+              throw :success, resp if successful?(resp)
+              throw :failure if failure?(resp)
+              throw :failure, resp.error unless error_ignored?(resp)
+              throw :failure, too_many(attempts) if attempts == max_attempts
+              trigger_callbacks(@before_wait, attempts, resp)
+              sleep(interval)
+            end
+          end
+          failure = 'waiter failed' if failure.nil?
+          raise String === failure ? Errors::WaiterFailed.new(failure) : failure
+        end
+      end
+
+      private
+
+      def successful?(response)
+        acceptor_matches?(:success, response)
+      end
+
+      def failure?(response)
+        acceptor_matches?(:failure, response)
+      end
+
+      def trigger_callbacks(callbacks, *args)
+        callbacks.each { |block| block.call(*args) }
+      end
+
+      def send_request(client, params)
+        req = client.build_request(operation_name, params)
+        req.handlers.remove(RAISE_HANDLER)
+        req.send_request
+      end
+
+      def operation_name
+        underscore(@definition['operation']).to_sym
+      end
+
+      def acceptor_matches?(acceptor, resp)
+        case type(acceptor)
+        when 'output' then output_matches?(resp, values(acceptor), path(acceptor))
+        when 'error' then error_matches?(resp.error, values(acceptor))
+        end
+      end
+
+      def type(acceptor)
+        @definition["#{acceptor}_type"] || @definition['acceptor_type']
+      end
+
+      def path(acceptor)
+        underscore(@definition["#{acceptor}_path"] || @definition['acceptor_path'])
+      end
+
+      def values(acceptor)
+        values = @definition["#{acceptor}_value"] || @definition['acceptor_value']
+        values.is_a?(Array) ? values : [values]
+      end
+
+      def output_matches?(resp, value, path)
+        if resp.error
+          false
+        elsif path
+          output_value_matches?(value, Jamespath.search(path, resp.data))
+        else
+          true
+        end
+      end
+
+      def output_value_matches?(expected, results)
+        if results.is_a?(Array)
+          results.all? { |result| expected.include?(result) }
+        else
+          expected.include?(results)
+        end
+      end
+
+      def error_ignored?(resp)
+        if resp.error
+          error_matches?(resp.error, @definition['ignore_errors'] || [])
+        else
+          true
+        end
+      end
+
+      def error_matches?(error, errors)
+        if error
+          errors.any? { |pattern| error.class.name.match(/#{pattern}$/) }
+        else
+          false
+        end
+      end
+
+      def too_many(attempts)
+        "too many attempts made, #{attempts} attempts made without " +
+        "success or failure"
+      end
+
+      def underscore(str)
+        str.gsub(/\w+/) { |part| Seahorse::Util.underscore(part) } if str
+      end
+
+    end
+  end
+end