aws-sdk 1.2.6 → 1.3.0

data/lib/aws/core.rb

@@ -20,6 +20,7 @@ require 'aws/core/autoloader'
 #
 # The currently supported services are:
 #
+# * {DynamoDB}
 # * {EC2}
 # * {ELB}
 # * {IAM}
@@ -57,7 +58,7 @@ require 'aws/core/autoloader'
 module AWS
 
   # Current version of the AWS SDK for Ruby
-  VERSION = "1.2.6"
+  VERSION = "1.3.0"
 
   register_autoloads(self) do
     autoload :Errors, 'errors'
@@ -78,6 +79,7 @@ module AWS
       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 :DefaultSigner,             'default_signer'
@@ -96,6 +98,7 @@ module AWS
       autoload :Response,                  'response'
       autoload :ResponseCache,             'response_cache'
       autoload :ServiceInterface,          'service_interface'
+      autoload :SessionSigner,             'session_signer'
       autoload :UriEscape,                 'uri_escape'
       autoload :XmlGrammar,                'xml_grammar'
     end
@@ -153,6 +156,12 @@ module AWS
     # @param [Hash] options
     # @option options [String] :access_key_id (nil) AWS access key id 
     #   credential.
+    # @option options [String] :dynamo_db_endpoint ('dynamodb.amazonaws.com') The 
+    #   service endpoint for Amazon DynamoDB.
+    # @option options [String] :dynamo_db_retry_throughput_errors (false) When
+    #   true, AWS::DynamoDB::Errors::ProvisionedThroughputExceededException
+    #   errors will be retried.  You may need to increase the maximum number
+    #   of retries if you have a low provisioned throughput.
     # @option options [String] :ec2_endpoint ('ec2.amazonaws.com') The 
     #   service endpoint for Amazon EC2.
     # @option options [Object] :http_handler (AWS::HTTPartyHandler) The 

data/lib/aws/core/client.rb

@@ -181,7 +181,7 @@ module AWS
             populate_error(response)
             retry_delays ||= sleep_durations(response)
             if should_retry?(response) and !retry_delays.empty?
-              response.rebuild_request
+              rebuild_http_request(response)
               @http_handler.sleep_with_callback(retry_delays.shift) do
                 async_request_with_retries(response, response.http_request, retry_delays)
               end
@@ -222,15 +222,19 @@ module AWS
         while should_retry?(response)
           break if sleeps.empty?
           Kernel.sleep(sleeps.shift)
-  
           # rebuild the request to get a fresh signature
-          response.rebuild_request
+          rebuild_http_request(response)
           response = yield
         end
   
         response
   
       end
+
+      private
+      def rebuild_http_request response
+        response.rebuild_request
+      end
   
       private
       def sleep_durations response
@@ -266,10 +270,8 @@ module AWS
         response.error = nil
         status = response.http_response.status
         code = nil
-        code = xml_error_grammar.parse(response.http_response.body).code if
-          xml_error_response?(response)
-        
-  
+        code = extract_error_code(response)
+
         case
         when response.timeout?
           response.error = Timeout::Error.new
@@ -290,12 +292,15 @@ module AWS
       end
   
       protected
-      def xml_error_response? response
-        response.http_response.status >= 300 and
-          response.http_response.body and
-          xml_error_grammar.parse(response.http_response.body).respond_to?(:code)
+      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
+        end
       end
-  
+
       protected
       def xml_error_grammar
         if service_module::const_defined?(:Errors) and

data/lib/aws/core/configuration.rb

@@ -273,9 +273,19 @@ module AWS
   
           accepted_options << name
   
-          define_method(name) do
-            value = supplied.has_key?(name) ? supplied[name] : default_value
+          define_method(name) do |&default_override|
+
+            value = 
+              if supplied.has_key?(name)
+                supplied[name]
+              elsif default_override
+                default_override.call
+              else
+                default_value
+              end
+
             transform ? transform.call(value) : value
+
           end
   
           alias_method("#{name}?", name) if options[:boolean]
@@ -339,7 +349,7 @@ module AWS
 
       add_option :access_key_id, 
         ENV['AWS_ACCESS_KEY_ID'] || ENV['AMAZON_ACCESS_KEY_ID']
-  
+
       add_option :http_handler, Core::Http::NetHttpHandler.new
   
       add_option :logger

data/lib/aws/core/configured_json_client_methods.rb

