fog-aws 0.11.0 → 3.18.0

data/lib/fog/aws/requests/compute/authorize_security_group_egress.rb

@@ -0,0 +1,114 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # Add permissions to a security group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of group, optional (can also be specifed as GroupName in options)
+        # * options<~Hash>:
+        #   * 'GroupName'<~String> - Name of security group to modify
+        #   * 'GroupId'<~String> - Id of security group to modify
+        #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
+        #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
+        #   or
+        #   * 'CidrIp'<~String> - CIDR range
+        #   * 'FromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
+        #   * 'IpProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #   * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
+        #   or
+        #   * 'IpPermissions'<~Array>:
+        #     * permission<~Hash>:
+        #       * 'FromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
+        #       * 'Groups'<~Array>:
+        #         * group<~Hash>:
+        #           * 'GroupName'<~String> - Name of security group to authorize
+        #           * 'UserId'<~String> - Name of owner to authorize
+        #       * 'IpProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #       * 'IpRanges'<~Array>:
+        #         * ip_range<~Hash>:
+        #           * 'CidrIp'<~String> - CIDR range
+        #       * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AuthorizeSecurityGroupEgress.html]
+        def authorize_security_group_egress(group_name, options = {})
+          options = Fog::AWS.parse_security_group_options(group_name, options)
+
+          if ip_permissions = options.delete('IpPermissions')
+            options.merge!(indexed_ip_permissions_params(ip_permissions))
+          end
+
+          request({
+            'Action'    => 'AuthorizeSecurityGroupEgress',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def authorize_security_group_egress(group_name, options = {})
+          options = Fog::AWS.parse_security_group_options(group_name, options)
+
+          group = if options.key?('GroupName')
+                    self.data[:security_groups].values.find { |v| v['groupName'] == options['GroupName'] }
+                  else
+                    self.data[:security_groups][options.fetch('GroupId')]
+                  end
+
+          response = Excon::Response.new
+          group ||
+            raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name}' does not exist"))
+
+          verify_permission_options(options, group['vpcId'] != nil)
+
+          normalized_permissions = normalize_permissions(options)
+
+          normalized_permissions.each do |permission|
+            if matching_group_permission = find_matching_permission_egress(group, permission)
+              if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
+                raise Fog::AWS::Compute::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
+              end
+
+              if permission['ipRanges'].any? {|pr| matching_group_permission['ipRanges'].include?(pr) }
+                raise Fog::AWS::Compute::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
+              end
+            end
+          end
+
+          normalized_permissions.each do |permission|
+            if matching_group_permission = find_matching_permission_egress(group, permission)
+              matching_group_permission['groups'] += permission['groups']
+              matching_group_permission['ipRanges'] += permission['ipRanges']
+            else
+              group['ipPermissionsEgress'] << permission
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+        def find_matching_permission_egress(group, permission)
+          group['ipPermissionsEgress'].find do |group_permission|
+            permission['ipProtocol'] == group_permission['ipProtocol'] &&
+              permission['fromPort'] == group_permission['fromPort'] &&
+              permission['toPort'] == group_permission['toPort']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/authorize_security_group_ingress.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -30,6 +30,9 @@ module Fog
         #       * 'IpRanges'<~Array>:
         #         * ip_range<~Hash>:
         #           * 'CidrIp'<~String> - CIDR range
+        #       * 'Ipv6Ranges'<~Array>:
+        #         * ip_range<~Hash>:
+        #           * 'CidrIpv6'<~String> - CIDR range
         #       * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
         #
         # === Returns
@@ -49,7 +52,7 @@ module Fog
           request({
             'Action'    => 'AuthorizeSecurityGroupIngress',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(options))
         end
 
@@ -72,6 +75,10 @@ module Fog
               range_index += 1
               params[format('IpPermissions.%d.IpRanges.%d.CidrIp', key_index, range_index)] = ip_range['CidrIp']
             end
+            (permission['Ipv6Ranges'] || []).each_with_index do |ip_range, range_index|
+              range_index += 1
+              params[format('IpPermissions.%d.Ipv6Ranges.%d.CidrIpv6', key_index, range_index)] = ip_range['CidrIpv6']
+            end
           end
           params.reject {|k, v| v.nil? }
         end
@@ -80,14 +87,16 @@ module Fog
       class Mock
         def authorize_security_group_ingress(group_name, options = {})
           options = Fog::AWS.parse_security_group_options(group_name, options)
-          if options.key?('GroupName')
-            group_name = options['GroupName']
-          else
-            group_name = self.data[:security_groups].reject { |k,v| v['groupId'] != options['GroupId'] } .keys.first
-          end
+
+          group = if options.key?('GroupName')
+                    self.data[:security_groups].values.find { |v| v['groupName'] == options['GroupName'] }
+                  else
+                    self.data[:security_groups][options.fetch('GroupId')]
+                  end
 
           response = Excon::Response.new
-          group = self.data[:security_groups][group_name] || raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
+          group ||
+            raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name}' does not exist"))
 
           verify_permission_options(options, group['vpcId'] != nil)
 
@@ -96,11 +105,11 @@ module Fog
           normalized_permissions.each do |permission|
             if matching_group_permission = find_matching_permission(group, permission)
               if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
-                raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
+                raise Fog::AWS::Compute::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
               end
 
               if permission['ipRanges'].any? {|pr| matching_group_permission['ipRanges'].include?(pr) }
-                raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
+                raise Fog::AWS::Compute::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
               end
             end
           end
@@ -126,17 +135,17 @@ module Fog
 
         def verify_permission_options(options, is_vpc)
           if options.size <= 1
-            raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
+            raise Fog::AWS::Compute::Error.new("InvalidRequest => The request received was invalid.")
           end
           if !is_vpc && options['IpProtocol'] && !['tcp', 'udp', 'icmp'].include?(options['IpProtocol'])
-            raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => Unsupported IP protocol \"#{options['IpProtocol']}\"  - supported: [tcp, udp, icmp]")
+            raise Fog::AWS::Compute::Error.new("InvalidPermission.Malformed => Unsupported IP protocol \"#{options['IpProtocol']}\"  - supported: [tcp, udp, icmp]")
           end
           if !is_vpc && (options['IpProtocol'] && (!options['FromPort'] || !options['ToPort']))
