fog 0.2.30 → 0.3.0

data/lib/fog/aws/elb.rb

@@ -1,22 +1,20 @@
 module Fog
   module AWS
-    module ELB
-      extend Fog::Service
+    class ELB < Fog::Service
 
       requires :aws_access_key_id, :aws_secret_access_key
 
       request_path 'fog/aws/requests/elb'
-      request 'create_load_balancer'
-      request 'delete_load_balancer'
-      request 'deregister_instances_from_load_balancer'
-      request 'describe_instance_health'
-      request 'describe_load_balancers'
-      request 'disable_availability_zones_for_load_balancer'
-      request 'enable_availability_zones_for_load_balancer'
-      request 'register_instances_with_load_balancer'
+      request :create_load_balancer
+      request :delete_load_balancer
+      request :deregister_instances_from_load_balancer
+      request :describe_instance_health
+      request :describe_load_balancers
+      request :disable_availability_zones_for_load_balancer
+      request :enable_availability_zones_for_load_balancer
+      request :register_instances_with_load_balancer
 
       class Mock
-        include Collections
 
         def initialize(options={})
           Fog::Mock.not_implemented
@@ -25,7 +23,6 @@ module Fog
       end
 
       class Real
-        include Collections
 
         # Initialize connection to ELB
         #

data/lib/fog/aws/models/{ec2 → compute}/address.rb

@@ -2,13 +2,13 @@ require 'fog/model'
 
 module Fog
   module AWS
-    module EC2
+    class Compute
 
       class Address < Fog::Model
 
-        identity  :public_ip,   'publicIp'
+        identity  :public_ip, :aliases => 'publicIp'
 
-        attribute :server_id, 'instanceId'
+        attribute :server_id, :aliases => 'instanceId'
 
         def initialize(attributes = {})
           # assign server first to prevent race condition with new_record?

data/lib/fog/aws/models/{ec2 → compute}/addresses.rb

@@ -1,24 +1,16 @@
 require 'fog/collection'
-require 'fog/aws/models/ec2/address'
+require 'fog/aws/models/compute/address'
 
 module Fog
   module AWS
-    module EC2
-
-      module Collections
-        def addresses(attributes = {})
-          Fog::AWS::EC2::Addresses.new({
-            :connection => self
-          }.merge!(attributes))
-        end
-      end
+    class Compute
 
       class Addresses < Fog::Collection
 
         attribute :public_ip
         attribute :server
 
-        model Fog::AWS::EC2::Address
+        model Fog::AWS::Compute::Address
 
         def initialize(attributes)
           @public_ip ||= []

data/lib/fog/aws/models/{ec2 → compute}/flavor.rb

@@ -2,7 +2,7 @@ require 'fog/model'
 
 module Fog
   module AWS
-    module EC2
+    class Compute
 
       class Flavor < Fog::Model
 
@@ -18,4 +18,4 @@ module Fog
 
     end
   end
-end
+end

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

