fog 0.0.9 → 0.0.10

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

@@ -8,11 +8,22 @@ module Fog
 
       class Addresses < Fog::Collection
 
+        attribute :public_ip
+
+        def initialize(attributes)
+          @public_ip ||= []
+          super
+        end
+
         def all(public_ip = [])
           data = connection.describe_addresses(public_ip).body
-          addresses = Fog::AWS::EC2::Addresses.new(:connection => connection)
+          addresses = Fog::AWS::EC2::Addresses.new({
+            :connection => connection,
+            :public_ip  => public_ip
+          }.merge!(attributes))
           data['addressesSet'].each do |address|
             addresses << Fog::AWS::EC2::Address.new({
+              :addresses  => self,
               :connection => connection
             }.merge!(address))
           end
@@ -25,8 +36,21 @@ module Fog
           address
         end
 
+        def get(public_ip)
+          all(public_ip).first
+        rescue Fog::Errors::BadRequest
+          nil
+        end
+
         def new
-          Fog::AWS::S3::Address.new(:connection => connection)
+          Fog::AWS::EC2::Address.new(
+            :addresses  => self,
+            :connection => connection
+          )
+        end
+
+        def reload
+          all(public_ip)
         end
 
       end

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

@@ -0,0 +1,135 @@
+module Fog
+  module AWS
+    class EC2
+
+      class Instance < Fog::Model
+
+        attribute :ami_launch_index,  'amiLaunchIndex'
+        attribute :availability_zone, 'availabilityZone'
+        attribute :dns_name,          'dnsName'
+        attribute :group_id,          'groupId'
+        attribute :image_id,          'imageId'
+        attribute :instance_id,       'instanceId'
+        attribute :instance_state,    'instanceState'
+        attribute :instance_type,     'instanceType'
+        attribute :kernel_id,         'kernelId'
+        attribute :key_name,          'keyName'
+        attribute :launch_time,       'launchTime'
+        attribute :monitoring
+        attribute :placement
+        attribute :product_codes,     'productCodes'
+        attribute :private_dns_name,  'privateDnsName'
+        attribute :ramdisk_id,        'ramdiskId'
+        attribute :reason
+        attribute :user_data
+
+        def address
+          connection.addresses.select {|address| address.instance_id == @instance_id}.first
+        end
+
+        def address=(new_address)
+          new_address.instance_id = @instance_id
+          connection.associate_address(@instance_id, new_address.public_ip)
+        end
+
+        def destroy
+          connection.terminate_instances(@instance_id)
+          true
+        end
+
+        # def security_group
+        #   connection.security_groups.all(@group_id)
+        # end
+        #
+        # def security_group=(new_security_group)
+        #   @group_id = new_security_group.name
+        # end
+
+        def key_pair
+          connection.keypairs.all(@key_name).first
+        end
+
+        def key_pair=(new_keypair)
+          @key_name = new_keypair.name
+        end
+
+        def instances
+          @instances
+        end
+
+        def monitoring=(new_monitoring)
+          if new_monitoring.is_a?(Hash)
+            @monitoring = new_monitoring['state']
+          else
+            @monitoring = new_monitoring
+          end
+        end
+
+        def placement=(new_placement)
+          if placement.is_a?(Hash)
+            @availability_zone = new_placement['availabilityZone']
+          else
+            @availability_zone = new_placement
+          end
+        end
+
+        def reload
+          new_attributes = instances.all(@instance_id).first.attributes
+          merge_attributes(new_attributes)
+        end
+
+        def save
+          options = {}
+          if @availability_zone
+            options['Placement.AvailabilityZone'] = @availability_zone
+          end
+          if @group_id
+            options['groupId'] = @group_id
+          end
+          if @instance_type
+            options['instanceType'] = @instance_type
+          end
+          if @kernel_id
+            options['KernelId'] = @kernel_id
+          end
+          if @key_name
+            options['KeyName'] = @key_name
+          end
+          if @monitoring
+            options['Monitoring.Enabled'] = @monitoring
+          end
+          if @ramdisk_id
+            options['RamdiskId'] = @ramdisk_id
+          end
+          if @user_data
+            options['UserData'] = @user_data
+          end
+          data = connection.run_instances(@image_id, 1, 1, options)
+          merge_attributes(data.body['instancesSet'].first)
+          true
+        end
+
+        def volumes
+          connection.volumes.all.select {|volume| volume.instance_id == @instance_id}
+        end
+
+        def volume=(new_volume)
+          new_volume.instance_id = @instance_id
+          connection.attach_volume(@instance_id, new_volume.volume_id, new_volume.device)
+        end
+
+        private
+
+        def instance_state=(new_instance_state)
+          @instance_state = new_instance_state['name']
+        end
+
+        def instances=(new_instances)
+          @instances = new_instances
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Fog
+  module AWS
+    class EC2
+
+      def instances
+        Fog::AWS::EC2::Instances.new(:connection => self)
+      end
+
+      class Instances < Fog::Collection
+
+        attribute :instance_id
+
+        def all(instance_id = [])
+          data = connection.describe_instances(instance_id)
+          instances = Fog::AWS::EC2::Instances.new({
+            :connection   => connection
+          }.merge!(attributes))
+          data['instancesSet'].each do |instance|
+            instances << Fog::AWS::EC2::Instances.new({
+              :connection => connection,
+              :instances  => self
+            }.merge!(instance))
+          end
+          instances
+        end
+
+        def create(attributes = {})
+          instance = new(attributes)
+          instance.save
+          instance
+        end
+
+        def get(instance_id)
+          all(instance_id).first
+        rescue Fog::Errors::BadRequest
+          nil
+        end
+
+        def new(attributes = {})
+          Fog::AWS::EC2::Instance.new(
+            attributes.merge!(
+              :connection => connection,
+              :instances  => self
+            )
+          )
+        end
+
+        def reload
+          all(instance_id)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -8,18 +8,33 @@ module Fog
         attribute :material,    'keyMaterial'
         attribute :name,        'keyName'
 
