aws-sdk 1.0.4 → 1.1.0

data/lib/aws/base_client.rb

@@ -396,7 +396,7 @@ module AWS
     private
     def user_agent_string
       engine = (RUBY_ENGINE rescue nil or "ruby")
-      user_agent = "%s aws-sdk-ruby/1.0 %s/%s %s" %
+      user_agent = "%s aws-sdk-ruby/#{VERSION} %s/%s %s" %
         [config.user_agent_prefix, engine, RUBY_VERSION, RUBY_PLATFORM]
       user_agent.strip!
       if AWS.memoizing?

data/lib/aws/cacheable.rb

@@ -12,78 +12,66 @@
 # language governing permissions and limitations under the License.
 
 require 'aws/naming'
-require 'aws/meta_utils'
 
 module AWS
 
   # @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
-      endpoint_method = self.class.service_ruby_name + "_endpoint"
-      config.signer.access_key_id + ":" +
-        config.send(endpoint_method) + ":" +
-        local_cache_key
-    end
-
-    def attributes_from_response(response)
-      method = "populate_from_#{response.request_type}"
-      if respond_to?(method)
-        send(method, response)
+      @cache_key ||= begin
+        endpoint_method = self.class.service_ruby_name + "_endpoint"
+        config.signer.access_key_id + ":" +
+          config.send(endpoint_method) + ":" +
+          self.class.name + ":" +
+          local_cache_key
       end
     end
 
-    def request_types
-      self.class.request_types
-    end
-
-    class NoData < StandardError; end
+    # @private
+    public
+    def retrieve_attribute attr, &block
 
-    def retrieve_attribute(attribute)
       if cache = AWS.response_cache
-        if cache.resource_cache.cached?(cache_key, attribute)
-          return cache.resource_cache.get(cache_key, attribute)
+
+        if cache.resource_cache.cached?(cache_key, attr.name)
+          return cache.resource_cache.get(cache_key, attr.name)
         end
-        cache.select(*request_types).each do |resp|
-          if attributes = attributes_from_response(resp)
+
+        cache.select(*attr.request_types).each do |response|
+          if attributes = attributes_from_response(response)
             cache.resource_cache.store(cache_key, attributes)
-            return attributes[attribute] if attributes.key?(attribute)
+            return attributes[attr.name] if attributes.key?(attr.name)
           end
         end
+
       end
-      resp = yield
-      if attributes = attributes_from_response(resp)
+
+      response = yield
+
+      if attributes = attributes_from_response(response)
         if cache = AWS.response_cache
           cache.resource_cache.store(cache_key, attributes)
         end
-        attributes[attribute] if attributes.key?(attribute)
+        attributes[attr.name] if attributes.key?(attr.name)
       else
-        raise NoData.new("no data for #{self} in response to #{resp.request_type}")
-      end
-    end
-
-    module ClassMethods
-
-      def request_types
-        []
+        raise NoData.new("no data in #{response.request_type} response")
       end
-
-      def populate_from(type, &block)
-        define_method("populate_from_#{type}", &block)
-        new_request_types = request_types + [type]
-        new_request_types.uniq!
-        MetaUtils.extend_method(self, :request_types) { new_request_types }
-      end
-
-    end
-
-    def self.included mod
-      mod.extend ClassMethods
-      mod.extend Naming unless mod.respond_to?(:service_ruby_name)
     end
 
   end

data/lib/aws/client_logging.rb

@@ -50,7 +50,7 @@ module AWS
       status = response.http_response.status
       service = self.class.service_name
 
-      pattern = "[AWS %s %s %.06f] %s %s"
+      pattern = "[AWS %s %s %.06f] %s(%s)"
       parts = [service, status, time.real, method_name, sanitize_options(options)]
       severity = :info
 
@@ -72,7 +72,7 @@ module AWS
     def sanitize_value(value)
       case value
       when Hash
-        sanitize_hash(value)
+        '{' + sanitize_hash(value) + '}'
       when Array
         sanitize_array(value)
       when File
@@ -85,31 +85,36 @@ module AWS
     end
 
     protected
-    def sanitize_string(str)
-      if str.size > MAX_STRING_LENGTH
-        "#<String \"#{str[0,6]}\" ... \"#{str[-6,6]}\" (#{str.size} characters)>"
+    def sanitize_string str
+      summary = summarize_string(str)
+      inspected = str.inspect
+      if inspected.size > summary.size
+        summary
       else
-        str.inspect
+        inspected
       end
     end
 
     protected
-    def sanitize_file(file)
+    def summarize_string str
+      "#<String #{str[0,6].inspect} ... #{str[-6,6].inspect} (#{str.size} characters)>"
+    end
+
+    protected
+    def sanitize_file file
       "#<File:#{file.path} (#{File.size(file.path)} bytes)>"
     end
 
     protected
-    def sanitize_array(ary)
-      "[" +
-        ary.map { |v| sanitize_value(v) }.join(",") +
-        "]"
+    def sanitize_array array
+      "[" + array.map { |v| sanitize_value(v) }.join(",") + "]"
     end
 
     protected
-    def sanitize_hash(hash)
-      "{" + hash.map do |k,v|
+    def sanitize_hash hash
+      hash.map do |k,v|
         "#{sanitize_value(k)}=>#{sanitize_value(v)}"
-      end.sort.join(",") + "}"
+      end.sort.join(",")
     end
 
   end

data/lib/aws/collections.rb

