aws-sdk 1.5.6 → 1.5.7

data/lib/aws/cloud_watch/metric_statistics.rb

@@ -0,0 +1,69 @@
+# 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.
+
+module AWS
+  class CloudWatch
+
+    # Statistics for a metric.
+    #
+    # This class is an enumerable collection of data points.
+    #
+    # == Enumerating Statistics
+    #
+    #   metric = CloudWatch::Metric.new('my/namepace', 'metric-name')
+    #
+    #   stats = metric.statistics(
+    #     :start_time => Time.now - 3600,
+    #     :end_time => Time.now,
+    #     :statistics => ['Average'])
+    #
+    #   stats.label #=> 'some-label'
+    #   stats.each do |datapoint|
+    #     # datapoint is a hash
+    #   end
+    #
+    # @see Core::Collection
+    # 
+    class MetricStatistics
+
+      include Core::Collection::Simple
+
+      # @param [Metric] metric
+      # @param [String] label
+      # @param [Array<Hash>] datapoints
+      def initialize metric, label, datapoints
+        @metric = metric
+        @label = label
+        @datapoints = datapoints
+      end
+
+      # @return [Metric]
+      attr_reader :metric
+
+      # @return [String]
+      attr_reader :label
+
+      # @return [Array<Hash>]
+      attr_reader :datapoints
+
+      protected
+
+      def _each_item options = {}
+        datapoints.each do |point|
+          yield(point)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/cloud_watch/request.rb

@@ -0,0 +1,23 @@
+# 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.
+
+module AWS
+  class CloudWatch
+
+    # @private
+    class Request < Core::Http::Request
+      include Core::Signature::Version2
+    end
+
+  end
+end

data/lib/aws/core.rb

@@ -66,7 +66,7 @@ require 'aws/core/autoloader'
 module AWS
 
   # Current version of the AWS SDK for Ruby
-  VERSION = "1.5.6"
+  VERSION = "1.5.7"
 
   register_autoloads(self) do
     autoload :Errors, 'errors'

data/lib/aws/core/client.rb

@@ -11,10 +11,10 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-require 'set'
 require 'aws/core/client/query_xml'
 require 'aws/core/client/query_json'
-require 'json'
+require 'set'
+require 'yaml'
 
 module AWS
   module Core

data/lib/aws/core/client/query_json.rb

@@ -11,6 +11,8 @@
 # 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
     class Client

data/lib/aws/core/collection.rb

@@ -13,28 +13,13 @@
 module AWS
   module Core
 
-    # = Different Collection Types in AWS
-    #
-    # The Collection module acts as a namespace and base implementation for
-    # the primary collection types in AWS:
-    #
-    # * {AWS::Core::Collection::Simple}
-    # * {AWS::Core::Collection::Limitable}
-    #
-    # Each AWS service allows provides a method to enumerate resources.
-    #
-    # * Services that return all results in a single response use
-    #   {AWS::Core::Collection::Simple}.
-    #
-    # * Services that truncate large results sets *AND* allow you to provide
-    #   a perfered maximum number of results use 
-    #   {AWS::Core::Collection::Limitable}.
-    #
+    # Provides useful methods for enumerating items in a collection.
     module Collection
 
       AWS.register_autoloads(self) do
-        autoload :Simple,    'simple'
-        autoload :Limitable, 'limitable'
+        autoload :Simple, 'simple'
+        autoload :WithNextToken, 'with_next_token'
+        autoload :WithLimitAndNextToken, 'with_limit_and_next_token'
       end
 
       include Enumerable
@@ -89,16 +74,12 @@ module AWS
       # a single collection.  Each batch represents all of the items returned
       # in a single resopnse.
       #
-      # @note If you require fixed size batches, see {#in_groups_of}.
-      #
+      # @note If you require fixed batch sizes, see {#in_groups_of}.
       # @param (see #each)
-      #
       # @option (see #each)
-      #
       # @return (see #each)
-      #
       def each_batch options = {}, &block
-        raise NotImplementedError
+        _each_batch(options.dup, &block)
       end
 
       # Use this method when you want to call a method provided by 
@@ -228,7 +209,59 @@ module AWS
         Core::PageResult.new(self, items, per_page, next_token)
 
       end
+
+      protected
+
+      def _each_batch options, &block
+        # should be defined in the collection modules
+        raise NotImplementedError
+      end
+
+      def _each_item next_token, options = {}, &block
+        # should be defined in classes included the collection modules
+        raise NotImplementedError
+      end
+
+      def _extract_next_token options
+        next_token = options.delete(:next_token)
+        next_token = nil if next_token == ''
+        next_token
+      end
+
+      def _extract_batch_size options
+        batch_size = options.delete(:batch_size)
+        batch_size = nil if batch_size == ''
+        batch_size = batch_size.to_i if batch_size
+        batch_size
+      end
+
+      def _extract_limit options
+        limit = options.delete(:limit) || _limit
+        limit = nil if limit == ''
+        limit = limit.to_i if limit
+        limit
+      end
   
+      # Override this method in collection classes that provide
+      # an alternative way to provide the limit than passinging
+      # it to the enumerable method as :limit.
+      #
+      # An example of when this would be useful:
+      #
+      #   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 5 wins out
+      #   collection.limit(10).each(:limit => 5) {|item| ... }
+      #
+      def _limit
+        nil
+      end
+
     end
   end
 end

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