@@ -0,0 +1,71 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# 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
+
+    # @private
+    module ConfiguredJsonClientMethods
+
+      # @private
+      module ClassMethods
+
+        include ApiConfig
+
+        def configure_client
+
+          super
+
+          unless self::Options.include?(ConfiguredOptionGrammars)
+            self::Options.module_eval do
+              include(ConfiguredOptionGrammars)
+              define_configured_grammars
+            end
+          end
+
+          api_config[:operations].each do |name, customizations|
+            option_grammar = self::Options.operation_grammar(name)
+            target_prefix = self::TARGET_PREFIX
+            add_client_request_method(Inflection.ruby_name(name).to_sym) do
+              configure_request do |request, options|
+                request.headers["x-amz-target"] = target_prefix + name
+                request.body = option_grammar.to_json(options)
+              end
+
+              process_response do |response|
+                data = JSON.load(response.http_response.body)
+                MetaUtils.extend_method(response, :data) { data }
+              end
+
+              simulate_response do |response|
+                data = {}
+                MetaUtils.extend_method(response, :data) { data }
+              end
+            end
+          end
+
+        end
+
+      end
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+    end
+
+  end
+end
+

data/lib/aws/core/lazy_error_classes.rb

@@ -22,14 +22,16 @@ module AWS
   
         def const_missing(name)
           base_error_grammar = self::BASE_ERROR_GRAMMAR
+          mod = self::ERROR_MODULE
           const_missing_mutex.synchronize do
             return if const_defined?(name)
             const_set(name,
                       Class.new(self::Base) do
-                        include Errors::ModeledError
-  
+                        include mod::ModeledError
+
                         # so that MyService::Errors::Foo::Bar will work
                         const_set(:BASE_ERROR_GRAMMAR, base_error_grammar)
+                        const_set(:ERROR_MODULE, mod)
                         include LazyErrorClasses
                       end)
           end
@@ -51,6 +53,9 @@ module AWS
         unless mod.const_defined?(:BASE_ERROR_GRAMMAR)
           mod.const_set(:BASE_ERROR_GRAMMAR, XmlGrammar)
         end
+        unless mod.const_defined?(:ERROR_MODULE)
+          mod.const_set(:ERROR_MODULE, mod)
+        end
         mutex = Mutex.new
         MetaUtils.extend_method(mod, :const_missing_mutex) { mutex }
         mod.send(:include, Errors)

data/lib/aws/core/option_grammar.rb

@@ -12,6 +12,7 @@
 # language governing permissions and limitations under the License.
 
 require 'base64'
+require 'bigdecimal'
 
 module AWS
   module Core
@@ -219,7 +220,13 @@ module AWS
               return [Http::Request::Param.new(prefixed_name(prefix), "")] if params.empty?
               params
             end
-  
+
+            def hash_format(value)
+              value.map do |v|
+                member_option.hash_format(v)
+              end
+            end
+
             def join
               '.'
             end
@@ -284,6 +291,7 @@ module AWS
             MetaUtils.extend_method(option, :member_options) { options.values }
             by_ruby_name = options.values.inject({}) do |memo, member_option|
               memo[member_option.ruby_name] = member_option
+              memo[member_option.name] = member_option
               memo
             end
             MetaUtils.extend_method(option, :member_option) { |n| by_ruby_name[n] }
@@ -306,7 +314,8 @@ module AWS
               raise ArgumentError.new("missing required key #{option.ruby_name} for #{context}") if
                 option.required? and
                 !value.has_key?(option.ruby_name) and
-                !value.has_key?(option.ruby_name.to_sym)
+                !value.has_key?(option.ruby_name.to_sym) and
+                !value.has_key?(option.name)
             end
           end
   
@@ -316,7 +325,15 @@ module AWS
               member_option(name).request_params(value, prefixed_name(prefix))
             end.flatten
           end
-  
+
+          def hash_format(hash)
+            hash.inject({}) do |hash, (name, value)|
+              option = member_option(name.to_s)
+              hash[option.name] = option.hash_format(value)
+              hash
+            end
+          end
+
         end
 
         module Map
@@ -388,13 +405,20 @@ module AWS
             @_value_option ||= MapOption.new("value")
           end
 
