aws-sdk 1.0.4 → 1.1.0

data/lib/aws/ec2.rb

@@ -167,8 +167,8 @@ module AWS
   # the string "linux", you can do this:
   #
   #   ec2.images.with_owner("amazon").
-  #     filtered("platform", "windows").
-  #     filtered("description", "*linux*")
+  #     filter("platform", "windows").
+  #     filter("description", "*linux*")
   #
   # Similarly, you can tag images, instances, security groups,
   # snapshots, and volumes with free-form key-value metadata and

data/lib/aws/ec2/attachment.rb

@@ -11,8 +11,7 @@
 # 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
@@ -31,67 +30,45 @@ module AWS
     #  end
     #  sleep 1 until volume.status == :available
     #  volume.delete
-    class Attachment
-
-      include Model
-      include Cacheable
-
-      attr_reader :volume
-      attr_reader :instance
-      attr_reader :device
+    class Attachment < Resource
 
       # @private
-      def initialize(volume, instance, device, opts = {})
+      def initialize volume, instance, device, options = {}
         @volume = volume
         @instance = instance
         @device = device
-        super(opts)
-      end
-
-      # (see Volume#detach_from)
-      def delete(opts = {})
-        client.detach_volume(opts.merge(:volume_id => volume.id,
-                                        :instance_id => instance.id,
-                                        :device => device))
+        super
       end
 
-      # @return [Symbol] The attachment status.  Possible values:
-      #   * +:attaching+
-      #   * +:attached+
-      #   * +:detaching+
-      #   * +:detached+
-      def status
-        retrieve_attribute(:status) { describe_call }
-      end
-
-      # @return [Time] The time at which this attachment was created.
-      def attach_time
-        retrieve_attribute(:attach_time) { describe_call }
-      end
-
-      # @return [Boolean] True if the volume will be deleted on
-      #   instance termination.
-      def delete_on_termination?
-        retrieve_attribute(:delete_on_termination?) { describe_call }
-      end
+      # @return [Volume] Returns the volume that is attached.
+      attr_reader :volume
 
-      # @return [Boolean] True if the attachment exists.
-      def exists?
-        !describe_attachment.nil?
-      end
+      # @return [Instance] Returns the EC2 instance the volume is attached to.
+      attr_reader :instance
 
-      # @return [Boolean] True if the attachments are the same.
-      #
-      # @param [Object] other The object to compare with.
-      def ==(other)
-        other.kind_of?(Attachment) and
-          other.volume == volume and
-          other.instance == instance and
-          other.device == device
-      end
-      alias_method :eql?, :==
+      # @return [String] Returns how the device is exposed to the instance
+      #   (e.g. '/dev/sdh')
+      attr_reader :device
 
-      populate_from :describe_volumes do |resp|
+      # @overload status
+      # Returns the attachment status.  Possible values are:
+      # * +:attaching+
+      # * +:attached+
+      # * +:detaching+
+      # * +:detached+
+      # @return [Symbol] Returns the attachment status.  
+      attribute :status, :to_sym => true
+
+      # @overload attach_time
+      # @return [Time] Returns the time at which this attachment was created.
+      attribute :attach_time
+
+      # @overload delete_on_termination? 
+      # @return [Boolean] Returns +true+ if the volume will be deleted 
+      #   on instance termination.
+      attribute :delete_on_termination?
+    
+      populates_from(:describe_volumes) do |resp|
         if volume = resp.volume_index[self.volume.id] and
             attachments = volume.attachment_set and
             attachment = attachments.find do |att|
@@ -99,31 +76,47 @@ module AWS
               att.volume_id == self.volume.id &&
               att.device == self.device
           end
-
-          attributes_from_response_object(attachment)
+        then
+          attachment
         end
       end
 
-      [:attach_volume,
-       :detach_volume].each do |op|
-        populate_from op do |resp|
-          attributes_from_response_object(resp) if
-            resp.volume_id == volume.id and
-            resp.instance_id == instance.id and
-            resp.device == device
+      populates_from(:attach_volume, :detach_volume) do |resp|
+        if 
+          resp.volume_id == volume.id and
+          resp.instance_id == instance.id and
+          resp.device == device
+        then
+          resp
         end
       end
 
