aws-sdk 1.0.4 → 1.1.0

data/lib/aws/ec2/instance_collection.rb

@@ -46,45 +46,43 @@ module AWS
       include TaggedCollection
       include BlockDeviceMappings
 
-      ##
       # Runs one or more EC2 instances.
       #
       # @example Running a single instance
-      #  i = ec2.instances.create(:image_id => "ami-8c1fece5")
-      #  sleep 1 while i.status == :pending
+      #   i = ec2.instances.create(:image_id => "ami-8c1fece5")
+      #   sleep 1 while i.status == :pending
       #
       # @example Running multiple instances with the same parameters
-      #  instances =
-      #    ec2.instances.create(:image_id => "ami-8c1fece5",
-      #                         :count => 10)
-      #  sleep 1 while instances.any? { |i| i.status == :pending }
+      #
+      #   instances = ec2.instances.create(
+      #     :image_id => "ami-8c1fece5",
+      #     :count => 10)
+      #
+      #  sleep 1 while instances.any? {|i| i.status == :pending }
       #
       # @example Specifying block device mappings
-      #  ec2.instances.create(:image_id => "ami-8c1fece5",
-      #                       :block_device_mappings => {
-      #                         "/dev/sda2" => {
-      #                           # 15 GiB
-      #                           :volume_size => 15,
-      #                           :delete_on_termination => true
-      #                         }
-      #                       })
       #
-      # @return [Instance or Array] If a single instance is being created, this returns
-      #   an instance of {EC2::Instance} to represent the newly
-      #   created instance.  Otherwise it returns an array of
-      #   EC2::Instance objects.
+      #   ec2.instances.create({
+      #     :image_id => "ami-8c1fece5",
+      #     :block_device_mappings => {
+      #       "/dev/sda2" => {
+      #         :volume_size => 15, # 15 GiB
+      #         :delete_on_termination => true
+      #       }
+      #     }
+      #   })
       #
-      # @param [Hash] opts Options for new instance.  +:image_id+ is
+      # @param [Hash] options Options for new instance.  +:image_id+ is
       #   the only required option.
       #
-      # @option opts :count How many instances to request.  By
+      # @option options :count How many instances to request.  By
       #   default one instance is requested.  You can specify this
       #   either as an integer or as a Range, to indicate the
       #   minimum and maximum number of instances to run.  Note that
       #   for a new account you can request at most 20 instances at
       #   once.
       #
-      # @option opts [Hash] :block_device_mappings This must be a
+      # @option options [Hash] :block_device_mappings This must be a
       #   hash; the keys are device names to map, and the value for
       #   each entry determines how that device is mapped.  Valid
       #   values include:
@@ -110,43 +108,43 @@ module AWS
       #                              to delete the volume when the
       #                              instance is terminated.
       #
-      # @option opts [Boolean] :monitoring Setting this to true
+      # @option options [Boolean] :monitoring Setting this to true
       #   enables CloudWatch monitoring on the instances once they
       #   are started.
       #
-      # @option opts [String] :availability_zone Specifies the
+      # @option options [String] :availability_zone Specifies the
       #   availability zone where the instance should run.  Without
       #   this option, EC2 will choose an availability zone for you.
       #
-      # @option opts [String] :image_id ID of the AMI you want to
+      # @option options [String] :image_id ID of the AMI you want to
       #   launch.
       #
-      # @option opts [String] :key_name The name of the key pair to
+      # @option options [String] :key_name The name of the key pair to
       #   use.  Note: Launching public images without a key pair ID
       #   will leave them inaccessible.
       #
-      # @option opts [Array] :security_groups The names of the
+      # @option options [Array] :security_groups The names of the
       #   security groups that will be used to determine network
       #   access rules for the instances.  You may pass instances of
       #   {SecurityGroup} as well.
       #
-      # @option opts [String] :user_data Arbitrary user data.  You
+      # @option options [String] :user_data Arbitrary user data.  You
       #   do not need to encode this value.
       #
-      # @option opts [String] :instance_type The type of instance to
+      # @option options [String] :instance_type The type of instance to
       #   launch, for example "m1.small".
       #
