aws-sdk 1.6.3 → 1.6.4

data/lib/aws/core.rb

@@ -62,14 +62,14 @@ require 'aws/core/autoloader'
 #   config/initializers/aws-sdk.rb
 #
 # Optionally you can create a Yaml configuration file at
-# RAILS_ROOT/config/aws.yaml; This should be formatted in the same manor
+# RAILS_ROOT/config/aws.yml; This should be formatted in the same manor
 # as the default RAILS_ROOT/config/database.yml file (one section for
 # each Rails environment).
 #
 module AWS
 
   # Current version of the AWS SDK for Ruby
-  VERSION = "1.6.3"
+  VERSION = "1.6.4"
 
   register_autoloads(self) do
     autoload :Errors, 'errors'
@@ -78,6 +78,7 @@ module AWS
   module Core
 
     AWS.register_autoloads(self) do
+
       autoload :AsyncHandle,               'async_handle'
       autoload :Cacheable,                 'cacheable'
       autoload :Client,                    'client'
@@ -87,9 +88,11 @@ module AWS
       autoload :Data,                      'data'
       autoload :IndifferentHash,           'indifferent_hash'
       autoload :Inflection,                'inflection'
+
       autoload :JSONClient,                'json_client'
-      autoload :QueryClient,               'query_client'
-      autoload :RESTClient,                'rest_client'
+      autoload :JSONRequestBuilder,        'json_request_builder'
+      autoload :JSONResponseParser,        'json_response_parser'
+
       autoload :LazyErrorClasses,          'lazy_error_classes'
       autoload :LogFormatter,              'log_formatter'
       autoload :MetaUtils,                 'meta_utils'
@@ -98,13 +101,24 @@ module AWS
       autoload :OptionGrammar,             'option_grammar'
       autoload :PageResult,                'page_result'
       autoload :Policy,                    'policy'
+
+      autoload :QueryClient,               'query_client'
+      autoload :QueryRequestBuilder,       'query_request_builder'
+      autoload :QueryResponseParser,       'query_response_parser'
+
       autoload :Resource,                  'resource'
       autoload :ResourceCache,             'resource_cache'
       autoload :Response,                  'response'
       autoload :ResponseCache,             'response_cache'
+
+      autoload :RESTClient,                'rest_client'
+      autoload :RESTRequestBuilder,        'rest_request_builder'
+      autoload :RESTResponseParser,        'rest_response_parser'
+
       autoload :ServiceInterface,          'service_interface'
       autoload :Signer,                    'signer'
       autoload :UriEscape,                 'uri_escape'
+
     end
 
     module Options
@@ -209,6 +223,12 @@ module AWS
     # @option options [String] :cloud_formation_endpoint ('cloudformation.us-east-1.amazonaws.com')
     #   The service endpoint for AWS CloudFormation.
     #
+    # @option options [Boolean] :dynamo_db_big_decimals (true) When +true+,
+    #   {DynamoDB} will convert number values returned by {DynamoDB::Client}
+    #   from strings to BigDecimal objects.  If you set this to +false+,
+    #   they will be convereted from strings into floats (with a potential
+    #              # backwards to test xml ordering   loss of precision).
+    #
     # @option options [String] :dynamo_db_endpoint ('dynamodb.amazonaws.com')
     #   The service endpoint for Amazon DynamoDB.
     #

data/lib/aws/core/client.rb

@@ -356,15 +356,6 @@ module AWS
       end
 
       def populate_error response
-        response.error = extract_error(response)
-      end
-
-      # If the response contains error, this method will construct
-      # and return an error object.  If no error is contained in the
-      # response, then nil is returned.
-      # @param [Response] response
-      # @return [Errors::Base,nil]
-      def extract_error response
 
         status = response.http_response.status
 
@@ -377,14 +368,25 @@ module AWS
           error_message
         ]
 
