fog-aws 1.4.1 → 2.0.0

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

@@ -18,15 +18,17 @@ module Fog
         # * body<~Hash>:
         # * 'requestId'<~String> - Id of request
         # * 'subnet'<~Array>:
-        # * 'subnetId'<~String> - The Subnet's ID
-        # * 'state'<~String> - The current state of the Subnet. ['pending', 'available']
-        # * 'cidrBlock'<~String> - The CIDR block the Subnet covers.
-        # * 'AvailableIpAddressCount'<~Integer> - The number of unused IP addresses in the subnet (the IP addresses for any stopped
-        #   instances are considered unavailable)
-        # * 'AvailabilityZone'<~String> - The Availability Zone the subnet is in
-        # * 'tagSet'<~Array>: Tags assigned to the resource.
-        # * 'key'<~String> - Tag's key
-        # * 'value'<~String> - Tag's value
+        #   * 'subnetId'<~String> - The Subnet's ID
+        #   * 'state'<~String> - The current state of the Subnet. ['pending', 'available']
+        #   * 'cidrBlock'<~String> - The CIDR block the Subnet covers.
+        #   * 'availableIpAddressCount'<~Integer> - The number of unused IP addresses in the subnet (the IP addresses for any stopped
+        #     instances are considered unavailable)
+        #   * 'availabilityZone'<~String> - The Availability Zone the subnet is in
+        #   * 'tagSet'<~Array>: Tags assigned to the resource.
+        #     * 'key'<~String> - Tag's key
+        #     * 'value'<~String> - Tag's value
+        #   * 'mapPublicIpOnLaunch'<~Boolean> - Indicates whether instances launched in this subnet receive a public IPv4 address.
+        #   * 'defaultForAz'<~Boolean> - Indicates whether this is the default subnet for the Availability Zone.
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/ApiReference-query-CreateSubnet.html]
         def create_subnet(vpcId, cidrBlock, options = {})
@@ -65,7 +67,9 @@ module Fog
                 'cidrBlock'                => cidrBlock,
                 'availableIpAddressCount'  => "255",
                 'availabilityZone'         => av_zone,
-                'tagSet'                   => {}
+                'tagSet'                   => {},
+                'mapPublicIpOnLaunch'      => true,
+                'defaultForAz'             => true
               }
 
               # Add this subnet to the default network ACL

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

@@ -43,16 +43,18 @@ module Fog
               response.status = 200
               vpc_id = Fog::AWS::Mock.vpc_id
               vpc = {
-                'vpcId'                 => vpc_id,
-                'state'                 => 'pending',
-                'cidrBlock'             => cidrBlock,
-                'dhcpOptionsId'         => Fog::AWS::Mock.request_id,
-                'tagSet'                => {},
-                'enableDnsSupport'      => true,
-                'enableDnsHostnames'    => false,
-                'mapPublicIpOnLaunch'   => false,
-                'classicLinkEnabled'    => false,
-                'classicLinkDnsSupport' => false
+                'vpcId'                       => vpc_id,
+                'state'                       => 'pending',
+                'cidrBlock'                   => cidrBlock,
+                'dhcpOptionsId'               => Fog::AWS::Mock.request_id,
+                'tagSet'                      => {},
+                'enableDnsSupport'            => true,
+                'enableDnsHostnames'          => false,
+                'mapPublicIpOnLaunch'         => false,
+                'classicLinkEnabled'          => false,
+                'classicLinkDnsSupport'       => false,
+                'cidrBlockAssociationSet'     => [{ 'cidrBlock' => cidrBlock, 'state' => 'associated', 'associationId' => "vpc-cidr-assoc-#{vpc_id}" }],
+                'ipv6CidrBlockAssociationSet' => []
               }
               self.data[:vpcs].push(vpc)
 
@@ -75,6 +77,32 @@ module Fog
               # Manually override since Amazon doesn't let you create a default one
               self.data[:network_acls][default_nacl.network_acl_id]['default'] = true
 