-      # @option opts [String] :kernel_id The ID of the kernel with
+      # @option options [String] :kernel_id The ID of the kernel with
       #   which to launch the instance.
       #
-      # @option opts [String] :ramdisk_id The ID of the RAM disk to
+      # @option options [String] :ramdisk_id The ID of the RAM disk to
       #   select. Some kernels require additional drivers at
       #   launch. Check the kernel requirements for information on
       #   whether you need to specify a RAM disk. To find kernel
       #   requirements, refer to the Resource Center and search for
       #   the kernel ID.
       #
-      # @option opts [Boolean] :disable_api_termination Specifies
+      # @option options [Boolean] :disable_api_termination Specifies
       #   whether you can terminate the instance using the EC2
       #   API. A value of true means you can't terminate the
       #   instance using the API (i.e., the instance is "locked"); a
@@ -161,54 +159,61 @@ module AWS
       #     i.api_termination_disabled = false
       #     i.terminate                        # terminates the instance
       #
-      # @option opts [String] :instance_initiated_shutdown_behavior
+      # @option options [String] :instance_initiated_shutdown_behavior
       #   Determines whether the instance stops or terminates on
       #   instance-initiated shutdown.
-      def create(opts = {})
-        if image = opts.delete(:image)
-          opts[:image_id] = image.id
+      #
+      # @return [Instance or Array] If a single instance is being created, 
+      #   this returns an {EC2::Instance} to represent the newly
+      #   created instance.  Otherwise it returns an array of instance 
+      #   objects.
+      #
+      def create options = {}
+
+        if image = options.delete(:image)
+          options[:image_id] = image.id
         end
 
-        if kernel = opts.delete(:kernel)
-          opts[:kernel_id] = kernel.id
+        if kernel = options.delete(:kernel)
+          options[:kernel_id] = kernel.id
         end
 
-        if ramdisk = opts.delete(:ramdisk)
-          opts[:ramdisk_id] = ramdisk.id
+        if ramdisk = options.delete(:ramdisk)
+          options[:ramdisk_id] = ramdisk.id
         end
 
-        if key_pair = opts.delete(:key_pair)
-          opts[:key_name] = key_pair.name
+        if key_pair = options.delete(:key_pair)
+          options[:key_name] = key_pair.name
         end
 
-        opts = count_opts(opts).merge(opts)
-        opts.delete(:count)
+        options = count_options(options).merge(options)
+        options.delete(:count)
 
-        opts[:user_data] = Base64.encode64(opts[:user_data]).strip if
-          opts[:user_data]
+        options[:user_data] = Base64.encode64(options[:user_data]).strip if
+          options[:user_data]
 
-        opts[:block_device_mappings] =
-          translate_block_device_mappings(opts[:block_device_mappings]) if
-          opts[:block_device_mappings]
+        options[:block_device_mappings] =
+          translate_block_device_mappings(options[:block_device_mappings]) if
+          options[:block_device_mappings]
 
-        opts[:monitoring] = { :enabled => true } if
-          opts[:monitoring_enabled]
-        opts.delete(:monitoring_enabled)
+        options[:monitoring] = { :enabled => true } if
+          options[:monitoring_enabled]
+        options.delete(:monitoring_enabled)
 
-        opts[:placement] = {
-          :availability_zone => opts[:availability_zone].to_s
-        } if opts[:availability_zone]
-        opts.delete(:availability_zone)
+        options[:placement] = {
+          :availability_zone => options[:availability_zone].to_s
+        } if options[:availability_zone]
+        options.delete(:availability_zone)
 
-        opts[:security_groups] = group_opts(opts[:security_groups]) if
-          opts[:security_groups]
+        options[:security_groups] = group_opts(options[:security_groups]) if
+          options[:security_groups]
 
-        opts[:client_token] = UUIDTools::UUID.timestamp_create.to_s
+        options[:client_token] = UUIDTools::UUID.timestamp_create.to_s
 
-        resp = client.run_instances(opts)
+        resp = client.run_instances(options)
 