+      # @return [Boolean] Returns true if the attachment exists.
+      def exists?
+        !describe_attachment.nil?
+      end
+
+      # Detaches the volume from its instance.
+      # @option options [Boolean] :force Forces detachment if the
+      #   previous detachment attempt did not occur cleanly (logging
+      #   into an instance, unmounting the volume, and detaching
+      #   normally). This option can lead to data loss or a
+      #   corrupted file system. Use this option only as a last
+      #   resort to detach a volume from a failed instance. The
+      #   instance will not have an opportunity to flush file system
+      #   caches or file system metadata. If you use this option,
+      #   you must perform file system check and repair procedures.
+      def delete options = {}
+        client.detach_volume(options.merge(resource_options))
+      end
+
       protected
-      def attributes_from_response_object(attachment)
-        atts = {}
-        atts[:status] = (attachment.status.to_sym if
-                         attachment.respond_to?(:status))
-        atts[:attach_time] = (attachment.attach_time if
-                              attachment.respond_to?(:attach_time))
-        atts[:delete_on_termination?] = (attachment.delete_on_termination? if
-                                         attachment.respond_to?(:delete_on_termination?))
-        atts
+      def resource_identifiers
+        [
+          [:volume_id, volume.id],
+          [:instance_id, instance.id],
+          [:device, device],
+        ]
       end
 
       protected

data/lib/aws/ec2/attachment_collection.rb

@@ -31,22 +31,24 @@ module AWS
       attr_reader :volume
 
       # @private
-      def initialize(volume, opts = {})
+      def initialize volume, options = {}
         @volume = volume
-        super(opts)
+        super
       end
 
       # @yield [attachment] Each attachment of the volume as an
       #   {Attachment} object.
       # @return [nil]
-      def each(&block)
-        volume.attachment_set.each do |att|
-          instance = Instance.new(att.instance_id, :config => config)
-          attachment = Attachment.new(self.volume,
-                                      instance,
-                                      att.device,
-                                      :config => config)
+      def each &block
+        volume.attachment_set.each do |item|
+
+          instance = Instance.new(item.instance_id, :config => config)
+
+          attachment = Attachment.new(self.volume, instance, item.device, 
+            :config => config)
+
           yield(attachment)
+
         end
         nil
       end

data/lib/aws/ec2/availability_zone.rb

@@ -19,59 +19,68 @@ module AWS
     # Represents an EC2 availability zone.  You can use this class
     # to get information about the state of an availability zone
     # that is available to your account.
+    #
+    # @attr_reader [String,nil] region_name Returns the region name
+    #   of the availability zone.
+    #
+    # @attr_reader [Symbol] state Returns the state of the availability 
+    #   zone, e.g. +:available+.
+    #
+    # @attr_reader [Array<String>] messages Returns a list of messages about the 
+    #   Availability Zone.
+    #
     class AvailabilityZone < Resource
 
+      # @param [String] name The name of the availability zone.
+      def initialize name, options = {}
+        @name = name
+        if options[:region]
+          options[:region_name] = options[:region].name
+          
+        end
+        super
+      end
+
       # @return [String] Returns the name of the availability zone,
       #   e.g. "us-east-1a".
       attr_reader :name
 
       alias_method :to_s, :name
+
       alias_method :to_str, :name
 
-      # @param [String] name The name of the availability zone.
-      def initialize(name, opts = {})
-        @name = name
-        @region = opts[:region]
-        super(opts)
-      end
+      attribute :region_name, :static => true
+
+      attribute :state, :as => :zone_state, :to_sym => true
 
-      # @return [Region] The region of this availability zone.
-      def region; end
-      describe_call_attribute :region_name, :getter => :region, :memoize => true do
-        translate_output do |value|
-          Region.new(value, :config => config) if value
+      attribute :messages, :as => :message_set do
+        translates_output do |messages|
+          messages ? messages.collect{|m| m.message } : []
         end
       end
 
-      # @return [Symbol] The state of the availability zone,
-      #   e.g. +:available+.
-      def state; end
-      describe_call_attribute :zone_state, :getter => :state, :to_sym => true
+      populates_from(:describe_availability_zones) do |resp|
+        resp.availability_zone_info.find {|az| az.zone_name == name }
+      end
 
-      # @return [Array] A list of messages about the Availability
-      #   Zone.
-      def messages; end
-      describe_call_attribute :message_set, :getter => :messages do
-        translate_output { |set| set.map { |m| m.message } if set }
+      # @return [Region] Returns the region of this availability zone.
+      def region
+        Region.new(self.region_name, :config => config)
       end
 
       protected
