aws-sdk 1.8.5 → 1.9.0

data/lib/aws/core/async_handle.rb

@@ -13,25 +13,25 @@
 
 module AWS
   module Core
-  
+
     # Mixin that provides a generic callback facility for asynchronous
     # tasks that can either succeed or fail.
     module AsyncHandle
-  
+
       # Called to signal success and fire off the success and complete callbacks.
       def signal_success
         __send_signal(:success)
       end
-  
+
       # Called to signal failure and fire off the failure and complete callbacks.
       def signal_failure
         __send_signal(:failure)
       end
-  
+
       # Registers a callback to be called on successful completion of
       # the task.
       #
-      #  handle.on_success { puts "It worked!" }
+      #     handle.on_success { puts "It worked!" }
       #
       # If this is called when the task has already completed
       # successfully, it will call the callback immediately.
@@ -42,10 +42,10 @@ module AWS
           (@_async_callbacks ||= []) << { :success => block }
         end
       end
-  
+
       # Registers a callback to be called when the task fails.
       #
-      #  handle.on_failure { puts "It didn't work!" }
+      #     handle.on_failure { puts "It didn't work!" }
       #
       # If this is called when the task has already failed, it will
       # call the callback immediately.
@@ -56,13 +56,13 @@ module AWS
           (@_async_callbacks ||= []) << { :failure => block }
         end
       end
-  
+
       # Registers a callback to be called when the task is complete,
       # regardless of its status.  Yields the status to the block.
       #
-      #  handle.on_complete do |status|
-      #    puts "It #{status == :success ? 'did' : 'did not'} work!"
-      #  end
+      #     handle.on_complete do |status|
+      #       puts "It #{status == :success ? 'did' : 'did not'} work!"
+      #     end
       #
       # If this is called when the task has already completed, it will
       # call the callback immediately.
@@ -76,7 +76,7 @@ module AWS
           }
         end
       end
-  
+
       private
       def __send_signal(kind)
         @_async_status = kind
@@ -84,7 +84,7 @@ module AWS
           cb[kind]
         end.compact.each {|block| block.call } if @_async_callbacks
       end
-  
+
     end
   end
 end

data/lib/aws/core/cacheable.rb

@@ -13,56 +13,55 @@
 
 module AWS
   module Core
-  
+
     # @private
     module Cacheable
-  
+
       # @private
       class NoData < StandardError; end
-  
+
       def self.included base
         base.extend Naming unless base.respond_to?(:service_ruby_name)
       end
-  
+
       # @private
       protected
       def local_cache_key
         raise NotImplementedError
       end
-  
+
       # @private
       protected
       def cache_key
         @cache_key ||= begin
-          endpoint_method = self.class.service_ruby_name + "_endpoint"
           config.credential_provider.access_key_id + ":" +
-            config.send(endpoint_method) + ":" +
+            config.region + ":" +
             self.class.name + ":" +
             local_cache_key
         end
       end
-  
+
       # @private
       public
       def retrieve_attribute attr, &block
-  
+
         if cache = AWS.response_cache
-  
+
           if cache.resource_cache.cached?(cache_key, attr.name)
             return cache.resource_cache.get(cache_key, attr.name)
           end
-  
+
           cache.select(*attr.request_types).each do |response|
             if attributes = attributes_from_response(response)
               cache.resource_cache.store(cache_key, attributes)
               return attributes[attr.name] if attributes.key?(attr.name)
             end
           end
-  
+
         end
-  
+
         response = yield
-  
+
         if attributes = attributes_from_response(response)
           if cache = AWS.response_cache
             cache.resource_cache.store(cache_key, attributes)
@@ -72,7 +71,7 @@ module AWS
           raise NoData.new("no data in #{response.request_type} response")
         end
       end
-  
+
     end
   end
 end

data/lib/aws/core/client.rb

@@ -105,7 +105,7 @@ module AWS
       #   end
       #
       # The block executes in the context of an HttpHandler
-      # instance, and +super+ delegates to the HTTP handler used by
+      # instance, and `super` delegates to the HTTP handler used by
       # this client.  This provides an easy way to spy on requests
       # and responses.  See HttpHandler, HttpRequest, and
       # HttpResponse for more details on how to implement a fully
@@ -177,11 +177,13 @@ module AWS
       protected
 
       def new_request
-        eval(self.class.name.sub(/::Client$/, ''))::Request.new
+        eval(self.class.name.sub(/::Client.*$/, ''))::Request.new
       end
 
       def new_response(*args, &block)
-        Response.new(*args, &block)
+        resp = Response.new(*args, &block)
+        resp.config = config
+        resp
       end
 
       def make_async_request response
@@ -315,18 +317,32 @@ module AWS
         response.error.kind_of?(Errors::ServerError)
       end
 
-      # @return [Boolean] Returns +true+ if the response contains an
+      # @return [Boolean] Returns `true` if the response contains an
       #   error message that indicates credentials have expired.
       def expired_credentials? response
         response.error and
         response.error.respond_to?(:code) and