-        if opts[:min_count] == opts[:max_count] and
-            opts[:min_count] == 1
+        if options[:min_count] == options[:max_count] and
+            options[:min_count] == 1
           self[resp.instances_set.first.instance_id]
         else
           resp.instances_set.map do |i|
@@ -216,6 +221,7 @@ module AWS
           end
         end
       end
+
       alias_method :run, :create
 
       # @yield [Instance] Yields each instance in the collection.
@@ -242,18 +248,17 @@ module AWS
 
       # @private
       private
-      def count_opts(opts)
+      def count_options options
         min = max = 1
-        count = opts[:count]
+        count = options[:count]
         case count
         when Range
           min = count.begin
-          max = (count.exclude_end? ? count.end-1 : count.end)
+          max = (count.exclude_end? ? count.end - 1 : count.end)
         when Integer
           min = max = count
         end
-        { :min_count => min,
-          :max_count => max }
+        { :min_count => min, :max_count => max }
       end
 
       # @private

data/lib/aws/ec2/key_pair.rb

@@ -17,11 +17,12 @@ module AWS
   class EC2
 
     # Represents an EC2 key pair.
+    # @attr_reader [String] fingerprint A SHA-1 digest of the DER encoded 
+    #   private key
     class KeyPair < Resource
 
       def initialize name, options = {}
         @name = name.to_s
-        @fingerprint = options[:fingerprint]
         @private_key = options[:private_key]
         super
       end
@@ -29,19 +30,24 @@ module AWS
       # @return [String] The name of the key pair.
       attr_reader :name
 
+      attribute :fingerprint, :as => :key_fingerprint, :static => true
+
+      populates_from(:create_key_pair, :import_key_pair) do |resp|
+        resp if resp.key_name == name
+      end
+
+      populates_from(:describe_key_pairs) do |resp|
+        resp.key_set.find{|k| k.key_name == name }
+      end
+
       # @return [Boolean] True if the key pair exists.
       def exists?
-        !client.describe_key_pairs(:filters => [{ :name => "key-name",
-                                                :values => [name] }]).
-          key_set.empty?
+        resp = client.describe_key_pairs(:filters => [
+          { :name => "key-name", :values => [name] }
+        ])
+        !resp.key_set.empty?
       end
 
-      # @return [String] A SHA-1 digest of the DER encoded private key
-      def fingerprint; end
-      describe_call_attribute(:key_fingerprint,
-                              :getter => :fingerprint,
-                              :memoize => true)
-
       # Returns the private key.  Raises an exception if called
       # against an existing key.  You can only get the private key
       # at the time of creation. 
@@ -63,14 +69,6 @@ module AWS
         true
       end
 
-      [:create_key_pair,
-       :import_key_pair].each do |op|
-        populate_from op do |resp|
-          attributes_from_response_object(resp) if
-            resp.key_name == name
-        end
-      end
-
       protected
       def response_id_method
         :key_name

data/lib/aws/ec2/region.rb

@@ -29,19 +29,25 @@ module AWS
     #    h[region.name] = region.instances.map(&:id)
     #    h
     #  end
+    #
+    # @attr_reader [String] endpoint The endpoint to use for this region
+    #   (e.g. "ec2.eu-west-1.amazonaws.com").
+    #
     class Region < Resource
 
-      # The name of the region (e.g. "us-east-1")
-      attr_reader :name
-
       def initialize(name, options = {})
         @name = name
         super(options)
       end
 
-      # @return [String] The endpoint to use for this region.
-      def endpoint; end
-      describe_call_attribute :region_endpoint, :getter => :endpoint, :memoize => true
+      # @return [String] The name of the region (e.g. "us-east-1").
+      attr_reader :name
+
+      attribute :endpoint, :as => :region_endpoint, :static => true
+
+      populates_from(:describe_regions) do |resp|
+        resp.region_info.find{|r| r.region_name == name }
+      end
 
       # @return [Boolean] True if the region is available for this
       #   account.
@@ -51,17 +57,19 @@ module AWS
           region_info.empty?
       end
 