@@ -0,0 +1,39 @@
+require 'fog/collection'
+require 'fog/aws/models/compute/flavor'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::AWS::Compute::Flavor
+
+        def all
+          data = [
+            { :bits => 0,  :cores => 2,   :disk => 0,    :id => 't1.micro',   :name => 'Micro Instance',       :ram => 613},
+
+            { :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/compute/image.rb

@@ -0,0 +1,44 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id,                     :aliases => 'imageId'
+
+        attribute :architecture
+        attribute :block_device_mapping,  :aliases => 'blockDeviceMapping'
+        attribute :location,              :aliases => 'imageLocation'
+        attribute :owner_id,              :aliases => 'imageOwnerId'
+        attribute :state,                 :aliases => 'imageState'
+        attribute :type,                  :aliases => 'imageType'
+        attribute :is_public,             :aliases => 'isPublic'
+        attribute :kernel_id,             :aliases => 'kernelId'
+        attribute :platform
+        attribute :product_codes,         :aliases => 'productCodes'
+        attribute :ramdisk_id,            :aliases => 'ramdiskId'
+        attribute :root_device_type,      :aliases => 'rootDeviceType'
+        attribute :root_device_name,      :aliases => '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 → compute}/images.rb

@@ -1,21 +1,15 @@
 require 'fog/collection'
-require 'fog/aws/models/ec2/image'
+require 'fog/aws/models/compute/image'
 
 module Fog
   module AWS
-    module EC2
-
-      module Collections
-        def images
-          Fog::AWS::EC2::Images.new(:connection => self)
-        end
-      end
+    class Compute
 
       class Images < Fog::Collection
 
         attribute :image_id
 
-        model Fog::AWS::EC2::Image
+        model Fog::AWS::Compute::Image
 
         def initialize(attributes)
           @image_id ||= []

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

@@ -0,0 +1,44 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class KeyPair < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:material, :private_key)
+
+        identity  :name,        :aliases => 'keyName'
+
+        attribute :fingerprint, :aliases => 'keyFingerprint'
+        attribute :private_key, :aliases => 'keyMaterial'
+
+        attr_accessor :public_key
+
+        def destroy
+          requires :name
+
+          connection.delete_key_pair(@name)
+          true
+        end
+
+        def save
+          requires :name
+
+          data = if public_key
+            connection.import_key_pair(name, public_key).body
+          else
+            connection.create_key_pair(name).body
+          end
+          new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
+          merge_attributes(new_attributes)
+          true
+        end
+
+        private
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/{ec2 → compute}/key_pairs.rb

@@ -1,21 +1,15 @@
 require 'fog/collection'
-require 'fog/aws/models/ec2/key_pair'
+require 'fog/aws/models/compute/key_pair'
 
 module Fog
   module AWS
-    module EC2
-
-      module Collections
-        def key_pairs
-          Fog::AWS::EC2::KeyPairs.new(:connection => self)
-        end
-      end
+    class Compute
 
       class KeyPairs < Fog::Collection
 
         attribute :key_name
 
-        model Fog::AWS::EC2::KeyPair
+        model Fog::AWS::Compute::KeyPair
 
         def initialize(attributes)
           @key_name ||= []

data/lib/fog/aws/models/{ec2 → compute}/security_group.rb

@@ -2,15 +2,15 @@ require 'fog/model'
 
 module Fog
   module AWS
-    module EC2
+    class Compute
 
       class SecurityGroup < Fog::Model
 
-        identity  :name,            'groupName'
+        identity  :name,            :aliases => 'groupName'
 
-        attribute :description,     'groupDescription'
-        attribute :ip_permissions,  'ipPermissions'
-        attribute :owner_id,        'ownerId'
+        attribute :description,     :aliases => 'groupDescription'
+        attribute :ip_permissions,  :aliases => 'ipPermissions'
+        attribute :owner_id,        :aliases => 'ownerId'
 
         def authorize_group_and_owner(group, owner)
           requires :name
@@ -30,7 +30,7 @@ module Fog
             'FromPort'    => range.min,
             'GroupName'   => @name,
             'ToPort'      => range.max,
-            'IpProtocol'  => options[:ip_protocol] || 'tcp' 
+            'IpProtocol'  => options[:ip_protocol] || 'tcp'
           )
         end
 
@@ -41,6 +41,28 @@ module Fog
           true
         end
 
+        def revoke_group_and_owner(group, owner)
+          requires :name
+
+          connection.revoke_security_group_ingress(
+            'GroupName'                   => @name,
+            'SourceSecurityGroupName'     => group,
+            'SourceSecurityGroupOwnerId'  => owner
+          )
+        end
+
+        def revoke_port_range(range, options = {})
+          requires :name
+
+          connection.revoke_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 save
           requires :description, :name
 

data/lib/fog/aws/models/{ec2 → compute}/security_groups.rb

@@ -1,21 +1,15 @@
 require 'fog/collection'
-require 'fog/aws/models/ec2/security_group'
+require 'fog/aws/models/compute/security_group'
 
 module Fog
   module AWS
-    module EC2
-
-      module Collections
-        def security_groups
-          Fog::AWS::EC2::SecurityGroups.new(:connection => self)
-        end
-      end
+    class Compute
 
       class SecurityGroups < Fog::Collection
 
         attribute :group_name
 
-        model Fog::AWS::EC2::SecurityGroup
+        model Fog::AWS::Compute::SecurityGroup
 
         def initialize(attributes)
           @group_name ||= []

data/lib/fog/aws/models/{ec2 → compute}/server.rb

@@ -2,36 +2,39 @@ require 'fog/model'
 
 module Fog
   module AWS
