fog 0.0.29 → 0.0.30

data/lib/fog/aws/models/ec2/key_pair.rb

@@ -4,25 +4,16 @@ module Fog
 
       class KeyPair < Fog::Model
 
+        identity  :name,        'keyName'
+
         attribute :fingerprint, 'keyFingerprint'
         attribute :material,    'keyMaterial'
-        attribute :name,        'keyName'
 
         def destroy
           connection.delete_key_pair(@name)
           true
         end
 
-        def key_pairs
-          @key_pairs
-        end
-
-        def reload
-          if new_key_pair = key_pairs.get(@name)
-            merge_attributes(new_key_pair.attributes)
-          end
-        end
-
         def save
           data = connection.create_key_pair(@name).body
           new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
@@ -30,12 +21,6 @@ module Fog
           true
         end
 
-        private
-
-        def key_pairs=(new_key_pairs)
-          @key_pairs = new_key_pairs
-        end
-
       end
 
     end

data/lib/fog/aws/models/ec2/key_pairs.rb

@@ -10,12 +10,14 @@ module Fog
 
         attribute :key_name
 
+        model Fog::AWS::EC2::KeyPair
+
         def initialize(attributes)
           @key_name ||= []
           super
         end
 
-        def all(key_name = [])
+        def all(key_name = @key_name)
           data = connection.describe_key_pairs(key_name).body
           key_pairs = Fog::AWS::EC2::KeyPairs.new({
             :connection => connection,
@@ -23,40 +25,21 @@ module Fog
           }.merge!(attributes))
           data['keySet'].each do |key|
             key_pairs << Fog::AWS::EC2::KeyPair.new({
-              :connection => connection,
-              :key_pairs  => self
+              :collection => key_pairs,
+              :connection => connection
             }.merge!(key))
           end
           key_pairs
         end
 
-        def create(attributes = {})
-          bucket = new(attributes)
-          bucket.save
-          bucket
-        end
-
         def get(key_name)
           if key_name
             all(key_name).first
           end
-        rescue Fog::Errors::BadRequest
+        rescue Excon::Errors::BadRequest
           nil
         end
 
-        def new(attributes = {})
-          Fog::AWS::EC2::KeyPair.new(
-            attributes.merge!(
-              :connection => connection,
-              :key_pairs  => self
-            )
-          )
-        end
-
-        def reload
-          all(key_name)
-        end
-
       end
 
     end

data/lib/fog/aws/models/ec2/security_group.rb

@@ -4,16 +4,28 @@ module Fog
 
       class SecurityGroup < Fog::Model
 
+        identity  :group_name,        'groupName'
+
         attribute :group_description, 'groupDescription'
-        attribute :group_name,        'groupName'
         attribute :ip_permissions,    'ipPermissions'
         attribute :owner_id,          'ownerId'
 
-        def authorize(options = {})
-          options = {
-            'GroupName' => @group_name
-          }.merge!(options)
-          connection.authorize_security_group_ingress(options)
+        def authorize_group_and_owner(group, owner)
+          connection.authorize_security_group_ingress(
+            'GroupName'                   => @group_name,
+            'SourceSecurityGroupName'     => group,
+            'SourceSecurityGroupOwnerId'  => owner
+          )
+        end
+
+        def authorize_port_range(range, options = {})
+          connection.authorize_security_group_ingress(
+            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
+            'FromPort'    => range.min,
+            'GroupName'   => @group_name,
+            'ToPort'      => range.max,
+            'IpProtocol'  => options[:ip_protocol] || 'tcp' 
+          )
         end
 
         def destroy
@@ -21,27 +33,11 @@ module Fog
           true
         end
 
-        def reload
-          if new_security_group = security_groups.get(@group_name)
-            merge_attributes(new_security_group.attributes)
-          end
-        end
-
         def save
           data = connection.create_security_group(@group_name, @group_description).body
           true
         end
 
-        def security_groups
-          @security_groups
-        end
-
-        private
-
-        def security_groups=(new_security_groups)
-          @security_groups = new_security_groups
-        end
-
       end
 
     end