-      PROXIED_METHODS = [:instances,
-                         :security_groups,
-                         :key_pairs,
-                         :elastic_ips,
-                         :tags,
-                         :availability_zones,
-                         :images,
-                         :volumes,
-                         :snapshots,
-                         :reserved_instances,
-                         :reserved_instances_offerings]
+      PROXIED_METHODS = [
+        :instances,
+        :security_groups,
+        :key_pairs,
+        :elastic_ips,
+        :tags,
+        :availability_zones,
+        :images,
+        :volumes,
+        :snapshots,
+        :reserved_instances,
+        :reserved_instances_offerings
+      ]
 
       PROXIED_METHODS.each do |method|
         define_method(method) do

data/lib/aws/ec2/reserved_instances.rb

@@ -42,7 +42,13 @@ module AWS
       attr_reader :id
 
       ATTRIBUTES.each do |attr_name|
-        describe_call_attribute attr_name, :memoize => true
+        attribute(attr_name, :static => true)
+      end
+
+      populates_from(:describe_reserved_instances) do |resp|
+        resp.reserved_instances_set.find do |r|
+          r.reserved_instances_id == id
+        end
       end
 
     end

data/lib/aws/ec2/reserved_instances_collection.rb

@@ -30,9 +30,9 @@ module AWS
         response = filtered_request(:describe_reserved_instances)
         response.reserved_instances_set.each do |item|
 
-          reserved_instance = ReservedInstances.new(
-            item.reserved_instances_id,
-            :config => config)
+          reserved_instance = ReservedInstances.new_from(
+            :describe_reserved_instances, item, 
+            item.reserved_instances_id, :config => config)
 
           yield(reserved_instance)
 

data/lib/aws/ec2/reserved_instances_offering.rb

@@ -40,7 +40,13 @@ module AWS
       attr_reader :id
 
       ATTRIBUTES.each do |attr_name|
-        describe_call_attribute attr_name, :memoize => true
+        attribute(attr_name, :static => true)
+      end
+
+      populates_from(:describe_reserved_instances_offerings) do |resp|
+        resp.reserved_instances_offerings_set.find do |r|
+          r.reserved_instances_offering_id == id
+        end
       end
 
       def purchase options = {}

data/lib/aws/ec2/reserved_instances_offering_collection.rb

@@ -29,9 +29,9 @@ module AWS
         response = filtered_request(:describe_reserved_instances_offerings)
         response.reserved_instances_offerings_set.each do |item|
 
-          reserved_instance_offering = ReservedInstancesOffering.new(
-            item.reserved_instances_offering_id,
-            :config => config)
+          reserved_instance_offering = ReservedInstancesOffering.new_from(
+            :describe_reserved_instances_offerings, item, 
+            item.reserved_instances_offering_id, :config => config)
 
           yield(reserved_instance_offering)
 

data/lib/aws/ec2/resource.rb

@@ -11,64 +11,25 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-require 'aws/model'
-require 'aws/cacheable'
+require 'aws/resource'
 
 module AWS
   class EC2
 
     # @private
-    class Resource
+    class Resource < AWS::Resource
 
-      include Model
-      include Cacheable
-
-      def initialize(*args)
-        super
-        @memoized_attributes = {}
-        if options = args.last and options.kind_of?(Hash)
-          self.class.memoized_attributes.each do |att|
-            @memoized_attributes[att] = options[att] if options.key?(att)
-          end
-        end
-      end
-
-      def inspect
-        "<#{self.class}:#{__resource_id__}>"
-      end
-
-      def local_cache_key
-        "#{self.class}:#{__resource_id__}"
-      end
-
-      def attributes_from_response(response)
-        if atts = super
-          self.class.memoized_attributes.each do |att|
-            @memoized_attributes[att] = atts[att]
-          end
-          atts
-        end
-      end
-
-      def ==(other)
-        other.kind_of?(self.class) and
-          __resource_id__ == other.__resource_id__
+      # @private
+      protected
+      def resource_identifiers
+        [[resource_id_method, send(resource_id_method)]]
       end
 
-      alias_method :eql?, :==
-
       protected
       def __resource_id__
         send(resource_id_method)
       end
 
-      protected
-      def find_in_response(resp)
-        resp.send(plural_name + "_set").find do |obj|
-          obj.send(response_id_method) == __resource_id__
-        end
-      end
-
       protected
       def response_id_method
         # e.g. instance_id