-            raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => TCP/UDP port (-1) out of range")
+            raise Fog::AWS::Compute::Error.new("InvalidPermission.Malformed => TCP/UDP port (-1) out of range")
           end
           if options.key?('IpPermissions')
             if !options['IpPermissions'].is_a?(Array) || options['IpPermissions'].empty?
-              raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
+              raise Fog::AWS::Compute::Error.new("InvalidRequest => The request received was invalid.")
             end
             options['IpPermissions'].each {|p| verify_permission_options(p, is_vpc) }
           end
@@ -150,14 +159,15 @@ module Fog
                          else
                            options['SourceSecurityGroupName']
                          end
-            source_group_id=self.data[:security_groups][group_name]['groupId']
+            source_group_id, _ = self.data[:security_groups].find { |_,v| v['groupName'] == group_name }
+
             ['tcp', 'udp'].each do |protocol|
               normalized_permissions << {
                 'ipProtocol' => protocol,
                 'fromPort'   => 1,
                 'toPort'     => 65535,
                 'groups'     => [{
-                  'groupName' => options['SourceSecurityGroupName'],
+                  'groupName' => group_name,
                   'userId'    => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id],
                   'groupId'   => source_group_id
                 }],
@@ -169,7 +179,7 @@ module Fog
               'fromPort'   => -1,
               'toPort'     => -1,
               'groups'     => [{
-                'groupName' => options['SourceSecurityGroupName'],
+                'groupName' => group_name,
                 'userId'    => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id],
                 'groupId'   => source_group_id
               }],
@@ -183,23 +193,32 @@ module Fog
               'groups'     => [],
               'ipRanges'   => [{'cidrIp' => options['CidrIp']}]
             }
+          elsif options['CidrIpv6']
+            normalized_permissions << {
+              'ipProtocol' => options['IpProtocol'],
+              'fromPort'   => Integer(options['FromPort']),
+              'toPort'     => Integer(options['ToPort']),
+              'groups'     => [],
+              'ipv6Ranges' => [{'cidrIpv6' => options['CidrIpv6']}]
+            }
           elsif options['IpPermissions']
             options['IpPermissions'].each do |permission|
 
               groups = (permission['Groups'] || []).map do |authorized_group|
                 security_group = if group_name = authorized_group['GroupName']
