fog 1.0.0 → 1.5.0

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

@@ -7,10 +7,11 @@ module Fog
       class SecurityGroup < Fog::Model
 
         identity  :name,            :aliases => 'groupName'
-
         attribute :description,     :aliases => 'groupDescription'
+        attribute :group_id,        :aliases => 'groupId'
         attribute :ip_permissions,  :aliases => 'ipPermissions'
         attribute :owner_id,        :aliases => 'ownerId'
+        attribute :vpc_id,          :aliases => 'vpcId'
 
         # Authorize access by another security group
         #
@@ -39,12 +40,15 @@ module Fog
         #
 
         def authorize_group_and_owner(group, owner = nil)
-          requires :name
+          Fog::Logger.deprecation("authorize_group_and_ownder is deprecated, use authorize_port_range with :group option instead")
+
+          requires_one :name, :group_id
 
           connection.authorize_security_group_ingress(
             name,
-            'SourceSecurityGroupName'     => group,
-            'SourceSecurityGroupOwnerId'  => owner
+            'GroupId'                    => group_id,
+            'SourceSecurityGroupName'    => group,
+            'SourceSecurityGroupOwnerId' => owner
           )
         end
 
@@ -60,6 +64,7 @@ module Fog
         # options::
         #   A hash that can contain any of the following keys:
         #    :cidr_ip (defaults to "0.0.0.0/0")
+        #    :group - ("account:group_name" or "account:group_id"), cannot be used with :cidr_ip
         #    :ip_protocol (defaults to "tcp")
         #
         # == Returns:
@@ -77,14 +82,28 @@ module Fog
         #
 
         def authorize_port_range(range, options = {})
-          requires :name
+          requires_one :name, :group_id
+
+          ip_permission = {
+            'FromPort'   => range.min,
+            'ToPort'     => range.max,
+            'IpProtocol' => options[:ip_protocol] || 'tcp'
+          }
+
+          if options[:group].nil?
+            ip_permission['IpRanges'] = [
+              { 'CidrIp' => options[:cidr_ip] || '0.0.0.0/0' }
+            ]
+          else
+            ip_permission['Groups'] = [
+              group_info(options[:group])
+            ]
+          end
 
           connection.authorize_security_group_ingress(
             name,
-            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
-            'FromPort'    => range.min,
-            'ToPort'      => range.max,
-            'IpProtocol'  => options[:ip_protocol] || 'tcp'
+            'GroupId'       => group_id,
+            'IpPermissions' => [ ip_permission ]
           )
         end
 
@@ -98,9 +117,13 @@ module Fog
         #
 
         def destroy
-          requires :name
+          requires_one :name, :group_id
 
-          connection.delete_security_group(name)
+          if group_id.nil?
+            connection.delete_security_group(name)
+          else
+            connection.delete_security_group(nil, group_id)
+          end
           true
         end
 
@@ -131,12 +154,15 @@ module Fog
         #
 
         def revoke_group_and_owner(group, owner = nil)
-          requires :name
+          Fog::Logger.deprecation("revoke_group_and_owner is deprecated, use revoke_port_range with :group option instead")
+
+          requires_one :name, :group_id
 
           connection.revoke_security_group_ingress(
             name,
-            'SourceSecurityGroupName'     => group,
-            'SourceSecurityGroupOwnerId'  => owner
+            'GroupId'                    => group_id,
+            'SourceSecurityGroupName'    => group,
+            'SourceSecurityGroupOwnerId' => owner
           )
         end
 
@@ -152,6 +178,7 @@ module Fog
         # options::
         #   A hash that can contain any of the following keys:
         #    :cidr_ip (defaults to "0.0.0.0/0")
+        #    :group - ("account:group_name" or "account:group_id"), cannot be used with :cidr_ip
         #    :ip_protocol (defaults to "tcp")
         #
         # == Returns:
@@ -169,14 +196,28 @@ module Fog
         #
 
         def revoke_port_range(range, options = {})
-          requires :name
+          requires_one :name, :group_id
+
+          ip_permission = {
+            'FromPort'   => range.min,
+            'ToPort'     => range.max,
+            'IpProtocol' => options[:ip_protocol] || 'tcp'
+          }
+
+          if options[:group].nil?
+            ip_permission['IpRanges'] = [
+              { 'CidrIp' => options[:cidr_ip] || '0.0.0.0/0' }
+            ]
+          else
+            ip_permission['Groups'] = [
+              group_info(options[:group])
+            ]
+          end
 
           connection.revoke_security_group_ingress(
             name,
-            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
-            'FromPort'    => range.min,
-            'ToPort'      => range.max,
-            'IpProtocol'  => options[:ip_protocol] || 'tcp'
+            'GroupId'       => group_id,
+            'IpPermissions' => [ ip_permission ]
           )
         end
 