@@ -93,74 +54,54 @@ module AWS
       end
 
       protected
-      def describe_call
-        name = self.class.describe_call_name
-        if client.respond_to?(name)
-          client.send(name, Hash[[[(response_id_method.to_s + "s").to_sym,
-                                   [__resource_id__]]]])
-        else
-          raise NotImplementedError
-        end
-      end
-
-      protected
-      def describe_attribute_call(attribute_name)
-        name = describe_attribute_call_name
-        client.send(name, Hash[[[response_id_method.to_sym,
-                                 __resource_id__],
-                                [:attribute, attribute_name]]])
+      def get_resource attribute
+        describe_call
       end
 
       protected
-      def get_mutable_attribute(name)
-        att_name = Inflection.class_name(name.to_s)
-        att_name = att_name[0,1].downcase + att_name[1..-1]
-        method_name = "describe_#{inflected_name}_attribute"
-        resp = client.send(method_name,
-                           Hash[[[:"#{inflected_name}_id", __resource_id__],
-                                 [:attribute, att_name]]])
-        if att = resp.send(name) and
-            att.respond_to?(:value)
-          att.value
+      def retrieve_attribute attribute_or_attribute_name, &block
+        if attribute_or_attribute_name.is_a?(Symbol)
+          attribute = self.class.attributes[attribute_or_attribute_name]
         else
-          nil
+          attribute = attribute_or_attribute_name
         end
+        super(attribute, &block)
       end
 
       protected
-      def set_mutable_attribute(name, input_value)
-        value = send("translate_input_for_#{name}", input_value) if
-          respond_to?("translate_input_for_#{name}")
-        opts = {}
-        opts[name] = { :value => value }
-        opts["#{inflected_name}_id".to_sym] = __resource_id__
-        method_name = "modify_#{inflected_name}_attribute"
-        resp = client.send(method_name, opts)
-        input_value
+      def describe_call
+        options = { :"#{response_id_method}s" => [__resource_id__] }
+        client.send(describe_call_name, options)
       end
 
       protected
-      def attributes_from_response_object(obj)
-        atts = {}
-        self.class.describe_call_attributes.each do |att, response_att|
-          raw_value = (obj.send(response_att) if obj.respond_to?(response_att))
-          translated = send("translate_describe_output_for_#{response_att}", raw_value)
-          atts[att] = translated
-        end
-        atts
+      def describe_attribute_call(attribute)
+        name = describe_attribute_call_name
+
+        attr_opt_name = Inflection.class_name(attribute.get_as.to_s)
+        attr_opt_name = attr_opt_name[0,1].downcase + attr_opt_name[1..-1]
+
+        client.send(name, Hash[[[response_id_method.to_sym,
+                                 __resource_id__],
+                                [:attribute, attr_opt_name]]])
       end
 
       protected
-      def attributes_from_describe_attribute_response(resp)
-        requested_att = resp.request_options[:attribute]
-        return nil unless
-          resp.request_options[response_id_method.to_sym] == __resource_id__
+      def update_resource attribute, value
+        options = {}
+        options[attribute.set_as] = { :value => value }
+        options[:"#{inflected_name}_id"] = __resource_id__
+        method_name = "modify_#{inflected_name}_attribute"
+        client.send(method_name, options)
+      end
 
-        response_att = Inflection.ruby_name(requested_att)
-        if getter = self.class.mutable_attributes[response_att.to_sym]
-          raw_value = resp.send(response_att)
-          translated = send("translate_describe_attribute_output_for_#{response_att}", raw_value)
-          Hash[[[getter, translated]]]
+      # required for tagged item, which most ec2 resources are
+      protected
+      def find_in_response response
+        self.class.attribute_providers.each do |provider|
+          if provider.request_types.include?(response.request_type)
+            return send(provider.finder_method, response)
+          end
         end
       end
 
@@ -168,7 +109,7 @@ module AWS
 
         protected
         def describe_call_name
-          name = "describe_#{plural_name}"
+          :"describe_#{plural_name}"
         end
 
         protected
