aws-sdk 1.4.1 → 1.5.0

data/lib/aws/cloud_formation/errors.rb

@@ -13,13 +13,9 @@
 
 module AWS
   class CloudFormation
-
-    # @private
     module Errors
 
-      BASE_ERROR_GRAMMAR = Client::XML::BaseError
-
-      include Core::LazyErrorClasses
+      extend Core::LazyErrorClasses
 
     end
   end

data/lib/aws/cloud_formation/request.rb

@@ -17,8 +17,7 @@ module AWS
     # @private
     class Request < Core::Http::Request
 
-      include Core::AuthorizeV4
-      include Core::AuthorizeWithSessionToken
+      include Core::Signature::Version4
 
       def service
         'cloudformation'

data/lib/aws/cloud_formation/stack.rb

@@ -99,7 +99,7 @@ module AWS
       describe_attribute :parameters do 
         translates_output do |params|
           params.inject({}) do |hash,param|
-            hash.merge(param.parameter_key => param.parameter_value)
+            hash.merge(param[:parameter_key] => param[:parameter_value])
           end
         end
       end
@@ -112,7 +112,7 @@ module AWS
 
       provider(:describe_stacks) do |provider|
         provider.find do |resp|
-          resp.stacks.find{|stack| stack.stack_name == name }
+          resp.data[:stacks].find{|stack| stack[:stack_name] == name }
         end
         provider.provides *describe_attributes.keys
       end
@@ -127,7 +127,8 @@ module AWS
       # @return [Array<StackOutput>]
       def outputs
         output_details.collect do |o|
-          StackOutput.new(self, o.output_key, o.output_value, o.description)
+          key, value, desc = o.values_at(:output_key, :output_value, :description)
+          StackOutput.new(self, key, value, desc)
         end
       end
 

data/lib/aws/cloud_formation/stack_collection.rb

@@ -188,12 +188,12 @@ module AWS
       protected
 
       def _each_item options = {}
-        client.describe_stacks.stacks.each do |summary|
+        client.describe_stacks.data[:stacks].each do |summary|
 
           stack = Stack.new_from(
             :describe_stacks, 
             summary, 
-            summary.stack_name, 
+            summary[:stack_name], 
             :config => config)
 
           yield(stack)

data/lib/aws/cloud_formation/stack_resource_collection.rb

@@ -23,7 +23,7 @@ module AWS
     # = Other Ways to Get Resource Details
     #
     # If you want to get a {StackResource} by its physical resource
-    # id, then you should use {CloudFormation#get_resource}.
+    # id, then you should use {CloudFormation#stack_resource}.
     #
     # You can also take a look at {Stack#resource_summaries} for
     # light-weight hashes of stack resource details.

data/lib/aws/cloud_formation/stack_resource_summary_collection.rb

@@ -38,7 +38,7 @@ module AWS
       include Core::Collection::Simple
 
       # @param [Stack] stack
-      # @param [Hash[ options
+      # @param [Hash] options
       def initialize stack, options = {}
         @stack = stack
         super
@@ -62,7 +62,7 @@ module AWS
             yield(summary.to_hash)
           end
 
-          next_token = resp.next_token if resp.respond_to?(:next_token)
+          next_token = resp.data[:next_token]
 
         end while next_token
       end

data/lib/aws/cloud_formation/stack_summary_collection.rb

@@ -117,7 +117,7 @@ module AWS
             yield(summary.to_hash)
           end
 
-          next_token = resp.next_token if resp.respond_to?(:next_token)
+          next_token = resp.data[:next_token]
 
         end while next_token
       end

data/lib/aws/core.rb

@@ -61,7 +61,7 @@ require 'aws/core/autoloader'
 module AWS
 
   # Current version of the AWS SDK for Ruby
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 
   register_autoloads(self) do
     autoload :Errors, 'errors'
@@ -70,26 +70,15 @@ module AWS
   module Core
 
     AWS.register_autoloads(self) do
-      autoload :ApiConfig,                 'api_config'
       autoload :AsyncHandle,               'async_handle'
-      autoload :AuthorizeV2,               'authorize_v2'
-      autoload :AuthorizeV3,               'authorize_v3'
-      autoload :AuthorizeV4,               'authorize_v4'
-      autoload :AuthorizeWithSessionToken, 'authorize_with_session_token'
       autoload :Cacheable,                 'cacheable'
       autoload :Client,                    'client'
       autoload :Collection,                'collection'
       autoload :Configuration,             'configuration'