-        case
-        when response.network_error? then NetworkError.new
-        when error_code              then error_class(error_code).new(*error_args)
-        when status >= 500           then Errors::ServerError.new(*error_args)
-        when status >= 300           then Errors::ClientError.new(*error_args)
-        else nil # no error
-        end
+        response.error =
+          case
+          when response.network_error? then NetworkError.new
+          when error_code then error_class(error_code).new(*error_args)
+          when status >= 500 then Errors::ServerError.new(*error_args)
+          when status >= 300 then Errors::ClientError.new(*error_args)
+          else nil # no error
+          end
+
+      end
 
+      # Extracts the error code and error message from a response
+      # if it contains an error.  Returns nil otherwise.  Should be defined
+      # 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+.
+      def extract_error_details response
+        raise NotImplementedError
       end
 
       # Given an error code string, this method will return an error class.
@@ -511,44 +513,111 @@ module AWS
         user_agent
       end
 
-      # Adds a single method to the current client class.  This method
-      # yields a request method builder that allows you to specify how:
-      #
-      # * the request is built
-      # * the response is processed
-      # * the response is stubbed for testing
-      #
-      def self.add_client_request_method method_name, options = {}, &block
+      class << self
+
+        # @return [Array<Symbol>] Returns a list of service operations as
+        #   method names supported by this client.
+        def operations
+          @operations ||= []
+        end
 
-        operations << method_name
+        # @private
+        def request_builders
+          @request_builders ||= {}
+        end
+
+        # @private
+        def response_parsers
+          @response_parsers ||= {}
+        end
+
+        protected
+
+        # Define this in sub-classes (e.g. QueryClient, RESTClient, etc)
+        def request_builder_for api_config, operation
+          raise NotImplementedError
+        end
 