-                                   self.data[:security_groups][group_name]
+                                   self.data[:security_groups].values.find { |sg| sg['groupName'] == group_name }
                                  elsif group_id = authorized_group['GroupId']
-                                   self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id }
-                                 end ||
-                                 raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
-
-                                 {
-                                   'groupName' => authorized_group['GroupName'] || security_group["groupName"],
-                                   'userId'    => authorized_group['UserId']    || self.data[:owner_id],
-                                   'groupId'   => authorized_group["GroupId"]   || security_group['groupId']
-                                 }
-                  end
+                                   self.data[:security_groups][group_id]
+                                 end
+                security_group ||
+                  raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
+
+                {
+                  'groupName' => authorized_group['GroupName'] || security_group['groupName'],
+                  'userId'    => authorized_group['UserId']    || self.data[:owner_id],
+                  'groupId'   => authorized_group["GroupId"]   || security_group['groupId']
+                }
+              end
 
 
               if ['tcp', 'udp', 'icmp'].include?(permission['IpProtocol'])
@@ -208,7 +227,7 @@ module Fog
                   'fromPort'   => Integer(permission['FromPort']),
                   'toPort'     => Integer(permission['ToPort']),
                   'groups'     => groups,
-                  'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
+                  'ipRanges'   => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
                 }
               else
                 normalized_permissions << {

data/lib/fog/aws/requests/compute/cancel_spot_instance_requests.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/cancel_spot_instance_requests'
 
@@ -23,10 +23,27 @@ module Fog
           request({
             'Action'    => 'CancelSpotInstanceRequests',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::CancelSpotInstanceRequests.new
+            :parser     => Fog::Parsers::AWS::Compute::CancelSpotInstanceRequests.new
           }.merge!(params))
         end
       end
+
+      class Mock
+        def cancel_spot_instance_requests(spot_instance_request_id)
+          response = Excon::Response.new
+          spot_request = self.data[:spot_requests][spot_instance_request_id]
+
+          unless spot_request
+            raise Fog::AWS::Compute::NotFound.new("The spot instance request ID '#{spot_instance_request_id}' does not exist")
+          end
+
+          spot_request['fault']['code'] = 'request-cancelled'
+          spot_request['state'] = 'cancelled'
+
+          response.body = {'spotInstanceRequestSet' => [{'spotInstanceRequestId' => spot_instance_request_id, 'state' => 'cancelled'}], 'requestId' => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/compute/copy_image.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/copy_image'
 
@@ -28,7 +28,7 @@ module Fog
             'Name'            => name,
             'Description'     => description,
             'ClientToken'     => client_token,
-            :parser           => Fog::Parsers::Compute::AWS::CopyImage.new
+            :parser           => Fog::Parsers::AWS::Compute::CopyImage.new
           )
         end
       end

data/lib/fog/aws/requests/compute/copy_snapshot.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/copy_snapshot'
 
@@ -9,6 +9,11 @@ module Fog
         # ==== Parameters
         # * source_snapshot_id<~String> - Id of snapshot
         # * source_region<~String>      - Region to move it from
+        # * options<~Hash>:
+        #   * 'Description'<~String>    - A description for the EBS snapshot
+        #   * 'Encrypted'<~Boolean>     - Specifies whether the destination snapshot should be encrypted
+        #   * 'KmsKeyId'<~String>       - The full ARN of the AWS Key Management Service (AWS KMS) CMK
+        #                                 to use when creating the snapshot copy.
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -17,14 +22,22 @@ module Fog
         #     * 'snapshotId'<~String> - id of snapshot
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CopySnapshot.html]
-        def copy_snapshot(source_snapshot_id, source_region, description = nil)
-          request(
-            'Action'          => 'CopySnapshot',
-            'SourceSnapshotId'=> source_snapshot_id,
-            'SourceRegion'    => source_region,
-            'Description'     => description,
-            :parser       => Fog::Parsers::Compute::AWS::CopySnapshot.new
-          )
+        def copy_snapshot(source_snapshot_id, source_region, options = {})
+          # For backward compatibility. In previous versions third param was a description
+          if options.is_a?(String)
+            Fog::Logger.warning("copy_snapshot with description as a string in third param is deprecated, use hash instead: copy_snapshot('source-id', 'source-region', { 'Description' => 'some description' })")
+            options = { 'Description' => options }
+          end
+          params              = {
+            'Action'           => 'CopySnapshot',
+            'SourceSnapshotId' => source_snapshot_id,
+            'SourceRegion'     => source_region,
+            'Description'      => options['Description'],
+            :parser            => Fog::Parsers::AWS::Compute::CopySnapshot.new
+          }
+          params['Encrypted'] = true if options['Encrypted']
+          params['KmsKeyId']  = options['KmsKeyId'] if options['Encrypted'] && options['KmsKeyId']
+          request(params)
         end
       end
 