-          class MapOption < DefaultOption
-            def param_name
-              @param_name || name  
-            end
-            def param_name= name
-              @param_name = name
-            end
+        end
+
+        module Bigdecimal
+
+          extend NoArgs
+
+          def validate(value, context = nil)
+            raise format_error("decimal value", context) unless
+              value.kind_of?(Numeric) or
+              value.respond_to?(:to_int)
+          end
+
+          def hash_format(value)
+            BigDecimal(value.to_s)
           end
 
         end
@@ -421,7 +445,11 @@ module AWS
         def request_params(value, prefix = nil)
           [Http::Request::Param.new(prefixed_name(prefix), encode_value(value))]
         end
-  
+
+        def hash_format(value)
+          value
+        end
+
         def prefixed_name(prefix)
           return "#{prefix}.#{name}" if prefix
           name
@@ -527,7 +555,8 @@ module AWS
               options.has_key?(option.ruby_name) || options.has_key?(option.ruby_name.to_sym)
           end
         end
-  
+
+        # Returns the options in AWS/Query format
         def request_params(options)
           validate(options)
           options.map do |(name, value)|
@@ -535,7 +564,23 @@ module AWS
             option(name).request_params(value)
           end.flatten
         end
-  
+
+        # Returns the options as a hash (which is used to generate JSON
+        # in to_json).
+        def to_h(options)
+          validate(options)
+          options.inject({}) do |hash, (name, value)|
+            option = self.option(name.to_s)
+            hash[option.name] = option.hash_format(value)
+            hash
+          end
+        end
+
+        # Returns the options in JSON format
+        def to_json(options)
+          to_h(options).to_json
+        end
+
         def included(m)
           m.extend(self::ModuleMethods)
         end
@@ -636,6 +681,15 @@ module AWS
         end
   
       end
+
+      class MapOption < DefaultOption
+        def param_name
+          @param_name || name  
+        end
+        def param_name= name
+          @param_name = name
+        end
+      end
   
       extend ModuleMethods
   

data/lib/aws/core/resource.rb

@@ -300,6 +300,7 @@ module AWS
   
           case
           when @options[:to_sym]  then value.tr('-','_').downcase.to_sym
+          when @options[:timestamp] then Time.at(value.to_i)
           when @output_translator then @output_translator.call(value)
           else value
           end
@@ -364,7 +365,14 @@ module AWS
             attr = @klass.attributes[attr_name]
             method = options[:get_as] || attr.get_as
   
-            v = resp_obj.respond_to?(method) ? resp_obj.send(method) : nil
+            v = case
+                when resp_obj.respond_to?(method)
+                  resp_obj.send(method)
+                when resp_obj.respond_to?(:key?) && resp_obj.key?(method)
+                  resp_obj[method]
+                else
+                  nil
+                end
             v = v.value if v and options[:value_wrapped]
             v = attr.translate_output_value(v)
   

data/lib/aws/core/session_signer.rb

@@ -0,0 +1,95 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws/sts'
+require 'thread'
+
+module AWS
+  module Core
+
+    # @private
+    class SessionSigner
+  
+      @create_mutex = Mutex.new
+  
+      def self.for config
+        @create_mutex.synchronize do
+          @session_signers ||= {}
+          @session_signers[config.signer.access_key_id] ||= self.new(config)
+        end
+      end
+  
+      def initialize config
+        @config = config
+        @session_mutex = Mutex.new
+      end
+  
+      def sign *args
+        short_term_signer.sign(*args)
+      end
+  
+      def access_key_id
+        session.credentials[:access_key_id]
+      end
+  
+      def secret_access_key
+        session.credentials[:secret_access_key]
+      end
+  
+      def session_token
+        session.credentials[:session_token]
+      end
+  
+      def refresh_session
+        sts = AWS::STS.new(:config => @config, :use_ssl => true)
+        @session_mutex.synchronize do
+          @session = sts.new_session
+        end
+      end
+
+      protected
+      def get_session
+        local_session = nil
+        @session_mutex.synchronize do
+          local_session =  @session
+        end
+        local_session
+      end
+  
+      protected
+      def session
+
+        session = get_session
+
+        if session.nil?
+          refresh_session 
+          session = get_session
+        end
+
+        if session.expires_at < (Time.now + 15 * 60)
+          refresh_session 
+          session = get_session
+        end
+
+        session
+
+      end
+  
+      protected
+      def short_term_signer
+        DefaultSigner.new(access_key_id, secret_access_key, session_token)
+      end
+  
+    end
+  end
+end