-      autoload :ConfiguredClientMethods,   'configured_client_methods'
-      autoload :ConfiguredGrammars,        'configured_grammars'
-      autoload :ConfiguredJsonClientMethods, 'configured_json_client_methods'
-      autoload :ConfiguredOptionGrammars,  'configured_option_grammars'
-      autoload :ConfiguredXmlGrammars,     'configured_xml_grammars'
+      autoload :Data,                      'data'
       autoload :DefaultSigner,             'default_signer'
-      autoload :IgnoreResultElement,       'ignore_result_element'
       autoload :IndifferentHash,           'indifferent_hash'
       autoload :Inflection,                'inflection'
-      autoload :JsonClient,                'json_client'
       autoload :LazyErrorClasses,          'lazy_error_classes'
       autoload :LogFormatter,              'log_formatter'
       autoload :MetaUtils,                 'meta_utils'
@@ -105,7 +94,33 @@ module AWS
       autoload :ServiceInterface,          'service_interface'
       autoload :SessionSigner,             'session_signer'
       autoload :UriEscape,                 'uri_escape'
-      autoload :XmlGrammar,                'xml_grammar'
+    end
+
+    module Signature
+      AWS.register_autoloads(self) do
+        autoload :Version2,     'version_2'
+        autoload :Version3,     'version_3'
+        autoload :Version4,     'version_4'
+      end
+    end
+    
+    module XML
+      AWS.register_autoloads(self) do
+        autoload :Parser,     'parser'
+        autoload :Grammar,    'grammar'
+        autoload :Stub,       'stub'
+        autoload :Frame,      'frame'
+        autoload :RootFrame,  'root_frame'
+        autoload :FrameStack, 'frame_stack'
+      end
+
+      module SaxHandlers
+        AWS.register_autoloads(self, 'aws/core/xml/sax_handlers') do
+          autoload :Nokogiri, 'nokogiri'
+          autoload :REXML,    'rexml'
+        end
+      end
+
     end
 
     module Http

data/lib/aws/core/async_handle.rb

@@ -16,7 +16,6 @@ module AWS
   
     # Mixin that provides a generic callback facility for asynchronous
     # tasks that can either succeed or fail.
-    # @private
     module AsyncHandle
   
       # Called to signal success and fire off the success and complete callbacks.
@@ -36,11 +35,11 @@ module AWS
       #
       # If this is called when the task has already completed
       # successfully, it will call the callback immediately.
-      def on_success(&blk)
+      def on_success(&block)
         if @_async_status == :success
-          blk.call
+          block.call
         else
-          (@_async_callbacks ||= []) << { :success => blk }
+          (@_async_callbacks ||= []) << { :success => block }
         end
       end
   
@@ -50,11 +49,11 @@ module AWS
       #
       # If this is called when the task has already failed, it will
       # call the callback immediately.
-      def on_failure(&blk)
+      def on_failure(&block)
         if @_async_status == :failure
-          blk.call
+          block.call
         else
-          (@_async_callbacks ||= []) << { :failure => blk }
+          (@_async_callbacks ||= []) << { :failure => block }
         end
       end
   
@@ -67,13 +66,13 @@ module AWS
       #
       # If this is called when the task has already completed, it will
       # call the callback immediately.
-      def on_complete(&blk)
+      def on_complete(&block)
         if !@_async_status.nil?
-          blk.call(@_async_status)
+          block.call(@_async_status)
         else
           (@_async_callbacks ||= []) << {
-            :failure => lambda { blk.call(:failure) },
-            :success => lambda { blk.call(:success) }
+            :failure => lambda { block.call(:failure) },
+            :success => lambda { block.call(:success) }
           }
         end
       end
@@ -83,7 +82,7 @@ module AWS
         @_async_status = kind
         @_async_callbacks.map do |cb|
           cb[kind]
-        end.compact.each { |blk| blk.call } if @_async_callbacks
+        end.compact.each {|block| block.call } if @_async_callbacks
       end
   
     end

data/lib/aws/core/client.rb

@@ -12,17 +12,19 @@
 # language governing permissions and limitations under the License.
 
 require 'set'
+require 'aws/core/client/query_xml'
+require 'aws/core/client/query_json'
 
 module AWS
   module Core
     
-    # Base class for all of the Amazon AWS service clients.
-    # @private
+    # Base client class for all of the Amazon AWS service clients.
     class Client
   
       extend Naming
   