@@ -35,7 +48,7 @@ module Fog
         # Fog::AWS[:compute].copy_snapshot("snap-1db0a957", 'us-east-1')
         #
 
-        def copy_snapshot(source_snapshot_id, source_region, description = nil)
+        def copy_snapshot(source_snapshot_id, source_region, options = {})
           response = Excon::Response.new
           response.status = 200
           snapshot_id = Fog::AWS::Mock.snapshot_id

data/lib/fog/aws/requests/compute/create_dhcp_options.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_dhcp_options'
 
@@ -21,7 +21,7 @@ module Fog
           request({
             'Action'    => 'CreateDhcpOptions',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::CreateDhcpOptions.new
+            :parser     => Fog::Parsers::AWS::Compute::CreateDhcpOptions.new
           }.merge!(params))
         end
         private

data/lib/fog/aws/requests/compute/create_image.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_image'
 
@@ -39,7 +39,7 @@ module Fog
             'Name'              => name,
             'Description'       => description,
             'NoReboot'          => no_reboot.to_s,
-            :parser             => Fog::Parsers::Compute::AWS::CreateImage.new
+            :parser             => Fog::Parsers::AWS::Compute::CreateImage.new
           }.merge!(params))
         end
       end

data/lib/fog/aws/requests/compute/create_internet_gateway.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_internet_gateway'
 
@@ -25,7 +25,7 @@ module Fog
         def create_internet_gateway()
           request({
             'Action'     => 'CreateInternetGateway',
-            :parser      => Fog::Parsers::Compute::AWS::CreateInternetGateway.new
+            :parser      => Fog::Parsers::AWS::Compute::CreateInternetGateway.new
           })
         end
       end

data/lib/fog/aws/requests/compute/create_key_pair.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_key_pair'
 
@@ -22,7 +22,7 @@ module Fog
           request(
             'Action'  => 'CreateKeyPair',
             'KeyName' => key_name,
-            :parser   => Fog::Parsers::Compute::AWS::CreateKeyPair.new
+            :parser   => Fog::Parsers::AWS::Compute::CreateKeyPair.new
           )
         end
       end
@@ -43,7 +43,7 @@ module Fog
             }.merge!(data)
             response
           else
-            raise Fog::Compute::AWS::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
+            raise Fog::AWS::Compute::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
           end
         end
       end

data/lib/fog/aws/requests/compute/create_network_acl.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_network_acl'
 
@@ -42,7 +42,7 @@ module Fog
           request({
             'Action' => 'CreateNetworkAcl',
             'VpcId'  => vpcId,
-            :parser  => Fog::Parsers::Compute::AWS::CreateNetworkAcl.new
+            :parser  => Fog::Parsers::AWS::Compute::CreateNetworkAcl.new
           }.merge!(options))
         end
       end
@@ -54,7 +54,7 @@ module Fog
             id = Fog::AWS::Mock.network_acl_id
 
             unless self.data[:vpcs].find { |s| s['vpcId'] == vpcId }