-        def delete
+        def destroy
           connection.delete_key_pair(@name)
           true
         end
 
+        def key_pairs
+          @key_pairs
+        end
+
+        def reload
+          new_attributes = key_pairs.all(@name).first.attributes
+          merge_attributes(new_attributes)
+        end
+
         def save
           data = connection.create_key_pair(@name).body
           new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
-          update_attributes(new_attributes)
+          merge_attributes(new_attributes)
           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

@@ -8,12 +8,23 @@ module Fog
 
       class KeyPairs < Fog::Collection
 
+        attribute :key_name
+
+        def initialize(attributes)
+          @key_name ||= []
+          super
+        end
+
         def all(key_name = [])
           data = connection.describe_key_pairs(key_name).body
-          key_pairs = Fog::AWS::EC2::KeyPairs.new(:connection => connection)
+          key_pairs = Fog::AWS::EC2::KeyPairs.new({
+            :connection => connection,
+            :key_name   => key_name
+          }.merge!(attributes))
           data['keySet'].each do |key|
             key_pairs << Fog::AWS::EC2::KeyPair.new({
-              :connection => connection
+              :connection => connection,
+              :key_pairs  => self
             }.merge!(key))
           end
           key_pairs
@@ -25,8 +36,23 @@ module Fog
           bucket
         end
 
+        def get(key_name)
+          all(key_name).first
+        rescue Fog::Errors::BadRequest
+          nil
+        end
+
         def new(attributes = {})
-          Fog::AWS::EC2::KeyPair.new(attributes.merge!(:connection => connection))
+          Fog::AWS::EC2::KeyPair.new(
+            attributes.merge!(
+              :connection => connection,
+              :key_pairs  => self
+            )
+          )
+        end
+
+        def reload
+          all(key_name)
         end
 
       end

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

@@ -0,0 +1,41 @@
+module Fog
+  module AWS
+    class EC2
+
+      class SecurityGroup < Fog::Model
+
+        attribute :group_description, 'groupDescription'
+        attribute :group_name,        'groupName'
+        attribute :ip_permissions,    'ipPermissions'
+        attribute :owner_id,          'ownerId'
+
+        def destroy
+          connection.delete_security_group(@group_name)
+          true
+        end
+
+        def reload
+          new_attributes = security_groups.get(@group_name).attributes
+          merge_attributes(new_attributes)
+        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
+  end
+end

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

@@ -0,0 +1,62 @@
+module Fog
+  module AWS
+    class EC2
+
+      def security_groups
+        Fog::AWS::EC2::SecurityGroups.new(:connection => self)
+      end
+
+      class SecurityGroups < Fog::Collection
+
+        attribute :group_name
+
+        def initialize(attributes)
+          @group_name ||= []
+          super
+        end
+
+        def all(group_name = [])
+          data = connection.describe_security_groups(group_name).body
+          security_groups = Fog::AWS::EC2::SecurityGroups.new({
+            :connection => connection,
+            :group_name => group_name
+          }.merge!(attributes))
+          data['securityGroupInfo'].each do |security_group|
+            security_groups << Fog::AWS::EC2::SecurityGroup.new({
+              :connection       => connection,
+              :security_groups  => self
+            }.merge!(security_group))
+          end
+          security_groups
+        end
+
+        def create(attributes = {})
+          security_group = new(attributes)
+          security_group.save
+          security_group
+        end
+
+        def get(group_name)
+          all(group_name).first
+        rescue Fog::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
+  end
+end

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

@@ -8,31 +8,31 @@ module Fog
         attribute :snapshot_id, 'snapshotId'
         attribute :start_time,  'startTime'
         attribute :status
-        attribute :volumeId,    'volumeId'
+        attribute :volume_id,    'volumeId'
 
-        def delete
+        def destroy
           connection.delete_snapshot(@snapshot_id)
           true
         end
 
+        def reload
+          new_attributes = snapshots.get(@snapshot_id).attributes
+          merge_attributes(new_attributes)
+        end
+
         def save
-          data = connection.create_snapshot(@volume.volume_id).body
+          data = connection.create_snapshot(volume_id).body
           new_attributes = data.reject {|key,value| key == 'requestId'}
-          update_attributes(new_attributes)
+          merge_attributes(new_attributes)
           true
         end
 
         def snapshots
-          @snapshots ||= begin
-            Fog::AWS::S3::Snapshots.new(
-              :connection => connection,
-              :volume     => self
-            )
-          end
+          @snapshots
         end
 
         def volume
-          @volume
+          connection.describe_volumes(@volume_id)
         end
 
         private
@@ -42,7 +42,7 @@ module Fog
         end
 
         def volume=(new_volume)
-          @volume = new_volume
+          @volume_id = new_volume.volume_id
         end
 
       end