+
+              # create default security groups
+              default_elb_group_name = "default_elb_#{Fog::Mock.random_hex(6)}"
+              default_elb_group_id = Fog::AWS::Mock.security_group_id
+
+              Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups][default_elb_group_id] = {
+                'groupDescription'    => 'default_elb security group',
+                'groupName'           => default_elb_group_name,
+                'groupId'             => default_elb_group_id,
+                'ipPermissions'       => [],
+                'ownerId'             => self.data[:owner_id],
+                'vpcId'               => vpc_id
+              }
+
+              default_group_name = 'default'
+              default_group_id = Fog::AWS::Mock.security_group_id
+
+              Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups][default_group_id] = {
+                'groupDescription'    => default_group_name,
+                'groupName'           => default_group_name,
+                'groupId'             => default_group_id,
+                'ipPermissions'       => [],
+                'ownerId'             => self.data[:owner_id],
+                'vpcId'               => vpc_id
+              }
+
               response.body = {
                 'requestId' => Fog::AWS::Mock.request_id,
                 'vpcSet'    => [vpc]

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

@@ -47,12 +47,12 @@ module Fog
             raise Fog::Compute::AWS::Error.new("May not specify both group_name and group_id")
           end
 
-          if id
-            name = self.data[:security_groups].reject { |k,v| v['groupId'] != id } .keys.first
+          if name
+            id, _ = self.data[:security_groups].find { |_,v| v['groupName'] == name }
           end
 
-          unless self.data[:security_groups][name]
-            raise Fog::Compute::AWS::NotFound.new("The security group '#{name}' does not exist")
+          unless self.data[:security_groups][id]
+            raise Fog::Compute::AWS::NotFound.new("The security group '#{id}' does not exist")
           end
 
           response = Excon::Response.new
@@ -61,14 +61,14 @@ module Fog
 
           # ec2 authorizations
           self.region_data.each do |_, key_data|
-            key_data[:security_groups].each do |group_name, group|
-              next if group == self.data[:security_groups][name]
+            key_data[:security_groups].each do |group_id, group|
+              next if group == self.data[:security_groups][group_id]
 
               group['ipPermissions'].each do |group_ip_permission|
                 group_ip_permission['groups'].each do |group_group_permission|
-                  if group_group_permission['groupName'] == name &&
+                  if group_group_permission['groupId'] == group_id &&
                       group_group_permission['userId'] == self.data[:owner_id]
-                    used_by_groups << "#{key_data[:owner_id]}:#{group_name}"
+                    used_by_groups << "#{key_data[:owner_id]}:#{group['groupName']}"
                   end
                 end
               end
@@ -100,7 +100,7 @@ module Fog
             raise Fog::Compute::AWS::Error.new("InUse => There are active instances using security group '#{name}'")
           end
 
-          self.data[:security_groups].delete(name)
+          self.data[:security_groups].delete(id)
           response.status = 200
           response.body = {
             'requestId' => Fog::AWS::Mock.request_id,

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

@@ -42,23 +42,25 @@ module Fog
       class Mock
         def describe_network_interface_attribute(network_interface_id, attribute)
           response = Excon::Response.new
-          if self.data[:network_interfaces][network_interface_id]
+          network_interface = self.data[:network_interfaces][network_interface_id]
 
-            response.status = 200
-            response.body = {
-              'requestId'          => Fog::AWS::Mock.request_id,
-              'networkInterfaceId' => network_interface_id
-            }
-            case attribute
-            when 'description', 'groupSet', 'sourceDestCheck', 'attachment'
-              response.body[attribute] = self.data[:network_interfaces][network_interface_id][attribute]
-            else
-              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
-            end
-            response
-          else
+
+          unless network_interface
             raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
           end
+
+          response.status = 200
+          response.body = {
+            'requestId'          => Fog::AWS::Mock.request_id,
+            'networkInterfaceId' => network_interface_id
+          }
+          case attribute
+          when 'description', 'groupSet', 'sourceDestCheck', 'attachment'
+            response.body[attribute] = network_interface[attribute]
+          else
+            raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+          end
+          response
         end
       end
     end

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

@@ -66,22 +66,46 @@ module Fog
             'protocol'  => 'ipProtocol',
             'to-port'   => 'toPort'
           }
-          security_group_groups = lambda { |security_group| (security_group['ipPermissions'] || []).map { |permission| permission["groups"] }.flatten.compact.uniq }
+
+          security_group_groups = lambda do |security_group|
+            (security_group['ipPermissions'] || []).map do |permission|
+              permission['groups']
+            end.flatten.compact.uniq
+          end
+
           for filter_key, filter_value in filters
             if permission_key = filter_key.split('ip-permission.')[1]
               if permission_key == 'group-name'
-                security_group_info = security_group_info.reject{|security_group| !security_group_groups.call(security_group).find {|group| [*filter_value].include?(group['groupName'])}}
+                security_group_info = security_group_info.reject do |security_group|
+                  !security_group_groups.call(security_group).find do |group|
+                    [*filter_value].include?(group['groupName'])
+                  end
+                end
               elsif permission_key == 'group-id'
-                security_group_info = security_group_info.reject{|security_group| !security_group_groups.call(security_group).find {|group| [*filter_value].include?(group['groupId'])}}
+                security_group_info = security_group_info.reject do |security_group|
+                  !security_group_groups.call(security_group).find do |group|
+                    [*filter_value].include?(group['groupId'])
+                  end
+                end
               elsif permission_key == 'user-id'
-                security_group_info = security_group_info.reject{|security_group| !security_group_groups.call(security_group).find {|group| [*filter_value].include?(group['userId'])}}
+                security_group_info = security_group_info.reject do |security_group|
+                  !security_group_groups.call(security_group).find do |group|
+                    [*filter_value].include?(group['userId'])
+                  end
+                end
               else
                 aliased_key = permission_aliases[filter_key]
-                security_group_info = security_group_info.reject{|security_group| !security_group['ipPermissions'].find {|permission| [*filter_value].include?(permission[aliased_key])}}
+                security_group_info = security_group_info.reject do |security_group|
+                  !security_group['ipPermissions'].find do |permission|
+                    [*filter_value].include?(permission[aliased_key])
+                  end
+                end
               end
             else
               aliased_key = aliases[filter_key]
-              security_group_info = security_group_info.reject{|security_group| ![*filter_value].include?(security_group[aliased_key])}
+              security_group_info = security_group_info.reject do |security_group|
+                ![*filter_value].include?(security_group[aliased_key])
+              end
             end
           end
 

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

@@ -14,17 +14,18 @@ module Fog
         # * body<~Hash>:
         # * 'requestId'<~String> - Id of request
         # * 'subnetSet'<~Array>:
-        # * 'subnetId'<~String> - The Subnet's ID
-        # * 'state'<~String> - The current state of the Subnet. ['pending', 'available']
-        # * 'vpcId'<~String> - The ID of the VPC the subnet is in
-        # * 'cidrBlock'<~String> - The CIDR block the Subnet covers.
-        # * 'availableIpAddressCount'<~Integer> - The number of unused IP addresses in the subnet (the IP addresses for any
-        #   stopped instances are considered unavailable)
-        # * 'availabilityZone'<~String> - The Availability Zone the subnet is in.
-        # * 'tagSet'<~Array>: Tags assigned to the resource.
-        # * 'key'<~String> - Tag's key
-        # * 'value'<~String> - Tag's value
-        # * 'instanceTenancy'<~String> - The allowed tenancy of instances launched into the Subnet.
+        #   * 'subnetId'<~String> - The Subnet's ID
+        #   * 'state'<~String> - The current state of the Subnet. ['pending', 'available']
+        #   * 'vpcId'<~String> - The ID of the VPC the subnet is in
+        #   * 'cidrBlock'<~String> - The CIDR block the Subnet covers.
+        #   * 'availableIpAddressCount'<~Integer> - The number of unused IP addresses in the subnet (the IP addresses for any
+        #     stopped instances are considered unavailable)
+        #   * 'availabilityZone'<~String> - The Availability Zone the subnet is in.
+        #   * 'tagSet'<~Array>: Tags assigned to the resource.
+        #     * 'key'<~String> - Tag's key
+        #     * 'value'<~String> - Tag's value
+        #   * 'mapPublicIpOnLaunch'<~Boolean> - Indicates whether instances launched in this subnet receive a public IPv4 address.
+        #   * 'defaultForAz'<~Boolean> - Indicates whether this is the default subnet for the Availability Zone.
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/index.html?ApiReference-query-DescribeSubnets.html]
         def describe_subnets(filters = {})

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