-              raise Fog::Compute::AWS::Error.new("Unknown VPC '#{vpcId}' specified")
+              raise Fog::AWS::Compute::Error.new("Unknown VPC '#{vpcId}' specified")
             end
 
             data = {

data/lib/fog/aws/requests/compute/create_network_acl_entry.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -35,7 +35,7 @@ module Fog
             'RuleAction'   => rule_action,
             'Egress'       => egress,
             'CidrBlock'    => cidr_block,
-            :parser        => Fog::Parsers::Compute::AWS::Basic.new
+            :parser        => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(options))
         end
       end
@@ -46,7 +46,7 @@ module Fog
           if self.data[:network_acls][network_acl_id]
 
             if self.data[:network_acls][network_acl_id]['entrySet'].find { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
-              raise Fog::Compute::AWS::Error.new("Already a rule with that number")
+              raise Fog::AWS::Compute::Error.new("Already a rule with that number")
             end
 
             data = {
@@ -71,7 +71,7 @@ module Fog
             }
             response
           else
-            raise Fog::Compute::AWS::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
           end
         end
       end

data/lib/fog/aws/requests/compute/create_network_interface.rb

@@ -1,7 +1,8 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
+        require 'ipaddr'
         require 'fog/aws/parsers/compute/create_network_interface'
 
         # Creates a network interface
@@ -54,7 +55,7 @@ module Fog
           request({
             'Action'     => 'CreateNetworkInterface',
             'SubnetId'   => subnetId,
-            :parser      => Fog::Parsers::Compute::AWS::CreateNetworkInterface.new
+            :parser      => Fog::Parsers::AWS::Compute::CreateNetworkInterface.new
           }.merge!(options))
         end
       end
@@ -65,35 +66,37 @@ module Fog
           if subnetId
             subnet = self.data[:subnets].find{ |s| s['subnetId'] == subnetId }
             if subnet.nil?
-              raise Fog::Compute::AWS::Error.new("Unknown subnet '#{subnetId}' specified")
+              raise Fog::AWS::Compute::Error.new("Unknown subnet '#{subnetId}' specified")
             else
               id = Fog::AWS::Mock.network_interface_id
-              cidr_block = IPAddress.parse(subnet['cidrBlock'])
+              cidr_block = IPAddr.new(subnet['cidrBlock'])
 
               groups = {}
               if options['GroupSet']
                 options['GroupSet'].each do |group_id|
-                  group_obj = self.data[:security_groups].select { |k,v| v['groupId'] == group_id }.first
+                  group_obj = self.data[:security_groups][group_id]
                   if group_obj.nil?
-                    raise Fog::Compute::AWS::Error.new("Unknown security group '#{group_id}' specified")
+                    raise Fog::AWS::Compute::Error.new("Unknown security group '#{group_id}' specified")
                   end
-                  groups[group_id] = group_obj
+                  groups[group_id] = group_obj['groupName']
                 end
               end
 
               if options['PrivateIpAddress'].nil?
+                range = cidr_block.to_range
                 # Here we try to act like a DHCP server and pick the first
                 # available IP (not including the first in the cidr block,
                 # which is typically reserved for the gateway).
-                cidr_block.each_host do |p_ip|
-                  unless self.data[:network_interfaces].map{ |ni, ni_conf| ni_conf['privateIpAddress'] }.include?p_ip.to_s ||
-                    cidr_block.first == p_ip
+                range = range.drop(2)[0..-2] if cidr_block.ipv4?
+
+                range.each do |p_ip|
+                  unless self.data[:network_interfaces].map{ |ni, ni_conf| ni_conf['privateIpAddress'] }.include?p_ip.to_s
                     options['PrivateIpAddress'] = p_ip.to_s
                     break
                   end
                 end
               elsif self.data[:network_interfaces].map{ |ni,ni_conf| ni_conf['privateIpAddress'] }.include?options['PrivateIpAddress']
-                raise Fog::Compute::AWS::Error.new('InUse => The specified address is already in use.')
+                raise Fog::AWS::Compute::Error.new('InUse => The specified address is already in use.')
               end
 
               data = {

data/lib/fog/aws/requests/compute/create_placement_group.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -22,7 +22,7 @@ module Fog
             'Action'            => 'CreatePlacementGroup',
             'GroupName'         => name,
             'Strategy'          => strategy,
-            :parser             => Fog::Parsers::Compute::AWS::Basic.new
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
           )
         end
       end