data/lib/fog/aws/models/ec2/security_groups.rb

@@ -10,12 +10,14 @@ module Fog
 
         attribute :group_name
 
+        model Fog::AWS::EC2::SecurityGroup
+
         def initialize(attributes)
           @group_name ||= []
           super
         end
 
-        def all(group_name = [])
+        def all(group_name = @group_name)
           data = connection.describe_security_groups(group_name).body
           security_groups = Fog::AWS::EC2::SecurityGroups.new({
             :connection => connection,
@@ -23,40 +25,21 @@ module Fog
           }.merge!(attributes))
           data['securityGroupInfo'].each do |security_group|
             security_groups << Fog::AWS::EC2::SecurityGroup.new({
-              :connection       => connection,
-              :security_groups  => self
+              :collection => security_groups,
+              :connection => connection
             }.merge!(security_group))
           end
           security_groups
         end
 
-        def create(attributes = {})
-          security_group = new(attributes)
-          security_group.save
-          security_group
-        end
-
         def get(group_name)
           if group_name
             all(group_name).first
           end
-        rescue Fog::Errors::BadRequest
+        rescue Excon::Errors::BadRequest
           nil
         end
 
-        def new(attributes = {})
-          Fog::AWS::EC2::SecurityGroup.new(
-            attributes.merge!(
-              :connection => connection,
-              :security_groups  => self
-            )
-          )
-        end
-
-        def reload
-          all(group_name)
-        end
-
       end
 
     end

data/lib/fog/aws/models/ec2/snapshot.rb

@@ -4,8 +4,9 @@ module Fog
 
       class Snapshot < Fog::Model
 
+        identity  :snapshot_id, 'snapshotId'
+
         attribute :progress
-        attribute :snapshot_id, 'snapshotId'
         attribute :start_time,  'startTime'
         attribute :status
         attribute :volume_id,    'volumeId'
@@ -15,12 +16,6 @@ module Fog
           true
         end
 
-        def reload
-          if new_snapshot = snapshots.get(@snapshot_id)
-            merge_attributes(new_snapshot.attributes)
-          end
-        end
-
         def save
           data = connection.create_snapshot(volume_id).body
           new_attributes = data.reject {|key,value| key == 'requestId'}
@@ -28,20 +23,12 @@ module Fog
           true
         end
 
-        def snapshots
-          @snapshots
-        end
-
         def volume
           connection.describe_volumes(@volume_id)
         end
 
         private
 
-        def snapshots=(new_snapshots)
-          @snapshots = new_snapshots
-        end
-
         def volume=(new_volume)
           @volume_id = new_volume.volume_id
         end

data/lib/fog/aws/models/ec2/snapshots.rb

@@ -13,12 +13,14 @@ module Fog
         attribute :snapshot_id
         attribute :volume_id
 
+        model Fog::AWS::EC2::Snapshot
+
         def initialize(attributes)
           @snapshot_id ||= []
           super
         end
 
-        def all(snapshot_id = [])
+        def all(snapshot_id = @snapshot_id)
           data = connection.describe_snapshots(snapshot_id).body
           snapshots = Fog::AWS::EC2::Snapshots.new({
             :connection   => connection,
@@ -26,8 +28,8 @@ module Fog
           }.merge!(attributes))
           data['snapshotSet'].each do |snapshot|
             snapshots << Fog::AWS::EC2::Snapshot.new({
-              :connection => connection,
-              :snapshots  => self
+              :collection => snapshots,
+              :connection => connection
             }.merge!(snapshot))
           end
           if volume_id
@@ -36,37 +38,22 @@ module Fog
           snapshots
         end
 
-        def create(attributes = {})
-          snapshot = new(attributes)
-          snapshot.save
-          snapshot
-        end
-
         def get(snapshot_id)
           if snapshot_id
             all(snapshot_id).first
           end
-        rescue Fog::Errors::BadRequest
+        rescue Excon::Errors::BadRequest
           nil
         end
 
         def new(attributes = {})