-      CACHEABLE_REQUESTS = Set.new
+      # @private
+      CACHEABLE_REQUESTS = Set[]
   
       # Creates a new low-level client.
       #
@@ -82,18 +84,27 @@ module AWS
       # @return [DefaultSigner,Object] Returns the signer for this client.
       #   This is normally a DefaultSigner, but it can be configured to
       #   an other object.
+      # @private
       attr_reader :signer
 
       # @return [String] The snake-cased ruby name for the service
       #   (e.g. 's3', 'iam', 'dynamo_db', etc).
+      # @private
       attr_reader :service_ruby_name
 
       # @return [Integer] What port this client makes requests via.
+      # @private
       attr_reader :port
 
       # @return [String] Returns the service endpoint (hostname) this client
       #   makes requests against.
+      # @private
       attr_reader :endpoint
+
+      # @return (see Client.operations)
+      def operations
+        self.class.operations
+      end
   
       # Returns a copy of the client with a different HTTP handler.
       # You can pass an object like BuiltinHttpHandler or you can
@@ -126,7 +137,7 @@ module AWS
         with_config(config.with(options))
       end
   
-      # @param [Configuration] The configuration object to use.
+      # @param [Configuration] config The configuration object to use.
       # @return [Core::Client] Returns a new client object with the given
       #   configuration.
       def with_config config
@@ -155,21 +166,15 @@ module AWS
       end
   
       protected
+
       def new_request
-        req = self.class::REQUEST_CLASS.new
-        req.http_method = 'POST'
-        req.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
-        req.add_param 'Timestamp', Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
-        req.add_param 'Version', self.class::API_VERSION
-        req
+        eval(self.class.name.sub(/::Client$/, ''))::Request.new
       end
   
-      protected
       def new_response(*args, &block)
         Response.new(*args, &block)
       end
   
-      private
       def make_async_request response
   
         pauses = async_request_with_retries(response, response.http_request)
@@ -178,7 +183,6 @@ module AWS
   
       end
   
-      private
       def async_request_with_retries response, http_request, retry_delays = nil
   
         response.http_response = Http::Response.new
@@ -210,7 +214,6 @@ module AWS
   
       end
   
-      private
       def make_sync_request response
         retry_server_errors do
   
@@ -218,8 +221,6 @@ module AWS
             Http::Response.new
   
           @http_handler.handle(response.http_request, http_response)
-  
-          populate_error(response)
 
           populate_error(response)
           response.signal_success unless response.error
@@ -228,7 +229,6 @@ module AWS
         end
       end
   
-      private
       def retry_server_errors &block
   
         response = yield
@@ -246,31 +246,26 @@ module AWS
   
       end
 
-      private
       def rebuild_http_request response
         response.rebuild_request
         response.retry_count += 1
       end
   
-      private
       def sleep_durations response
         factor = scaling_factor(response)
         Array.new(config.max_retries) {|n| (2 ** n) * factor }
       end
   
-      private
       def scaling_factor response
         response.throttled? ? (0.5 + Kernel.rand * 0.1) : 0.3
       end
   
-      private
       def should_retry? response
         response.timeout? or
           response.throttled? or
           response.error.kind_of?(Errors::ServerError)
       end
   
-      private
       def return_or_raise options, &block
         response = yield
         unless options[:async]
@@ -279,85 +274,99 @@ module AWS
         response
       end
 
-      private
-      def log_client_request options
+      # Yields to the given block (which should be making a 
+      # request and returning a {Response} object).  The results of the 
+      # request/response are logged.
+      # 
+      # @param [Hash] options
+      # @option options [Boolean] :async
+      # @return [Response]
+      def log_client_request options, &block
 
         # time the request, retries and all
         start = Time.now
         response = yield
         response.duration = Time.now - start
 
-        if config.logger
-          if options[:async] 
-            response.on_complete { log_response(response) } 
-          else
-            log_response(response)
-          end
+        if options[:async] 
+          response.on_complete { log_response(response) } 
+        else
+          log_response(response)
         end
   
         response
 
       end
 
+      # Logs the response to the configured logger.
+      # @param [Resposne] response
+      # @return [nil]
       def log_response response
-        message = config.log_formatter.format(response)
-        config.logger.send(config.log_level, message)
+        if config.logger
+          message = config.log_formatter.format(response)
+          config.logger.send(config.log_level, message)
+        end
+        nil
       end
   