@@ -15,7 +15,7 @@ module AWS
   module Core
     module Collection
 
-      # AWS::Core::Collection::Simple is used by collections that always 
+      # AWS::Core::Collection::Simple is used by collections that always
       # recieve every matching items in a single response.
       #
       # This means:
@@ -25,7 +25,7 @@ module AWS
       # * Next tokens are artificial (guessable numeric offsets)
       #
       # AWS services generally return all items only for requests with a
-      # small maximum number of results.  
+      # small maximum number of results.
       #
       # See {AWS::Core::Collection} for documentation on the available
       # collection methods.
@@ -35,37 +35,36 @@ module AWS
         include Enumerable
         include Collection
 
-        # (see AWS::Core::Collection#each_batch)
-        def each_batch options = {}, &block
+        protected
+
+        def _each_batch options = {}, &block
 
-          each_opts  = options.dup
-          limit      = each_opts.delete(:limit)
-          limit      = limit.to_i if limit
-          next_token = each_opts.delete(:next_token)
-          offset     = next_token ? next_token.to_i - 1 : 0
-          total      = 0
+          limit = _extract_limit(options)
+          next_token = _extract_next_token(options)
+          offset = next_token ? next_token.to_i - 1 : 0
 
-          nil_or_next_token = nil
+          total = 0
+          skipped = 0
+          simulated_next_token = nil
 
           batch = []
-          _each_item(each_opts.dup) do |item|
+          _each_item(options.dup) do |item|
 
             total += 1
 
             # skip until we reach our offset (derived from the "next token")
-            next if total <= offset
+            if skipped < offset
+              skipped += 1
+              next
+            end
 
             if limit
-
               if batch.size < limit
                 batch << item
               else
-                # allow _each_item to yield one more item than needed
-                # so we can determine if we should return a "next token"
-                nil_or_next_token = total
+                simulated_next_token = total
                 break
               end
-
             else
               batch << item
             end
@@ -74,17 +73,10 @@ module AWS
 
           yield(batch)
 
-          nil_or_next_token
+          simulated_next_token
 
         end
-
-        protected
-        def _each_item options = {}, &block
-          raise NotImplementedError
-        end
-
       end
-
     end
   end
 end

data/lib/aws/core/collection/with_limit_and_next_token.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.
+
+module AWS
+  module Core
+    module Collection
+      
+      # = Collection::WithLimitAndNextToken
+      #
+      # This module is used by collections where the service may truncate
+      # responses but that also accept a upper limit of results to 
+      # return in a single request.
+      #
+      # See {AWS::Core::Collection} for documentation on the available
+      # methods.
+      #
+      module WithLimitAndNextToken
+
+        include Model
+        include Collection
+        include Enumerable
+
+        protected
+
+        def _each_batch options = {}, &block
+
+          limit = _extract_limit(options)
+          batch_size = _extract_batch_size(options)
+          next_token = _extract_next_token(options)
+
+          total = 0  # count of items yeilded across all batches
+
+          begin
+
+            max = nil
+            if limit or batch_size
+              max = []
+              max << (limit - total) if limit
+              max << batch_size if batch_size
+              max = max.min
+            end
+
+            batch = []
+            next_token = _each_item(next_token, max, options.dup) do |item|
+
+              total += 1
+              batch << item
+
+            end
+
+            yield(batch)
+
+          end until next_token.nil? or (limit and limit == total)
+
+          next_token
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# 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.
+
+module AWS
+  module Core
+    module Collection
+
+      # = Collection::WithNextToken
+      #
+      # When making a request to list elements from one of these
+      # collections, the response may return a next token.  This indicates
+      # there are more results than were returned.  You can not control
+      # the number of elements returned with each response.
+      #
+      # See {AWS::Core::Collection} for documentation on the available
+      # collection methods.
+      #
+      module WithNextToken
+
+        include Model
+        include Enumerable
+        include Collection
+
+        protected
+
+        def _each_batch options = {}, &block
+
+          limit = _extract_limit(options)
+
+          next_token, skip_count = _extract_next_token(options)
+
+          skipped = 0
+          collected = 0
+
+          begin
+
+            offset = 0
+            batch = []
+
+            next_token = _each_item(next_token, options.dup) do |item|
+
+              if skipped < skip_count
+                skipped += 1
+                next
+              end
+
+              if limit
+                if collected < limit
+                  batch << item
+                  collected += 1
+                else
+                  yield(batch)
+                  simulated_next_token = {}
+                  simulated_next_token[:token] = next_token if next_token
+                  simulated_next_token[:offset] = offset + skipped
+                  return simulated_next_token
+                end
+              else
+                batch << item
+                collected += 1
+              end
+
+              offset += 1
+
+            end # _each_item
+
+            yield(batch)
+
+          end until next_token.nil? or (limit and limit == collected)
+
+          next_token.nil? ? nil : { :token => next_token }
+
+        end
+
+        def _extract_next_token options
+          next_token = super
+          case next_token
+          when nil   then [nil, 0]
+          when Hash  then [next_token[:token], next_token[:offset] || 0]
+          else [next_token, 0]
+          end
+        end
+
+      end
+    end
+  end
+end