@@ -193,11 +234,34 @@ module Fog
 
         def save
           requires :description, :name
-
-          data = connection.create_security_group(name, description).body
+          data = connection.create_security_group(name, description, vpc_id).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
           true
         end
 
+        private
+
+        def group_info(group_str)
+          account, group = group_str.split(":")
+
+          if account.empty? || group.nil? || group.empty?
+            raise ArgumentError, "group must be specified in form of \"<account id>:<group name or id>\", #{group_str} given"
+          end
+
+          info = { 'UserId' => account }
+
+          if group.start_with?("sg-")
+            # we're dealing with a security group id
+            info['GroupId'] = group
+          else
+            # this has to be a security group name
+            info['GroupName'] = group
+          end
+
+          info
+        end
+
       end
 
     end

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

@@ -25,14 +25,15 @@ module Fog
         #    description=nil,
         #    ip_permissions=nil,
         #    owner_id=nil
+        #    vpc_id=nil
         #  >
         #
-        
+
         def initialize(attributes)
           self.filters ||= {}
           super
         end
-        
+
         # Returns an array of all security groups that have been created
         #
         # AWS.security_groups.all
@@ -50,6 +51,7 @@ module Fog
         #        description="default group",
         #        ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
         #        owner_id="312571045469"
+        #        vpc_id=nill
         #      >
         #    ]
         #  >