-      protected
       def populate_error response
-  
-        # clear out a previous error
-        response.error = nil
+        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
-        code = nil
-        code = extract_error_code(response)
+
+        error_code, error_message = extract_error_details(response)
+
+        error_args = [
+          response.http_request,
+          response.http_response,
+          error_code,
+          error_message
+        ]
 
         case
-        when response.timeout?
-          response.error = Timeout::Error.new
-  
-        when code
-          response.error =
-            service_module::Errors.error_class(code).new(response.http_request,
-                                                         response.http_response)
-        when status >= 500
-          response.error =
-            Errors::ServerError.new(response.http_request, response.http_response)
-  
-        when status >= 300
-          response.error =
-            Errors::ClientError.new(response.http_request, response.http_response)
-        end
-  
-      end
-  
-      protected
-      def extract_error_code response
-        if response.http_response.status >= 300 and
-            body = response.http_response.body and
-            parse = xml_error_grammar.parse(body) and
-            parse.respond_to?(:code)
-          parse.code
+        when response.timeout? then TimeoutError.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
 
-      protected
-      def xml_error_grammar
-        if service_module::const_defined?(:Errors) and
-            service_module::Errors::const_defined?(:BASE_ERROR_GRAMMAR)
-          service_module::Errors::BASE_ERROR_GRAMMAR
-        else
-          XmlGrammar
-        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
+      #
+      # @param [String] error_code The error code string as returned by
+      #   the service.  If this class contains periods, they will be 
+      #   converted into namespaces (e.g. 'Foo.Bar' becomes Errors::Foo::Bar).
+      #
+      # @return [Class]
+      #
+      def error_class error_code
+        errors_module.error_class(error_code)
       end
-  
-      protected
-      def service_module
-        AWS.const_get(self.class.to_s[/(\w+)::Client/, 1])
+
+      # Returns the ::Errors module for the current client.
+      #
+      #   AWS::S3::Client.new.errors_module
+      #   #=> AWS::S3::Errors
+      #
+      # @return [Module]
+      #
+      def errors_module
+        AWS.const_get(self.class.to_s[/(\w+)::Client/, 1])::Errors
       end
   
-      private
       def client_request name, options, &block
         return_or_raise(options) do
           log_client_request(options) do
@@ -407,13 +416,12 @@ module AWS
         end
       end
 
-      private
       def cacheable_request? name, options
         self.class::CACHEABLE_REQUESTS.include?(name)
       end
   
-      private
       def build_request(name, options, &block)
+
         # we dont want to pass the async option to the configure block
         opts = options.dup
         opts.delete(:async)
@@ -432,12 +440,14 @@ module AWS
         http_request.ssl_ca_path = config.ssl_ca_path if config.ssl_ca_path
   
         send("configure_#{name}_request", http_request, opts, &block)
+
         http_request.headers["user-agent"] = user_agent_string
         http_request.add_authorization!(signer)
+
         http_request
+
       end
   
-      private
       def user_agent_string
         engine = (RUBY_ENGINE rescue nil or "ruby")
         user_agent = "%s aws-sdk-ruby/#{VERSION} %s/%s %s" %
@@ -449,24 +459,18 @@ module AWS
         user_agent
       end
   
-      private
+      # 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
+
+        self.operations << method_name
   
-        method = ClientRequestMethodBuilder.new(self, method_name, &block)
-  
-        if xml_grammar = options[:xml_grammar]
-  
-          method.process_response do |resp|
-            xml_grammar.parse(resp.http_response.body, :context => resp)
-            super(resp)
-          end
-  
-          method.simulate_response do |resp|
-            xml_grammar.simulate(resp)
-            super(resp)
-          end
-  
-        end
+        ClientRequestMethodBuilder.new(self, method_name, &block)
   
         module_eval <<-END
           def #{method_name}(*args, &block)
@@ -476,13 +480,19 @@ module AWS
         END
   
       end
-  
-      protected
-      def self.configure_client
-  
-        module_eval('module Options; end')
-        module_eval('module XML; end')
-  
+
+      # 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
+        path = "lib/aws/api_config/#{service_name}-#{self::API_VERSION}.yml"
+        YAML.load(File.read(path))
+      end
+
+      # @return [Array<Symbol>] Returns a list of service operations as
+      #   method names supported by this client.
+      def self.operations
+        @operations ||= []
       end
   
       # @private