tecnh-fog 0.2.23.vpc

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

@@ -0,0 +1,62 @@
+require 'fog/collection'
+require 'fog/aws/models/ec2/address'
+
+module Fog
+  module AWS
+    module EC2
+
+      module Collections
+        def addresses(attributes = {})
+          Fog::AWS::EC2::Addresses.new({
+            :connection => self
+          }.merge!(attributes))
+        end
+      end
+
+      class Addresses < Fog::Collection
+
+        attribute :public_ip
+        attribute :server
+
+        model Fog::AWS::EC2::Address
+
+        def initialize(attributes)
+          @public_ip ||= []
+          super
+        end
+
+        def all(public_ip = @public_ip)
+          @public_ip = public_ip
+          data = connection.describe_addresses(public_ip).body
+          load(
+            data['addressesSet'].map do |address|
+              address.reject {|key, value| value.nil? || value.empty? }
+            end
+          )
+          if server
+            self.replace(self.select {|address| address.server_id == server.id})
+          end
+          self
+        end
+
+        def get(public_ip)
+          if public_ip
+            all(public_ip).first
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          if server
+            super({ :server => server }.merge!(attributes))
+          else
+            super(attributes)
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    module EC2
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :bits
+        attribute :cores
+        attribute :disk
+        attribute :name
+        attribute :ram
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fog/collection'
+require 'fog/aws/models/ec2/flavor'
+
+module Fog
+  module AWS
+    module EC2
+
+      module Collections
+        def flavors
+          Fog::AWS::EC2::Flavors.new(:connection => self)
+        end
+      end
+
+      class Flavors < Fog::Collection
+
+        model Fog::AWS::EC2::Flavor
+
+        def all
+          data = [
+            { :bits => 32, :cores => 1, :disk => 160,  :id => 'm1.small',  :name => 'Small Instance',       :ram => 1740.8},
+            { :bits => 64, :cores => 4, :disk => 850,  :id => 'm1.large',  :name => 'Large Instance',       :ram => 7680},
+            { :bits => 64, :cores => 8, :disk => 1690, :id => 'm1.xlarge', :name => 'Extra Large Instance', :ram => 15360},
+
+            { :bits => 32, :cores =>  5, :disk => 350,  :id => 'c1.medium', :name => 'High-CPU Medium',      :ram => 1740.8},
+            { :bits => 64, :cores => 20, :disk => 1690, :id => 'c1.xlarge', :name => 'High-CPU Extra Large', :ram => 7168},
+
+            { :bits => 64, :cores => 6.5, :disk => 420,  :id => 'm2.xlarge',  :name => 'High-Memory Extra Large',           :ram => 17510.4},
+            { :bits => 64, :cores =>  13, :disk => 850,  :id => 'm2.2xlarge', :name => 'High Memory Double Extra Large',    :ram => 35020.8},
+            { :bits => 64, :cores =>  26, :disk => 1690, :id => 'm2.4xlarge', :name => 'High Memory Quadruple Extra Large', :ram => 70041.6},
+          ]
+          load(data)
+          self
+        end
+
+        def get(flavor_id)
+          all.detect {|flavor| flavor.id == flavor_id}
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    module EC2
+
+      class Image < Fog::Model
+
+        identity :id,                    'imageId'
+
+        attribute :architecture
+        attribute :block_device_mapping, 'blockDeviceMapping'
+        attribute :location,             'imageLocation'
+        attribute :owner_id,             'imageOwnerId'
+        attribute :state,                'imageState'
+        attribute :type,                 'imageType'
+        attribute :is_public,            'isPublic'
+        attribute :kernel_id,            'kernelId'
+        attribute :platform
+        attribute :product_codes,        'productCodes'
+        attribute :ramdisk_id,           'ramdiskId'
+        attribute :root_device_type,     'rootDeviceType'
+        attribute :root_device_name,     'rootDeviceName'
+
+        def deregister(delete_snapshot = false)
+          connection.deregister_image(@id)
+
+          if(delete_snapshot && @root_device_type=="ebs")
+            @block_device_mapping.each do |block_device|
+              next if block_device["deviceName"] != @root_device_name
+              snapshot_id = block_device["snapshotId"]
+              snapshot = @connection.snapshots.get(snapshot_id)
+              return snapshot.destroy
+            end
+          end
+
+          return true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'fog/collection'
+require 'fog/aws/models/ec2/image'
+
+module Fog
+  module AWS
+    module EC2
+
+      module Collections
+        def images
+          Fog::AWS::EC2::Images.new(:connection => self)
+        end
+      end
+
+      class Images < Fog::Collection
+
+        attribute :image_id
+
+        model Fog::AWS::EC2::Image
+
+        def initialize(attributes)
+          @image_id ||= []
+          super
+        end
+
+        def all(image_id = @image_id)
+          @image_id = image_id
+          data = connection.describe_images('ImageId' => image_id).body
+          load(data['imagesSet'])
+        end
+
+        def get(image_id)
+          if image_id
+            all(image_id).first
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    module EC2
+
+      class KeyPair < Fog::Model
+
+        identity  :name,        'keyName'
+
+        attribute :fingerprint, 'keyFingerprint'
+        attribute :material,    'keyMaterial'
+
+        def destroy
+          requires :name
+
+          connection.delete_key_pair(@name)
+          true
+        end
+
+        def save
+          requires :name
+
+          data = connection.create_key_pair(@name).body
+          new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
+          merge_attributes(new_attributes)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fog/collection'
+require 'fog/aws/models/ec2/key_pair'
+
+module Fog
+  module AWS
+    module EC2
+
+      module Collections
+        def key_pairs
+          Fog::AWS::EC2::KeyPairs.new(:connection => self)
+        end
+      end
+
+      class KeyPairs < Fog::Collection
+
+        attribute :key_name
+
+        model Fog::AWS::EC2::KeyPair
+
+        def initialize(attributes)
+          @key_name ||= []
+          super
+        end
+
+        def all(key_name = @key_name)
+          @key_name = key_name
+          data = connection.describe_key_pairs(key_name).body
+          load(data['keySet'])
+        end
+
+        def get(key_name)
+          if key_name
+            all(key_name).first
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    module EC2
+
+      class SecurityGroup < Fog::Model
+
+        identity  :name,            'groupName'
+
+        attribute :description,     'groupDescription'
+        attribute :ip_permissions,  'ipPermissions'
+        attribute :owner_id,        'ownerId'
+
+        def authorize_group_and_owner(group, owner)
+          requires :name
+
+          connection.authorize_security_group_ingress(
+            'GroupName'                   => @name,
+            'SourceSecurityGroupName'     => group,
+            'SourceSecurityGroupOwnerId'  => owner
+          )
+        end
+
+        def authorize_port_range(range, options = {})
+          requires :name
+
+          connection.authorize_security_group_ingress(
+            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
+            'FromPort'    => range.min,
+            'GroupName'   => @name,
+            'ToPort'      => range.max,
+            'IpProtocol'  => options[:ip_protocol] || 'tcp' 
+          )
+        end
+
+        def destroy
+          requires :name
+
+          connection.delete_security_group(@name)
+          true
+        end
+
+        def save
+          requires :description, :name
+
+          data = connection.create_security_group(@name, @description).body
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fog/collection'
+require 'fog/aws/models/ec2/security_group'
+
+module Fog
+  module AWS
+    module EC2
+
+      module Collections
+        def security_groups
+          Fog::AWS::EC2::SecurityGroups.new(:connection => self)
+        end
+      end
+
+      class SecurityGroups < Fog::Collection
+
+        attribute :group_name
+
+        model Fog::AWS::EC2::SecurityGroup
+
+        def initialize(attributes)
+          @group_name ||= []
+          super
+        end
+
+        def all(group_name = @group_name)
+          @group_name = group_name
+          data = connection.describe_security_groups(group_name).body
+          load(data['securityGroupInfo'])
+        end
+
+        def get(group_name)
+          if group_name
+            all(group_name).first
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    module EC2
+
+      class Server < Fog::Model
+
+        identity  :id,                    'instanceId'
+
+        attr_accessor :architecture
+        attribute :ami_launch_index,      'amiLaunchIndex'
+        attribute :availability_zone,     'availabilityZone'
+        attribute :block_device_mapping,  'blockDeviceMapping'
+        attribute :dns_name,              'dnsName'
+        attribute :groups
+        attribute :flavor_id,             'instanceType'
+        attribute :image_id,              'imageId'
+        attribute :ip_address,            'ipAddress'
+        attribute :kernel_id,             'kernelId'
+        attribute :key_name,              'keyName'
+        attribute :created_at,            'launchTime'
+        attribute :monitoring
+        attribute :product_codes,         'productCodes'
+        attribute :private_dns_name,      'privateDnsName'
+        attribute :private_ip_address,    'privateIpAddress'
+        attribute :ramdisk_id,            'ramdiskId'
+        attribute :reason
+        attribute :root_device_name,      'rootDeviceName'
+        attribute :root_device_type,      'rootDeviceType'
+        attribute :state,                 'instanceState'
+        attribute :subnet_id,             'subnetId'
+        attribute :user_data
+
+        def initialize(attributes={})
+          @groups ||= ["default"] if attributes[:subnet_id].blank?
+          @flavor_id ||= 'm1.small'
+          super
+        end
+
+        def addresses
+          requires :id
+
+          connection.addresses(:server => self)
+        end
+
+        def console_output
+          requires :id
+
+          connection.get_console_output(@id)
+        end
+
+        def destroy
+          requires :id
+
+          connection.terminate_instances(@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 flavor_id
+          @flavor && @flavor.id || @flavor_id
+        end
+
+        def flavor=(new_flavor)
+          @flavor = new_flavor
+        end
+
+        def flavor
+          @flavor ||= connection.flavors.all.detect {|flavor| flavor.id == @flavor_id}
+        end
+
+        def key_pair
+          requires :key_name
+
+          connection.keypairs.all(@key_name).first
+        end
+
+        def key_pair=(new_keypair)
+          @key_name = new_keypair.name
+        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 new_placement.is_a?(Hash)
+            @availability_zone = new_placement['availabilityZone']
+          else
+            @availability_zone = new_placement
+          end
+        end
+
+        def ready?
+          @state == 'running'
+        end
+
+        def reboot
+          requires :id
+          connection.reboot_instances(@id)
+          true
+        end
+
+        def save
+          requires :image_id
+
+          options = {
+            'BlockDeviceMapping'          => @block_device_mapping,
+            'InstanceType'                => flavor_id,
+            'KernelId'                    => @kernel_id,
+            'KeyName'                     => @key_name,
+            'Monitoring.Enabled'          => @monitoring,
+            'Placement.AvailabilityZone'  => @availability_zone,
+            'RamdiskId'                   => @ramdisk_id,
+            'SecurityGroup'               => @groups,
+            'SubnetId'                    => subnet_id,
+            'UserData'                    => @user_data
+          }
+          
+          # If subnet is defined we are working on a virtual private cloud
+          # subnet & security group cannot co-exist. I wish VPC just ignored
+          # the security group parameter instead, it would be much easier!
+          if subnet_id.blank?
+            options.delete('SubnetId') 
+          else
+            options.delete('SecurityGroup')
+          end
+
+          data = connection.run_instances(@image_id, 1, 1, options)
+          merge_attributes(data.body['instancesSet'].first)
+          true
+        end
+
+        def start
+          requires :id
+          connection.start_instances(@id)
+          true
+        end
+
+        def stop
+          requires :id
+          connection.stop_instances(@id)
+          true
+        end
+
+        def volumes
+          requires :id
+
+          connection.volumes(:server => self)
+        end
+
+        private
+
+        def state=(new_state)
+          if new_state.is_a?(Hash)
+            @state = new_state['name']
+          else
+            @state = new_state
+          end
+        end
+
+      end
+
+    end
+  end
+end