@@ -0,0 +1,230 @@
+# Copyright 2011 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/model'
+
+module AWS
+
+  
+  # There are 3 collection modules:
+  #
+  # AWS::Collections::Basic 
+  #   - single request returns all items
+  #   - (sqs, ec2, ses)
+  #
+  # AWS::Collections::Paged
+  #   - responses may be truncated
+  #   - truncated responses return a "next token"
+  #   - (sns, sdb)
+  #
+  # AWS::Collections::PagedWithLimits
+  #   - requests accept a "max items"
+  #   - responses may be "truncated" 
+  #   - truncated responses return a "next token"
+  #   - (s3, iam)
+  #
+  # @private
+  module Collections
+  
+    # @private
+    module Basic
+  
+      include Model
+      include Enumerable
+
+      def enumerator options = {}
+        Enumerator.new(self, :each, options) 
+      end
+  
+      def each options = {}, &block
+        each_batch(options) do |batch|
+          batch.each(&block)
+        end
+        nil
+      end
+
+      def each_batch options = {}, &block
+
+        options = options.dup
+
+        limit = options.delete(:limit)
+        batch_size = options.delete(:batch_size)
+
+        total = 0  # count of items yeileded across all batches
+
+        each_response(options, limit, batch_size) do |response|
+
+          batch = []
+          each_item(response) do |item|
+            batch << item
+            if limit and (total += 1) == limit
+              yield(batch)
+              return
+            end
+          end
+
+          yield(batch)
+
+          batch.size
+
+        end
+
+        nil
+
+      end
+
+      def in_groups_of size, options = {}, &block
+
+        group = []
+
+        each_batch(options) do |batch|
+          batch.each do |item|
+            group << item
+            if group.size == size
+              yield(group)
+              group = []
+            end
+          end
+        end
+
+        yield(group) unless group.empty?
+
+        nil
+
+      end
+
+      # @note +limit+ has no effect, simply ignored
+      # @note +batch_size+ has no effect, simply ignored
+      # @private
+      protected
+      def each_response options, limit, batch_size, &block
+        response = client.send(request_method, options)
+        yield(response)
+      end
+
+      # @note Define this method in classes including this module.
+      # @private
+      protected
+      def request_method
+        raise NotImplementedError
+      end
+
+      # @note Define this method in classes including this module.
+      # @private
+      protected
+      def each_item response
+        raise NotImplementedError
+      end
+  
+    end
+  
+    # @private
+    module Paged
+  
+      include Basic
+
+      # @note +limit+ has no effect, simply ignored
+      # @note +batch_size+ has no effect, simply ignored
+      protected
+      def each_response options, limit, batch_size, &block
+
+        next_token = nil
+
+        begin
+  
+          page_opts = {}
+          page_opts[next_token_key] = next_token if next_token
+  
+          response = client.send(request_method, options.merge(page_opts))
+  
+          yield(response)
+  
+          next_token = next_token_for(response)
+  
+        end until next_token.nil?
+  
+      end
+  
+      # Override this methid in collections that use a different name
+      # for the param that offsets the find (e.g. :marker, :next_key, etc).
+      # @private
+      protected
+      def next_token_key
+        raise NotImplementedError
+      end
+  
+      # Override this method in collections that have an alternate method
+      # for finding the next token.  
+      # @private
+      protected
+      def next_token_for response
+        method = next_token_key
+        response.respond_to?(method) ? response.send(method) : nil
+      end
+  
+    end
+  
+    # @private
+    module PagedWithLimits
+  
+      include Paged
+
+      # A custom first method makes getting exactly one item much more 
+      # efficient.  Without the :limit => 1, an entire page of items 
+      # is received and then only one is grabbed.
+      # @private
+      def first
+        enumerator(:limit => 1).first  
+      end
+
+      # @private
+      protected
+      def each_response options, limit, batch_size, &block
+  
+        total = 0
+        next_token = nil
+
+        begin
+  
+          page_opts = {}
+
+          page_opts[next_token_key] = next_token if next_token
+
+          if limit or batch_size
+            max_items = []
+            max_items << (limit - total) if limit
+            max_items << batch_size if batch_size
+            page_opts[limit_key] = max_items.min
+          end
+  
+          response = client.send(request_method, options.merge(page_opts))
+  
+          total += yield(response)
+  
+          next_token = next_token_for(response)
+  
+        end until next_token.nil? or (limit and limit == total)
+  
+      end
+
+      # Override this methid in collections that use a different name
+      # for the param that offsets the find (e.g. :marker, :next_key, etc).
+      # @private
+      protected
+      def limit_key
+        raise NotImplementedError
+      end
+  
+    end
+
+  end
+end

data/lib/aws/common.rb

@@ -17,6 +17,10 @@ require 'aws/response_cache'
 
 # Root namespace for the AWS SDK for Ruby.
 module AWS
+
+  # Current version of the AWS SDK for Ruby
+  VERSION = "1.1.0"
+
   class << self
 
     # @private

data/lib/aws/configuration.rb

@@ -72,6 +72,7 @@ module AWS
         :ec2_endpoint => 'ec2.amazonaws.com',
         :http_handler => Http::HTTPartyHandler.new,
         :max_retries => 3,
+        :iam_endpoint => 'iam.amazonaws.com',
         :s3_endpoint => 's3.amazonaws.com',
         :s3_multipart_threshold => 16 * 1024 * 1024,
         :s3_multipart_min_part_size => 5 * 1024 * 1024,
@@ -163,6 +164,12 @@ module AWS
       @options[:max_retries]
     end
 
+    # @return [String] The service endpoint for AWS Idenity Access 
+    #   Management (IAM).
+    def iam_endpoint
+      @options[:iam_endpoint]
+    end
+
     # @return [String] The service endpoint for Amazon S3.
     def s3_endpoint
       @options[:s3_endpoint]