-          snapshot = Fog::AWS::EC2::Snapshot.new(
-            attributes.merge!(
-              :connection => connection,
-              :snapshots  => self
-            )
-          )
+          snapshot = super(attributes)
           if volume_id
             snapshot.volume_id = volume_id
           end
           snapshot
         end
 
-        def reload
-          all(snapshot_id)
-        end
-
       end
 
     end

data/lib/fog/aws/models/ec2/volume.rb

@@ -4,6 +4,8 @@ module Fog
 
       class Volume < Fog::Model
 
+        identity  :volume_id,         'volumeId'
+
         attribute :attach_time,       'attachTime'
         attribute :availability_zone, 'availabilityZone'
         attribute :create_time,       'createTime'
@@ -12,7 +14,6 @@ module Fog
         attribute :size
         attribute :snapshot_id,       'snapshotId'
         attribute :status
-        attribute :volume_id,         'volumeId'
         
         def initialize(attributes = {})
           if attributes['attachmentSet']
@@ -27,21 +28,10 @@ module Fog
         end
 
         def instance=(new_instance)
-          if !@volume_id
-            @instance = new_instance
-            if new_instance
-              @availability_zone = new_instance.availability_zone
-            end
-          elsif new_instance
-            @instance = nil
-            @instance_id = new_instance.instance_id
-            connection.attach_volume(@instance_id, @volume_id, @device)
-          end
-        end
-
-        def reload
-          if new_volume = volumes.get(@volume_id)
-            merge_attributes(new_volume.attributes)
+          if new_instance
+            attach(new_instance)
+          else
+            detach
           end
         end
 
@@ -59,14 +49,25 @@ module Fog
           connection.snapshots(:volume_id => volume_id)
         end
 
-        def volumes
-          @volumes
-        end
-
         private
 
-        def volumes=(new_volumes)
-          @volumes = new_volumes
+        def attach(new_instance)
+          if new_record?
+            @instance = new_instance
+            @availability_zone = new_instance.availability_zone
+          elsif new_instance
+            @instance = nil
+            @instance_id = new_instance.instance_id
+            connection.attach_volume(@instance_id, @volume_id, @device)
+          end
+        end
+
+        def detach
+          @instance = nil
+          @instance_id = nil
+          unless new_record?
+            connection.detach_volume(@volume_id)
+          end
         end
 
       end

data/lib/fog/aws/models/ec2/volumes.rb

@@ -13,12 +13,14 @@ module Fog
         attribute :volume_id
         attribute :instance
 
+        model Fog::AWS::EC2::Volume
+
         def initialize(attributes)
           @volume_id ||= []
           super
         end
 
-        def all(volume_id = [])
+        def all(volume_id = @volume_id)
           data = connection.describe_volumes(volume_id).body
           volumes = Fog::AWS::EC2::Volumes.new({
             :connection => connection,
@@ -26,42 +28,26 @@ module Fog
           }.merge!(attributes))
           data['volumeSet'].each do |volume|
             volumes << Fog::AWS::EC2::Volume.new({
-              :connection => connection,
-              :volumes    => self
+              :collection => volumes,
+              :connection => connection
             }.merge!(volume))
           end
           if instance
-            volumes = volumes.select {|volume| volume.instance_id == instance.id}
+            volumes = volumes.select {|volume| volume.instance_id == instance.instance_id}
           end
           volumes
         end
 
-        def create(attributes = {})
-          volume = new(attributes)
-          volume.save
-          volume
-        end
-
         def get(volume_id)
           if volume_id
             all(volume_id).first
           end
-        rescue Fog::Errors::BadRequest
+        rescue Excon::Errors::BadRequest
           nil
         end
 
         def new(attributes = {})
-          volume = Fog::AWS::EC2::Volume.new(
-            attributes.merge!(
-              :connection   => connection,
-              :instance     => instance,
-              :volumes      => self
-            )
-          )
-        end
-
-        def reload
-          all(volume_id)
+          super({ :instance => instance }.merge!(attributes))
         end
 
       end