@@ -57,7 +59,7 @@ module Fog
 
         def all(filters = filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('group-name' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('group-name' => []) instead [light_black](#{caller.first})[/]")
             filters = {'group-name' => [*filters]}
           end
           self.filters = filters
@@ -65,7 +67,7 @@ module Fog
           load(data['securityGroupInfo'])
         end
 
-        # Used to retreive a security group
+        # Used to retrieve a security group
         # group name is required to get the associated flavor information.
         #
         # You can run the following command to get the details:
@@ -79,15 +81,38 @@ module Fog
         #    description="default group",
         #    ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
         #    owner_id="312571045469"
-        #  > 
+        #    vpc_id=nil
+        #  >
         #
-        
+
         def get(group_name)
           if group_name
             self.class.new(:connection => connection).all('group-name' => group_name).first
           end
         end
 
+        # Used to retrieve a security group
+        # group id is required to get the associated flavor information.
+        #
+        # You can run the following command to get the details:
+        # AWS.security_groups.get_by_id("default")
+        #
+        # ==== Returns
+        #
+        #>> AWS.security_groups.get_by_id("sg-123456")
+        #  <Fog::AWS::Compute::SecurityGroup
+        #    name="default",
+        #    description="default group",
+        #    ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
+        #    owner_id="312571045469"
+        #  >
+        #
+
+        def get_by_id(group_id)
+          if group_id
+            self.class.new(:connection => connection).all('group-id' => group_id).first
+          end
+        end
       end
 
     end

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

@@ -14,10 +14,12 @@ module Fog
         attribute :ami_launch_index,      :aliases => 'amiLaunchIndex'
         attribute :availability_zone,     :aliases => 'availabilityZone'
         attribute :block_device_mapping,  :aliases => 'blockDeviceMapping'
+        attribute :network_interfaces,    :aliases => 'networkInterfaces'
         attribute :client_token,          :aliases => 'clientToken'
         attribute :dns_name,              :aliases => 'dnsName'
         attribute :groups
         attribute :flavor_id,             :aliases => 'instanceType'
+        attribute :iam_instance_profile,  :aliases => 'iamInstanceProfile'
         attribute :image_id,              :aliases => 'imageId'
         attr_accessor :instance_initiated_shutdown_behavior
         attribute :kernel_id,             :aliases => 'kernelId'
@@ -34,18 +36,22 @@ module Fog
         attribute :reason
         attribute :root_device_name,      :aliases => 'rootDeviceName'
         attribute :root_device_type,      :aliases => 'rootDeviceType'
+        attribute :security_group_ids,    :aliases => 'securityGroupIds'
         attribute :state,                 :aliases => 'instanceState', :squash => 'name'
         attribute :state_reason,          :aliases => 'stateReason'
         attribute :subnet_id,             :aliases => 'subnetId'
         attribute :tenancy
         attribute :tags,                  :aliases => 'tagSet'
         attribute :user_data
+        attribute :vpc_id,                :aliases => 'vpcId'
 
         attr_accessor :password
         attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
+        attr_writer   :iam_instance_profile_name, :iam_instance_profile_arn
+
 
         def initialize(attributes={})
-          self.groups     ||= ["default"] unless attributes[:subnet_id]
+          self.groups     ||= ["default"] unless (attributes[:subnet_id] || attributes[:security_group_ids])
           self.flavor_id  ||= 't1.micro'
           self.image_id   ||= begin
             self.username = 'ubuntu'
@@ -60,6 +66,8 @@ module Fog
               'ami-3202f25b'
             when 'us-west-1'
               'ami-f5bfefb0'
+            when 'us-west-2'
+              'ami-e0ec60d0'
             end
           end
           super
@@ -142,6 +150,8 @@ module Fog
           options = {
             'BlockDeviceMapping'          => block_device_mapping,
             'ClientToken'                 => client_token,
+            'IamInstanceProfile.Arn'      => @iam_instance_profile_arn,
+            'IamInstanceProfile.Name'     => @iam_instance_profile_name,
             'InstanceInitiatedShutdownBehavior' => instance_initiated_shutdown_behavior,
             'InstanceType'                => flavor_id,
             'KernelId'                    => kernel_id,
@@ -150,16 +160,19 @@ module Fog
             'Placement.AvailabilityZone'  => availability_zone,
             'Placement.GroupName'         => placement_group,
             'Placement.Tenancy'           => tenancy,
+            'PrivateIpAddress'            => private_ip_address,
             'RamdiskId'                   => ramdisk_id,
             'SecurityGroup'               => groups,
+            'SecurityGroupId'             => security_group_ids,
             'SubnetId'                    => subnet_id,
-            'UserData'                    => user_data
+            'UserData'                    => user_data,
           }
           options.delete_if {|key, value| value.nil?}
 
-          # 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 is defined then this is a Virtual Private Cloud.
+          # subnet & security group cannot co-exist. Attempting to specify 
+          # both subnet and groups will cause an error.  Instead please make
+          # use of Security Group Ids when working in a VPC.
           if subnet_id
             options.delete('SecurityGroup')
           else
@@ -169,8 +182,10 @@ module Fog
           data = connection.run_instances(image_id, 1, 1, options)
           merge_attributes(data.body['instancesSet'].first)
 
-          if self.tags
-            for key, value in self.tags
+          if tags = self.tags
+            # expect eventual consistency
+            Fog.wait_for { self.reload rescue nil }
+            for key, value in (self.tags = tags)
               connection.tags.create(
                 :key          => key,
                 :resource_id  => self.identity,
@@ -184,31 +199,20 @@ module Fog
 
         def setup(credentials = {})
           requires :public_ip_address, :username
-          require 'multi_json'
           require 'net/ssh'
 
           commands = [
             %{mkdir .ssh},
             %{passwd -l #{username}},
-            %{echo "#{MultiJson.encode(Fog::JSON.sanitize(attributes))}" >> ~/attributes.json}
+            %{echo "#{Fog::JSON.encode(Fog::JSON.sanitize(attributes))}" >> ~/attributes.json}
           ]
           if public_key
             commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
           end
 
           # wait for aws to be ready
-          Timeout::timeout(360) do
-            begin
-              Timeout::timeout(8) do
-                Fog::SSH.new(public_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
-              end
-            rescue Errno::ECONNREFUSED
-              sleep(2)
-              retry
-            rescue Net::SSH::AuthenticationFailed, Timeout::Error
-              retry
-            end
-          end
+          wait_for { sshable? }
+
           Fog::SSH.new(public_ip_address, username, credentials).run(commands)
         end
 

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

@@ -57,7 +57,7 @@ module Fog
 
         def all(filters = self.filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('instance-id' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('instance-id' => []) instead [light_black](#{caller.first})[/]")
             filters = {'instance-id' => [*filters]}
           end
           self.filters = filters
@@ -65,7 +65,7 @@ module Fog
           load(
             data['reservationSet'].map do |reservation|
               reservation['instancesSet'].map do |instance|
-                instance.merge(:groups => reservation['groupSet'])
+                instance.merge(:groups => reservation['groupSet'], :security_group_ids => reservation['groupIds'])
               end
             end.flatten
           )
@@ -103,7 +103,7 @@ module Fog
           server
         end
 
-        # Used to retreive a server
+        # Used to retrieve a server
         #
         # server_id is required to get the associated server information.
         #
@@ -142,7 +142,7 @@ module Fog
         #    user_data=nil
         #  >
         #
-        
+
         def get(server_id)
           if server_id
             self.class.new(:connection => connection).all('instance-id' => server_id).first

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

@@ -19,7 +19,7 @@ module Fog
 
         def all(filters = filters, options = {})
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('snapshot-id' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('snapshot-id' => []) instead [light_black](#{caller.first})[/]")
             filters = {'snapshot-id' => [*filters]}
           end
           self.filters = filters

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

@@ -31,6 +31,8 @@ module Fog
         attribute :tags,                       :aliases => 'tagSet'
         attribute :fault,                      :squash  => 'message'
         attribute :user_data
+        
+        attr_writer   :private_key, :private_key_path, :public_key, :public_key_path
 
         attr_writer :username
 
@@ -55,6 +57,45 @@ module Fog
           super
         end
 
+        def destroy
+          requires :id
+
+          connection.cancel_spot_instance_requests(id)
+          true
+        end
+
+        def key_pair
+          requires :key_name
+
+          connection.key_pairs.all(key_name).first
+        end
+
+        def key_pair=(new_keypair)
+          self.key_name = new_keypair && new_keypair.name
+        end
+        
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
+        def ready?
+          state == 'active'
+        end
+
         def save
           requires :image_id, :flavor_id, :price
 
@@ -83,10 +124,6 @@ module Fog
           merge_attributes( spot_instance_request )
         end
 
-        def ready?
-          state == 'active'
-        end
-
       end
     end
   end

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

@@ -17,7 +17,7 @@ module Fog
 
         def all(filters = self.filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('spot-instance-request-id' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('spot-instance-request-id' => []) instead [light_black](#{caller.first})[/]")
             filters = {'spot-instance-request-id' => [*filters]}
           end
           self.filters = filters
@@ -34,6 +34,50 @@ module Fog
           )
         end
 
+        def bootstrap(new_attributes = {})
+          spot_request = connection.spot_requests.new(new_attributes)
+
+          unless new_attributes[:key_name]
+            # first or create fog_#{credential} keypair
+            name = Fog.respond_to?(:credential) && Fog.credential || :default
+            unless spot_request.key_pair = connection.key_pairs.get("fog_#{name}")
+              spot_request.key_pair = connection.key_pairs.create(
+                :name => "fog_#{name}",
+                :public_key => spot_request.public_key
+              )
+            end
+          end
+
+          # make sure port 22 is open in the first security group
+          security_group = connection.security_groups.get(spot_request.groups.first)
+          authorized = security_group.ip_permissions.detect do |ip_permission|
+            ip_permission['ipRanges'].first && ip_permission['ipRanges'].first['cidrIp'] == '0.0.0.0/0' &&
+            ip_permission['fromPort'] == 22 &&
+            ip_permission['ipProtocol'] == 'tcp' &&
+            ip_permission['toPort'] == 22
+          end
+          unless authorized
+            security_group.authorize_port_range(22..22)
+          end
+
+          spot_request.save
+          spot_request.wait_for(Fog.timeout, interval=4) { ready? }
+          Fog.wait_for { server = connection.servers.get(spot_request.reload.instance_id) }
+          server = connection.servers.get(spot_request.instance_id)
+          if spot_request.tags
+            for key, value in spot_request.tags
+              connection.tags.create(
+                :key          => key,
+                :resource_id  => spot_request.instance_id,
+                :value        => value
+              )
+            end
+          end
+          server.wait_for { ready? }
+          server.setup(:key_data => [spot_request.private_key])
+          server
+        end
+
         def get(spot_request_id)
           if spot_request_id
             self.class.new(:connection => connection).all('spot-instance-request-id' => spot_request_id).first

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

@@ -0,0 +1,57 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class AWS
+
+      class Subnet < Fog::Model
+
+        identity  :subnet_id,                   :aliases => 'subnetId'
+        attribute :state     
+        attribute :vpc_id,                      :aliases => 'vpcId'
+        attribute :cidr_block,                  :aliases => 'cidrBlock'
+        attribute :available_ip_address_count,  :aliases => 'availableIpAddressCount'
+        attribute :availability_zone,           :aliases => 'availabilityZone'
+        attribute :tag_set,                     :aliases => 'tagSet'
+
+
+        # Removes an existing subnet
+        #
+        # subnet.destroy
+        #
+        # ==== Returns
+        #
+        # True or false depending on the result
+        #
+
+        def destroy
+          requires :subnet_id
+
+          connection.delete_subnet(subnet_id)
+          true
+        end
+
+        # Create a subnet
+        #
+        #  >> g = AWS.subnets.new(:vpc_id => "vpc-someId", :cidr_block => "10.0.0.0/24")
+        #  >> g.save
+        #
+        # == Returns:
+        #
+        # requestId and a subnetSet object
+        #
+
+        def save
+          requires :vpc_id, :cidr_block
+          data = connection.create_subnet(vpc_id, cidr_block).body['subnetSet'].first
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          true
+
+          true
+        end
+
+      end
+    end
+  end
+end