-        ClientRequestMethodBuilder.new(self, method_name, &block)
+        # Define this in sub-classes (e.g. QueryClient, RESTClient, etc)
+        def response_parser_for api_config, operation
+          raise NotImplementedError
+        end
+
+        # Adds a single method to the current client class.  This method
+        # yields a request method builder that allows you to specify how:
+        #
+        # * the request is built
+        # * the response is processed
+        # * the response is stubbed for testing
+        #
+        def add_client_request_method method_name, options = {}, &block
+
+          operations << method_name
+
+          ClientRequestMethodBuilder.new(self, method_name, &block)
+
+          method_def = <<-METHOD
+            def #{method_name}(*args, &block)
+              options = args.first ? args.first : {}
+              client_request(#{method_name.inspect}, options, &block)
+            end
+          METHOD
+
+          module_eval(method_def)
+
+        end
+
+        # Loads the API configuration for the given API version.
+        # @param [String] api_version The API version date string
+        #   (e.g. '2012-01-05').
+        # @return [Hash]
+        def load_api_config api_version
+          lib = File.dirname(File.dirname(__FILE__))
+          path = "#{lib}/api_config/#{service_name}-#{api_version}.yml"
+          YAML.load(File.read(path))
+        end
+
+        # Defines one method for each service operation described in
+        # the API configuration.
+        # @param [String] api_version
+        def define_client_methods api_version
+
+          const_set(:API_VERSION, api_version)
+
+          api_config = load_api_config(api_version)
+
+          api_config[:operations].each do |operation|
+
+            builder = request_builder_for(api_config, operation)
+            parser = response_parser_for(api_config, operation)
+
+            define_client_method(operation[:method], builder, parser)
 
-        method_def = <<-METHOD
-          def #{method_name}(*args, &block)
-            options = args.first ? args.first : {}
-            client_request(#{method_name.inspect}, options, &block)
           end
-        METHOD
+        end
 
-        module_eval(method_def)
+        def define_client_method method_name, builder, parser
 
-      end
+          request_builders[method_name] = builder
+          response_parsers[method_name] = parser
 
-      # Parses the service's API configuration yaml file.  This file has
-      # configuration that drives the request and response DSLs.
-      # @return [Hash]
-      def self.api_config
-        config_file =
-          File.dirname(File.dirname(__FILE__)) +
-          "/api_config/#{service_name}-#{self::API_VERSION}.yml"
-        YAML.load(File.read(config_file))
-      end
+          add_client_request_method(method_name) do
+
+            configure_request do |request, request_options|
+              builder.populate_request(request, request_options)
+            end
+
+            process_response do |response|
+              response.data = parser.extract_data(response)
+            end
+
+            simulate_response do |response|
+              response.data = parser.simulate
+            end
+
+          end
+        end
 
-      # @return [Array<Symbol>] Returns a list of service operations as
-      #   method names supported by this client.
-      def self.operations
-        @operations ||= []
       end
 
       # @private

data/lib/aws/core/configuration.rb

@@ -69,6 +69,12 @@ module AWS
     # @attr_reader [String] cloud_formation_endpoint ('cloudformation.us-east-1.amazonaws.com')
     #   The service endpoint for AWS CloudFormation.
     #
+    # @attr_reader [Boolean] dynamo_db_big_decimals (true) When +true+,
+    #   {DynamoDB} will convert number values returned by {DynamoDB::Client}
+    #   from strings to BigDecimal objects.  If you set this to +false+,
+    #   they will be convereted from strings into floats (with a potential
+    #   loss of precision).
+    #
     # @attr_reader [String] dynamo_db_endpoint ('dynamodb.us-east-1.amazonaws.com')
     #   The service endpoint for Amazon DynamoDB.
     #

data/lib/aws/core/credential_providers.rb

@@ -14,6 +14,7 @@
 require 'set'
 require 'net/http'
 require 'timeout'
+require 'thread'
 
 module AWS
   module Core

data/lib/aws/core/http/curb_handler.rb

@@ -16,7 +16,7 @@ require 'thread'
 module AWS
   module Core
     module Http
-  
+
       # @private
       class CurbHandler
 
@@ -86,10 +86,10 @@ module AWS
 
         private
         def make_easy_handle request, response, thread = nil
-  
+
           protocol = request.use_ssl? ? 'https' : 'http'
           url = "#{protocol}://#{request.host}:#{request.port}#{request.uri}"
-  
+
           curl = Curl::Easy.new(url)
           # curl.verbose = true
           request.headers.each {|k, v| curl.headers[k] = v}

data/lib/aws/core/http/httparty_handler.rb

@@ -16,7 +16,7 @@ require 'httparty'
 module AWS
   module Core
     module Http
-  
+
       # Makes HTTP requests using HTTParty.  This is the default
       # handler, so you don't need to do anything special to configure
       # it.  However, you can directly instantiate this class in order
@@ -31,11 +31,11 @@ module AWS
       #   )
       #
       class HTTPartyHandler
-  
+
         # @return [Hash] The default options to send to HTTParty on each
         #   request.
         attr_reader :default_request_options
-  
+
         # Constructs a new HTTP handler using HTTParty.
         #
         # @param [Hash] options Default options to send to HTTParty on
@@ -48,25 +48,25 @@ module AWS
         def initialize options = {}
           @default_request_options = options
         end
-  
+
         include HTTParty
-  
+
         class NoOpParser < HTTParty::Parser
           SupportedFormats = {}
         end
-  
+
         def handle(request, response)
-  
+
           opts = default_request_options.merge({
             :body => request.body,
             :parser => NoOpParser
           })
-  
+
           if request.proxy_uri
             opts[:http_proxyaddr] = request.proxy_uri.host
             opts[:http_proxyport] = request.proxy_uri.port
           end
-  
+
           if request.use_ssl?
             protocol = 'https'
             opts[:ssl_ca_file] = request.ssl_ca_file if request.ssl_verify_peer?
@@ -75,21 +75,21 @@ module AWS
           end
 
           url = "#{protocol}://#{request.host}:#{request.port}#{request.uri}"
-  
+
           # get, post, put, delete, head
           method = request.http_method.downcase
-  
+
           # Net::HTTP adds this header for us when the body is
           # provided, but it messes up signing
           headers = { 'content-type' => '' }
-  
+
           # headers must have string values (net http calls .strip on them)
           request.headers.each_pair do |key,value|
             headers[key] = value.to_s
           end
-  
+
           opts[:headers] = headers
-  
+
           begin
             http_response = self.class.send(method, url, opts)
             unless http_response.nil?
@@ -105,7 +105,7 @@ module AWS
     end
   end
 
-  # We move this from AWS::Http to AWS::Core::Http, but we want the 
+  # We move this from AWS::Http to AWS::Core::Http, but we want the
   # previous default handler to remain accessible from its old namesapce
   # @private
   module Http

data/lib/aws/core/json_client.rb

@@ -11,94 +11,36 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-require 'json'
-
 module AWS
   module Core
-
-    # = AWS::Core::Client::JSON
-    #
-    # Clients extend this module if the service they represent are
-    # AWS Query services that accept and return JSON.
-    #
-    module JSONClient
-
-      # Constructs the option grammars, one per service operation.
-      # @private
-      def self.extended base
-        base.send(:include, ErrorParser)
-        base.send(:define_grammars)
-      end
-
-      # @return [Hash<Symbol,OptionGrammar>] Returns a hash option
-      #   grammars.  Keys are method names (operations) and values are
-      #   request option grammars that convert a ruby hash of options
-      #   into a JSON document.
-      # @private
-      def option_grammars
-        @option_grammars ||= {}
-      end
+    class JSONClient < Core::Client
 
       protected
 
-      # Enumerates through the operations specified in the API
-      # configuration (yaml configuration file found in lib/api_config/)
-      # and defines one request method per operation.
-      def define_grammars
-        api_config[:operations].each do |op|
-          option_grammars[op[:method]] = OptionGrammar.customize(op[:inputs])
-        end
+      def self.request_builder_for api_config, operation
+        JSONRequestBuilder.new(api_config[:target_prefix], operation)
       end
 
-      def define_client_method method_name, operation
-        add_client_request_method(method_name) do
-
-          configure_request do |request, options|
-
-            parser = self.class.option_grammars[method_name]
-            x_amz_target = self.class::TARGET_PREFIX + operation
-
-            request.headers["content-type"] = "application/x-amz-json-1.0"
-            request.headers["x-amz-target"] = x_amz_target
-            request.body = parser.to_json(options)
-
-          end
-
-          process_response do |response|
-            response_body = response.http_response.body
-            response_body = "{}" if response_body == ""
-            data = ::JSON.load(response_body)
-            MetaUtils.extend_method(response, :data) { data }
-          end
-
-          simulate_response do |response|
-            data = {}
-            MetaUtils.extend_method(response, :data) { data }
-          end
-
-        end
+      def self.response_parser_for api_config, operation
+        JSONResponseParser.new(operation[:outputs])
       end
 
-      module ErrorParser
-
-        def extract_error_details response
-          if
-            response.http_response.status >= 300 and
-            body = response.http_response.body and
-            json = (::JSON.load(body) rescue nil) and
-            type = json["__type"] and
-            matches = type.match(/\#(.*)$/)
-          then
-            code = matches[1]
-            if code == 'RequestEntityTooLarge'
-              message = 'Request body must be less than 1 MB'
-            else
-              message = json['message']
-            end
-            [code, message]
+      def extract_error_details response
+        if
+          response.http_response.status >= 300 and
+          body = response.http_response.body and
+          json = (::JSON.load(body) rescue nil) and
+          type = json["__type"] and
+          matches = type.match(/\#(.*)$/)
+        then
+          code = matches[1]
+          if code == 'RequestEntityTooLarge'
+            message = 'Request body must be less than 1 MB'
+          else
+            message = json['message']
           end
+          [code, message]
         end
-
       end
 
     end