-        (response.error.code == 'ExpiredTokenException' || response.error.code == 'ExpiredToken')
+        (
+          response.error.code.to_s.match(/expired/i) or # session credentials
+          response.error.code == 'InvalidClientTokenId' or # query services
+          response.error.code == 'UnrecognizedClientException' or # json services
+          response.error.code == 'InvalidAccessKeyId' or # s3
+          response.error.code == 'AuthFailure' # ec2
+        )
       end
 
       def throttled? response
         response.error and
         response.error.respond_to?(:code) and
-        response.error.code.to_s.match(/Throttling/i)
+        (
+          response.error.code.to_s.match(/throttl/i) or
+          #response.error.code == 'Throttling' or # most query services
+          #response.error.code == 'ThrottlingException' or # json services
+          #response.error.code == 'RequestThrottled' or # sqs
+          response.error.code == 'ProvisionedThroughputExceededException' or # ddb
+          response.error.code == 'RequestLimitExceeded' or # ec2
+          response.error.code == 'BandwidthLimitExceeded' # cloud search
+        )
       end
 
       def redirected? response
@@ -405,15 +421,15 @@ module AWS
       # in sub-classes (e.g. QueryClient, RESTClient, etc).
       # @param [Response] response
       # @return [Array<Code,Message>,nil] Should return an array with an
-      #   error code and message, or +nil+.
+      #   error code and message, or `nil`.
       def extract_error_details response
         raise NotImplementedError
       end
 
       # Given an error code string, this method will return an error class.
       #
-      #   AWS::EC2::Client.new.send(:error_code, 'InvalidInstanceId')
-      #   #=> AWS::EC2::Errors::InvalidInstanceId
+      #     AWS::EC2::Client.new.send(:error_code, 'InvalidInstanceId')
+      #     #=> AWS::EC2::Errors::InvalidInstanceId
       #
       # @param [String] error_code The error code string as returned by
       #   the service.  If this class contains periods, they will be
@@ -427,8 +443,8 @@ module AWS
 
       # Returns the ::Errors module for the current client.
       #
-      #   AWS::S3::Client.new.errors_module
-      #   #=> AWS::S3::Errors
+      #     AWS::S3::Client.new.errors_module
+      #     #=> AWS::S3::Errors
       #
       # @return [Module]
       #
@@ -466,6 +482,7 @@ module AWS
                 cached_response.cached = true
                 cached_response
               else
+
                 # process the http request
                 options[:async] ?
                 make_async_request(response, &read_block) :
@@ -515,15 +532,23 @@ module AWS
         http_request.host = endpoint
         http_request.port = port
         http_request.region = config.send(:"#{service_ruby_name}_region")
-        http_request.proxy_uri = config.proxy_uri
         http_request.use_ssl = config.use_ssl?
-        http_request.ssl_verify_peer = config.ssl_verify_peer?
-        http_request.ssl_ca_file = config.ssl_ca_file if config.ssl_ca_file
-        http_request.ssl_ca_path = config.ssl_ca_path if config.ssl_ca_path
 
         send("configure_#{name}_request", http_request, opts)
 
         http_request.headers["user-agent"] = user_agent_string
+
+        if
+          @config.http_continue_threshold and
+          http_request.headers['content-length'] and
+          http_request.headers['content-length'].to_i > @config.http_continue_threshold
+        then
+          http_request.headers["expect"] = "100-continue"
+          http_request.continue_timeout = @config.http_continue_timeout
+        else
+          http_request.continue_timeout = nil
+        end
+
         http_request.add_authorization!(credential_provider)
 
         http_request

data/lib/aws/core/collection.rb

@@ -16,20 +16,18 @@ module AWS
     # Provides useful methods for enumerating items in a collection.
     module Collection
 
-      AWS.register_autoloads(self) do
-        autoload :Simple, 'simple'
-        autoload :WithNextToken, 'with_next_token'
-        autoload :WithLimitAndNextToken, 'with_limit_and_next_token'
-      end
+      autoload :Simple, 'aws/core/collection/simple'
+      autoload :WithNextToken, 'aws/core/collection/with_next_token'
+      autoload :WithLimitAndNextToken, 'aws/core/collection/with_limit_and_next_token'
 
       include Enumerable
 
       # Yields once for every item in this collection.
       #
-      #   collection.each {|item| ... }
+      #     collection.each {|item| ... }
       #
       # @note If you want fewer than all items, it is generally better
-      #   to call {#page} than {#each} with a +:limit+.
+      #   to call {#page} than {#each} with a `:limit`.
       #
       # @param [Hash] options
       #
@@ -37,13 +35,13 @@ module AWS
       #   items to enumerate from this collection.
       #
       # @option options [next_token] :next_token (nil)
-      #   Acts as an offset.  +:next_token+ may be returned by {#each} and
-      #   {#each_batch} when a +:limit+ is provided.
+      #   Acts as an offset.  `:next_token` may be returned by {#each} and
+      #   {#each_batch} when a `:limit` is provided.
       #
       # @return [nil_or_next_token] Returns nil if all items were enumerated.