@@ -54,11 +54,11 @@ module Fog
             when 'groupSet'
               groups = {}
               value.each do |group_id|
-                name = self.data[:security_groups].select { |k,v| v['groupId'] == group_id } .first.first
-                if name.nil?
+                security_group = self.data[:security_groups][group_id]
+                if security_group.nil?
                   raise Fog::Compute::AWS::Error.new("Unknown security group '#{group_id}' specified")
                 end
-                groups[group_id] = name
+                groups[group_id] = security_group['groupName']
               end
               nic['groupSet'] = groups
             when 'sourceDestCheck'

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

@@ -57,40 +57,34 @@ module Fog
       class Mock
         def revoke_security_group_egress(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 = self.data[:security_groups].values.find { |v| v['groupName'] == group_name }
+
+          group ||
+            raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
           response = Excon::Response.new
-          group = self.data[:security_groups][group_name]
 
-          if group
-            verify_permission_options(options, group['vpcId'] != nil)
+          verify_permission_options(options, group['vpcId'] != nil)
 
-            normalized_permissions = normalize_permissions(options)
+          normalized_permissions = normalize_permissions(options)
 
-            normalized_permissions.each do |permission|
-              if matching_permission = find_matching_permission_egress(group, permission)
-                matching_permission['ipRanges'] -= permission['ipRanges']
-                matching_permission['groups'] -= permission['groups']
+          normalized_permissions.each do |permission|
+            if matching_permission = find_matching_permission_egress(group, permission)
+              matching_permission['ipRanges'] -= permission['ipRanges']
+              matching_permission['groups'] -= permission['groups']
 
-                if matching_permission['ipRanges'].empty? && matching_permission['groups'].empty?
-                  group['ipPermissionsEgress'].delete(matching_permission)
-                end
+              if matching_permission['ipRanges'].empty? && matching_permission['groups'].empty?
+                group['ipPermissionsEgress'].delete(matching_permission)
               end
             end
-
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist")
           end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
         end
       end
     end

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

@@ -57,40 +57,33 @@ module Fog
       class Mock
         def revoke_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 = self.data[:security_groups].values.find { |v| v['groupName'] == group_name }
 
+          group ||
+            raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
           response = Excon::Response.new
-          group = self.data[:security_groups][group_name]
 
-          if group
-            verify_permission_options(options, group['vpcId'] != nil)
+          verify_permission_options(options, group['vpcId'] != nil)
 
-            normalized_permissions = normalize_permissions(options)
+          normalized_permissions = normalize_permissions(options)
 
-            normalized_permissions.each do |permission|
-              if matching_permission = find_matching_permission(group, permission)
-                matching_permission['ipRanges'] -= permission['ipRanges']
-                matching_permission['groups'] -= permission['groups']
+          normalized_permissions.each do |permission|
+            if matching_permission = find_matching_permission(group, permission)
+              matching_permission['ipRanges'] -= permission['ipRanges']
+              matching_permission['groups'] -= permission['groups']
 
-                if matching_permission['ipRanges'].empty? && matching_permission['groups'].empty?
-                  group['ipPermissions'].delete(matching_permission)
-                end
+              if matching_permission['ipRanges'].empty? && matching_permission['groups'].empty?
+                group['ipPermissions'].delete(matching_permission)
               end
             end
-
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist")
           end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
         end
       end
     end

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

@@ -48,7 +48,7 @@ module Fog
         #   * 'SecurityGroupId'<~Array> or <~String> - id's of security group(s) for instances, use this or SecurityGroup
         #   * 'InstanceInitiatedShutdownBehaviour'<~String> - specifies whether volumes are stopped or terminated when instance is shutdown, in [stop, terminate]
         #   * 'InstanceType'<~String> - Type of instance to boot. Valid options
-        #     in ['t1.micro', 't2.micro', 't2.small', 't2.medium', 'm1.small', 'm1.medium', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'c3.large', 'c3.xlarge', 'c3.2xlarge', 'c3.4xlarge', 'c3.8xlarge', 'g2.2xlarge', 'hs1.8xlarge', 'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge', 'cr1.8xlarge', 'm3.xlarge', 'm3.2xlarge', 'hi1.4xlarge', 'cc1.4xlarge', 'cc2.8xlarge', 'cg1.4xlarge', 'i2.xlarge', 'i2.2xlarge', 'i2.4xlarge', 'i2.8xlarge']
+        #     in ['t1.micro', 't2.nano', 't2.micro', 't2.small', 't2.medium', 'm1.small', 'm1.medium', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'c3.large', 'c3.xlarge', 'c3.2xlarge', 'c3.4xlarge', 'c3.8xlarge', 'g2.2xlarge', 'hs1.8xlarge', 'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge', 'cr1.8xlarge', 'm3.xlarge', 'm3.2xlarge', 'hi1.4xlarge', 'cc1.4xlarge', 'cc2.8xlarge', 'cg1.4xlarge', 'i2.xlarge', 'i2.2xlarge', 'i2.4xlarge', 'i2.8xlarge']
         #     default is 'm1.small'
         #   * 'KernelId'<~String> - Id of kernel with which to launch
         #   * 'KeyName'<~String> - Name of a keypair to add to booting instances

data/lib/fog/aws/requests/efs/create_mount_target.rb

@@ -25,8 +25,10 @@ module Fog
       class Mock
         def create_mount_target(file_system_id, subnet_id, options={})
           response               = Excon::Response.new
-          default_security_group = mock_compute.data[:security_groups]['default']
-          security_groups        = options["SecurityGroups"] || [default_security_group['groupId']]
+          default_security_group = mock_compute.data[:security_groups].find do |_, sg|
+            sg['groupDescription'] == 'default_elb security group'
+          end
+          security_groups        = options["SecurityGroups"] || [default_security_group.first]
 
           unless file_system = self.data[:file_systems][file_system_id]
             raise Fog::AWS::EFS::NotFound.new("invalid file system ID: #{file_system_id}")
@@ -41,8 +43,10 @@ module Fog
             raise Fog::AWS::EFS::InvalidSubnet.new("invalid subnet ID: #{subnet_id}")
           end
 
-          security_groups.each do |sg|
-            raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{sg}") unless mock_compute.data[:security_groups].values.detect { |sgd| sgd["groupId"] == sg }
+          security_groups.each do |group_id|
+            unless mock_compute.data[:security_groups][group_id]
+              raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{group_id}")
+            end
           end
 
           id = "fsmt-#{Fog::Mock.random_letters(8)}"

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -111,53 +111,22 @@ module Fog
                            when 'EC2-Classic'
                              Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
                            when 'EC2-VPC-Default'
-                             # find or create default vpc
                              compute = Fog::Compute::AWS::new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key)