-    module EC2
+    class Compute
 
       class Server < Fog::Model
 
-        identity  :id,                    'instanceId'
+        identity  :id,                    :aliases => 'instanceId'
 
         attr_accessor :architecture
-        attribute :ami_launch_index,      'amiLaunchIndex'
-        attribute :availability_zone,     'availabilityZone'
-        attribute :block_device_mapping,  'blockDeviceMapping'
-        attribute :dns_name,              'dnsName'
+        attribute :ami_launch_index,      :aliases => 'amiLaunchIndex'
+        attribute :availability_zone,     :aliases => 'availabilityZone'
+        attribute :block_device_mapping,  :aliases => 'blockDeviceMapping'
+        attribute :dns_name,              :aliases => '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 :flavor_id,             :aliases => 'instanceType'
+        attribute :image_id,              :aliases => 'imageId'
+        attribute :ip_address,            :aliases => 'ipAddress'
+        attribute :kernel_id,             :aliases => 'kernelId'
+        attribute :key_name,              :aliases => 'keyName'
+        attribute :created_at,            :aliases => 'launchTime'
         attribute :monitoring
-        attribute :product_codes,         'productCodes'
-        attribute :private_dns_name,      'privateDnsName'
-        attribute :private_ip_address,    'privateIpAddress'
-        attribute :ramdisk_id,            'ramdiskId'
+        attribute :product_codes,         :aliases => 'productCodes'
+        attribute :private_dns_name,      :aliases => 'privateDnsName'
+        attribute :private_ip_address,    :aliases => 'privateIpAddress'
+        attribute :ramdisk_id,            :aliases => 'ramdiskId'
         attribute :reason
-        attribute :root_device_name,      'rootDeviceName'
-        attribute :root_device_type,      'rootDeviceType'
-        attribute :state,                 'instanceState'
-        attribute :subnet_id,             'subnetId'
+        attribute :root_device_name,      :aliases => 'rootDeviceName'
+        attribute :root_device_type,      :aliases => 'rootDeviceType'
+        attribute :state,                 :aliases => 'instanceState'
+        attribute :subnet_id,             :aliases => 'subnetId'
         attribute :user_data
 
+        attr_accessor :password, :username
+        attr_writer   :private_key_path, :public_key_path
+
         def initialize(attributes={})
           @groups ||= ["default"] unless attributes[:subnet_id]
           @flavor_id ||= 'm1.small'
@@ -57,14 +60,6 @@ module Fog
           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
@@ -103,6 +98,14 @@ module Fog
           end
         end
 
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+        end
+
         def ready?
           @state == 'running'
         end
@@ -117,18 +120,18 @@ module Fog
           requires :image_id
 
           options = {
-            'BlockDeviceMapping'          => @block_device_mapping,
+            '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,
+            'KernelId'                    => kernel_id,
+            'KeyName'                     => key_name,
+            'Monitoring.Enabled'          => monitoring,
+            'Placement.AvailabilityZone'  => availability_zone,
+            'RamdiskId'                   => ramdisk_id,
+            'SecurityGroup'               => groups,
             'SubnetId'                    => subnet_id,
-            'UserData'                    => @user_data
+            '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!
@@ -138,11 +141,31 @@ module Fog
             options.delete('SubnetId')
           end
 
-          data = connection.run_instances(@image_id, 1, 1, options)
+          data = connection.run_instances(image_id, 1, 1, options)
           merge_attributes(data.body['instancesSet'].first)
           true
         end
 
+        def setup(credentials = {})
+          requires :ip_address, :identity, :public_key_path, :username
+          sleep(10) # takes a bit before EC2 instances will play nice
+          Fog::SSH.new(ip_address, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{File.read(public_key_path)}" >> ~/.ssh/authorized_keys},
+            %{passwd -l root},
+            %{echo "#{attributes.to_json}" >> ~/attributes.json}
+          ])
+        rescue Errno::ECONNREFUSED => e
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :identity, :ip_address, :private_key_path, :username
+          @ssh ||= Fog::SSH.new(ip_address, username, :keys => [private_key_path])
+          @ssh.run(commands)
+        end
+
         def start
           requires :id
           connection.start_instances(@id)
@@ -155,6 +178,10 @@ module Fog
           true
         end
 
+        def username
+          @username ||= 'root'
+        end
+
         def volumes
           requires :id