-      def inflected_name
-        "zone"
+      def describe_call_name
+        :describe_availability_zones
       end
 
       protected
-      def find_in_response(resp)
-        resp.availability_zone_info.find { |az| az.zone_name == name }
+      def inflected_name
+        self.class.inflected_name
       end
 
-      # @private
-      private
-      def get_attribute(name)
-        resp = client.describe_availability_zones(:zone_names =>
-                                                  [self.name])
-        az = resp.availability_zone_info.first
-        az.send(name)
+      protected
+      def self.inflected_name
+        "zone"
       end
 
     end

data/lib/aws/ec2/availability_zone_collection.rb

@@ -27,9 +27,8 @@ module AWS
         resp = filtered_request(:describe_availability_zones)
         resp.availability_zone_info.each do |az|
           zone = AvailabilityZone.new(az.zone_name,
-            :region => Region.new(az.region_name, :config => config),
-            :config => config
-          )
+            :region_name => az.region_name,
+            :config => config)
           yield(zone)
         end
         nil

data/lib/aws/ec2/elastic_ip.rb

@@ -15,41 +15,43 @@ require 'aws/ec2/resource'
 
 module AWS
   class EC2
+
+    #
+    # @attr_reader [String,nil] instance_id Returns the instance id if 
+    #   assigned to an EC2 instance, nil otherwise.
+    #
     class ElasticIp < Resource
 
       def initialize public_ip, options = {}
         @public_ip = public_ip
-        @instance_id = options[:instance_id]
         super
       end
 
-      # @private
-      def self.describe_call_name; :describe_addresses; end
-
-      # @private
-      def describe_call_name; self.class.describe_call_name; end
-
       # @return [String] The public IP address.
       attr_reader :public_ip
 
       alias_method :ip_address, :public_ip
 
-      # @return [String,nil] Returns the instance id if assigned to an
-      #   EC2 instance
-      def instance_id; end
-      describe_call_attribute :instance_id
+      attribute :instance_id
+
+      populates_from(:describe_addresses) do |resp|
+        resp.address_index[public_ip]
+      end
 
       # @return [Boolean] Returns true if this IP address is attached to
       #   an EC2 instance.
       def associated?
         !!instance_id
       end
+
       alias_method :attached?, :associated?
 
       # @return [Instance,nil] If associated, returns the {Instance} this
       #   elastic IP address is associated to, nil otherwise.
       def instance
-        associated? ? Instance.new(instance_id, :config => config) : nil
+        if instance_id = self.instance_id
+          Instance.new(instance_id, :config => config)
+        end
       end
 
       # Releases the elastic IP address.
@@ -57,10 +59,10 @@ module AWS
       # (For non-VPC elastic ips) Releasing an IP address automatically 
       # disassociates it from any instance it's associated with.
       #
-      # @return [true]
+      # @return [nil]
       def delete
-        client.release_address(:public_ip => public_ip)
-        true
+        client.release_address(resource_options)
+        nil
       end
 
       alias_method :release, :delete
@@ -68,13 +70,12 @@ module AWS
       # Disassociates this elastic IP address from an EC2 instance.
       # Raises an exception if this elastic IP is not currently
       # associated with an instance.
-      # @return [true]
+      # @return [nil]
       def disassociate
-        client.disassociate_address(:public_ip => public_ip)
-        true
+        client.disassociate_address(resource_options)
+        nil
       end
 
-      # @private
       # @return [String] Returns the public IP address
       def to_s
         public_ip.to_s
@@ -94,13 +95,15 @@ module AWS
 
       # @private
       protected
-      def find_in_response(resp)
-        resp.address_index[public_ip]
+      def describe_call_name
+        :describe_addresses
       end
 
       # @private
       protected
-      def __resource_id__; public_ip; end
+      def self.describe_call_name
+        :describe_addresses
+      end
 
     end
   end

data/lib/aws/ec2/elastic_ip_collection.rb

@@ -67,8 +67,11 @@ module AWS
         response = filtered_request(:describe_addresses)
         response.addresses_set.each do |address|
 
-          elastic_ip = ElasticIp.new(address.public_ip,
-                                     :config => config)
+          options = {}
+          options[:config] = config
+          options[:instance_id] = address.instance_id
+
+          elastic_ip = ElasticIp.new(address.public_ip, options)
 
           yield(elastic_ip)