-      #   If some items were excluded because of a +:limit+ option then
-      #   a +next_token+ is returned.  Calling an enumerable method on
-      #   the same collection with the +next_token+ acts like an offset.
+      #   If some items were excluded because of a `:limit` option then
+      #   a `next_token` is returned.  Calling an enumerable method on
+      #   the same collection with the `next_token` acts like an offset.
       #
       def each options = {}, &block
         each_batch(options) do |batch|
@@ -53,13 +51,13 @@ module AWS
 
       # Yields items from this collection in batches.
       #
-      #   collection.each_batch do |batch|
-      #     batch.each do |item|
-      #       # ...
+      #     collection.each_batch do |batch|
+      #       batch.each do |item|
+      #         # ...
+      #       end
       #     end
-      #   end
       #
-      # == Variable Batch Sizes
+      # ## Variable Batch Sizes
       #
       # Each AWS service has its own rules on how it returns results.
       # Because of this batch size may very based on:
@@ -85,16 +83,14 @@ module AWS
       # Use this method when you want to call a method provided by
       # Enumerable, but you need to pass options:
       #
-      #   # raises an error because collect does not accept arguments
-      #   collection.collect(:limit => 10) {|i| i.name }
+      #     # raises an error because collect does not accept arguments
+      #     collection.collect(:limit => 10) {|i| i.name }
       #
-      #   # not an issue with the enum method
-      #   collection.enum(:limit => 10).collect(&:name)
+      #     # not an issue with the enum method
+      #     collection.enum(:limit => 10).collect(&:name)
       #
       # @param (see #each)
-      #
       # @option (see #each)
-      #
       # @return [Enumerable::Enumerator] Returns an enumerator for this
       #   collection.
       #
@@ -115,15 +111,15 @@ module AWS
       # Yields items from this collection in groups of an exact
       # size (except for perhaps the last group).
       #
-      #   collection.in_groups_of (10, :limit => 30) do |group|
+      #     collection.in_groups_of (10, :limit => 30) do |group|
       #
-      #     # each group should be exactly 10 items unless
-      #     # fewer than 30 items are returned by the service
-      #     group.each do |item|
-      #       #...
-      #     end
+      #       # each group should be exactly 10 items unless
+      #       # fewer than 30 items are returned by the service
+      #       group.each do |item|
+      #         #...
+      #       end
       #
-      #   end
+      #     end
       #
       # @param [Integer] size Size each each group of objects
       #   should be yielded in.
@@ -152,29 +148,29 @@ module AWS
 
       # Returns a single page of results in a kind-of array ({PageResult}).
       #
-      #   items = collection.page(:per_page => 10) # defaults to 10 items
-      #   items.is_a?(Array) # => true
-      #   items.size         # => 8
-      #   items.per_page     # => 10
-      #   items.last_page?   # => true
+      #     items = collection.page(:per_page => 10) # defaults to 10 items
+      #     items.is_a?(Array) # => true
+      #     items.size         # => 8
+      #     items.per_page     # => 10
+      #     items.last_page?   # => true
       #
       # If you need to display a "next page" link in a web view you can
       # use the #more? method.  Just make sure the generated link
-      # contains the +next_token+.
+      # contains the `next_token`.
       #
-      #   <% if items.more? %>
-      #     <%= link_to('Next Page', params.merge(:next_token => items.next_token) %>
-      #   <% end %>
+      #     <% if items.more? %>
+      #       <%= link_to('Next Page', params.merge(:next_token => items.next_token) %>
+      #     <% end %>
       #
       # Then in your controller you can find the next page of results:
       #
-      #   items = collection.page(:next_token => params[:next_token])
+      #     items = collection.page(:next_token => params[:next_token])
       #
       # Given a {PageResult} you can also get more results directly:
       #
-      #   more_items = items.next_page
+      #     more_items = items.next_page
       #
-      # @note This method does not accept a +:page+ option, which means you
+      # @note This method does not accept a `:page` option, which means you
       #   can only start at the begining of the collection and request
       #   the next page of results.  You can not choose an offset
       #   or know how many pages of results there will be.
@@ -248,15 +244,15 @@ module AWS
       #
       # An example of when this would be useful:
       #
-      #   collection.limit(10).each {|item| ... }
+      #     collection.limit(10).each {|item| ... }
       #
       # The collection class including this module should define _limit
       # and return the cached limit value (of 10 from this example).
       # This value may still be overridden by a locally passed
-      # +:limit+ option:
+      # `:limit` option:
       #
-      #   # limit 5 wins out
-      #   collection.limit(10).each(:limit => 5) {|item| ... }
+      #     # limit 5 wins out
+      #     collection.limit(10).each(:limit => 5) {|item| ... }
       #
       def _limit
         nil

data/lib/aws/core/collection/with_limit_and_next_token.rb

@@ -15,7 +15,7 @@ module AWS
   module Core
     module Collection
 
-      # = Collection::WithLimitAndNextToken
+      # # Collection::WithLimitAndNextToken
       #
       # This module is used by collections where the service may truncate
       # responses but that also accept a upper limit of results to