@@ -202,134 +143,12 @@ module AWS
       extend InflectionMethods
       include InflectionMethods
 
-      # @private
-      class AttributeBuilder
-
-        include InflectionMethods
-
-        def initialize(klass, name, type)
-          @klass = klass
-          @name = name
-          @type = type
-          translate_input { |v| v }
-          translate_output { |v| v }
-        end
-
-        def translate_input(&blk)
-          @klass.send(:define_method, "translate_input_for_#{@name}", &blk)
-        end
-
-        def translate_output(&blk)
-          @klass.send(:define_method, output_translator(@name, @type), &blk)
-        end
-
-        def self.eval(klass, name, type, opts = {}, &blk)
-          i = new(klass, name, type)
-          i.instance_eval do
-            translate_output { |v| v.tr("-","_").to_sym if v } if opts[:to_sym]
-            translate_output { |v| v.value if v } if opts[:value_wrapper]
-            instance_eval(&blk) if blk
-          end
-        end
-      end
-
-      class NotFound < StandardError; end
-
       class << self
 
-        def memoized_attributes; []; end
-
         # @private
         protected
         def describe_call_attribute(name, opts = {}, &blk)
-          getter_name = opts[:getter] || name
-
-          # define the accessor
-          define_describe_call_getter(getter_name, opts) do |*args|
-            begin
-              retrieve_attribute(getter_name) { describe_call }
-            rescue Cacheable::NoData => e
-              name = Inflection.ruby_name(self.class.name).tr("_", " ")
-              raise NotFound, "unable to find the #{name}"
-            end
-          end
-
-          # ensure we are populating from the describe call
-          populate_from describe_call_name do |resp|
-            if obj = find_in_response(resp)
-              attributes_from_response_object(obj)
-            end
-          end
-
-          # add it to the list of attributes to populate from the response object
-          add_to_attribute_map(:describe_call_attributes, getter_name, name)
-
-          if opts[:memoize]
-            all_memoized = memoized_attributes
-            all_memoized << getter_name
-            MetaUtils.extend_method(self, :memoized_attributes) { all_memoized }
-          end
-
-          # evaluate translators
-          AttributeBuilder.eval(self, name, :describe, opts, &blk)
-        end
-
-        protected
-        def add_to_attribute_map(map_name, key, value)
-          all_attributes = {}
-          all_attributes = send(map_name) if respond_to?(map_name)
-          all_attributes[key] = value
-          MetaUtils.extend_method(self, map_name) do
-            all_attributes
-          end
-        end
-
-        protected
-        def define_describe_call_getter(getter_name, opts, &block)
-          if opts[:memoize]
-            original_block = block
-            block = lambda do
-              if @memoized_attributes.has_key?(getter_name)
-                @memoized_attributes[getter_name]
-              else
-                instance_eval(&original_block)
-              end
-            end
-          end
-          define_method(getter_name, &block)
-        end
-
-        # @private
-        def mutable_attribute(name, opts = {}, &blk)
-          getter = opts[:getter] || name
-          setter = opts[:setter] || "#{name}="
-
-          # e.g. "instanceType" or "blockDeviceMapping"
-          # as passed to the :attribute option of the service call
-          request_name = Inflection.class_name(name.to_s)
-          request_name = request_name[0,1].downcase + request_name[1..-1]
-
-          # define getter
-          define_method(getter) do
-            retrieve_attribute(getter) { describe_attribute_call(request_name) }
-          end
-
-          # define setter
-          define_method(setter) do |input_value|
-            set_mutable_attribute(name, input_value)
-          end unless opts[:setter] == false
-
-          # make sure we will populate from this type of response
-          populate_from describe_attribute_call_name do |resp|
-            attributes_from_describe_attribute_response(resp)
-          end
-
-          # describe how to populate this attribute
-          add_to_attribute_map(:mutable_attributes, name, getter)
-
-          # evaluate translations, etc.
-          AttributeBuilder.eval(self, name, :describe_attribute,
-                                { :value_wrapper => true }.merge(opts), &blk)
+          attribute(name, opts, &blk)
         end
 
       end