-                             unless vpc = compute.vpcs.all.first
-                               vpc = compute.vpcs.create('cidr_block' => '10.0.0.0/24')
-                             end
 
-                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+                             vpc = compute.vpcs.all.first ||
+                               compute.vpcs.create('cidr_block' => '10.0.0.0/24')
+
+                             Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
                                sg['groupName'] =~ /^default_elb/ &&
                                  sg["vpcId"] == vpc.id
                              }
-
-                             unless default_sg
-                               default_sg = {
-                                             'groupDescription'    => 'default_elb security group',
-                                             'groupName'           => "default_elb_#{Fog::Mock.random_hex(6)}",
-                                             'groupId'             => Fog::AWS::Mock.security_group_id,
-                                             'ipPermissionsEgress' => [],
-                                             'ipPermissions'       => [],
-                                             'ownerId'             => self.data[:owner_id],
-                                             'vpcId'               => vpc.id
-                                            }
-                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
-                             end
-
-                             default_sg
                            when 'EC2-VPC'
-                             # find or create default vpc security group
                              vpc_id = subnets.first["vpcId"]
-                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+
+                             Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
                                sg['groupName'] == 'default' &&
                                  sg["vpcId"] == vpc_id
                              }
-
-                             unless default_sg
-                               default_sg = {
-                                             'groupDescription'    => 'default elb security group',
-                                             'groupName'           => 'default',
-                                             'groupId'             => Fog::AWS::Mock.security_group_id,
-                                             'ipPermissionsEgress' => [],
-                                             'ipPermissions'       => [],
-                                             'ownerId'             => self.data[:owner_id],
-                                             'vpcId'               => vpc_id
-                                            }
-                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
-                             end
-
-                             default_sg
                            end
           self.data[:tags] ||= {}
           self.data[:tags][lb_name] = {}