fog-aws 1.4.1 → 3.27.0

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/purchase_reserved_instances_offering'
 
@@ -23,7 +23,7 @@ module Fog
             'ReservedInstancesOfferingId' => reserved_instances_offering_id,
             'InstanceCount'               => instance_count,
             :idempotent                   => true,
-            :parser                       => Fog::Parsers::Compute::AWS::PurchaseReservedInstancesOffering.new
+            :parser                       => Fog::Parsers::AWS::Compute::PurchaseReservedInstancesOffering.new
           })
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -21,7 +21,7 @@ module Fog
           request({
             'Action'    => 'RebootInstances',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(params))
         end
       end
@@ -41,7 +41,7 @@ module Fog
             }
             response
           else
-            raise Fog::Compute::AWS::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/register_image'
 
@@ -39,7 +39,7 @@ module Fog
             'Action'      => 'RegisterImage',
             'Name'        => name,
             'Description' => description,
-            :parser       => Fog::Parsers::Compute::AWS::RegisterImage.new
+            :parser       => Fog::Parsers::AWS::Compute::RegisterImage.new
           }
 
           # This determines if we are doing a snapshot or a S3 backed AMI.
@@ -124,7 +124,7 @@ module Fog
             if name.empty?
               message << 'The request must contain the parameter name'
             end
-            raise Fog::Compute::AWS::Error.new(message)
+            raise Fog::AWS::Compute::Error.new(message)
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -26,7 +26,7 @@ module Fog
             'Action'    => 'ReleaseAddress',
             field       => ip_or_allocation,
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
           )
         end
       end
@@ -39,7 +39,7 @@ module Fog
 
           if address
             if address['allocationId'] && public_ip_or_allocation_id == address['publicIp']
-              raise Fog::Compute::AWS::Error, "InvalidParameterValue => You must specify an allocation id when releasing a VPC elastic IP address"
+              raise Fog::AWS::Compute::Error, "InvalidParameterValue => You must specify an allocation id when releasing a VPC elastic IP address"
             end
 
             self.data[:addresses].delete(address['publicIp'])
@@ -50,7 +50,7 @@ module Fog
             }
             response
           else
-            raise Fog::Compute::AWS::Error.new("AuthFailure => The address '#{public_ip_or_allocation_id}' does not belong to you.")
+            raise Fog::AWS::Compute::Error.new("AuthFailure => The address '#{public_ip_or_allocation_id}' does not belong to you.")
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/replace_network_acl_association'
 
@@ -22,7 +22,7 @@ module Fog
             'Action'        => 'ReplaceNetworkAclAssociation',
             'AssociationId' => association_id,
             'NetworkAclId'  => network_acl_id,
-            :parser         => Fog::Parsers::Compute::AWS::ReplaceNetworkAclAssociation.new
+            :parser         => Fog::Parsers::AWS::Compute::ReplaceNetworkAclAssociation.new
           })
         end
       end
@@ -37,7 +37,7 @@ module Fog
             end
 
             unless old_nacl
-              raise Fog::Compute::AWS::Error.new("Invalid association_id #{association_id}")
+              raise Fog::AWS::Compute::Error.new("Invalid association_id #{association_id}")
             end
 
             subnet_id = old_nacl['associationSet'].find { |assoc| assoc['networkAclAssociationId'] == association_id }['subnetId']
@@ -57,7 +57,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/replace_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]
 
             unless self.data[:network_acls][network_acl_id]['entrySet'].find { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
-              raise Fog::Compute::AWS::Error.new("No rule with that number")
+              raise Fog::AWS::Compute::Error.new("No rule with that number")
             end
             self.data[:network_acls][network_acl_id]['entrySet'].delete_if { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
 
@@ -72,7 +72,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/replace_route.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -28,7 +28,7 @@ module Fog
             'Action' => 'ReplaceRoute',
             'RouteTableId' => route_table_id,
             :idempotent => true,
-            :parser => Fog::Parsers::Compute::AWS::Basic.new
+            :parser => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(options))
         end
       end
@@ -42,13 +42,13 @@ module Fog
           if !route_table.nil? && destination_cidr_block
             if !options['gatewayId'].nil? || !options['instanceId'].nil? || !options['networkInterfaceId'].nil?
               if !options['gatewayId'].nil? && self.internet_gateways.all('internet-gateway-id'=>options['gatewayId']).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The gateway ID '#{options['gatewayId']}' does not exist")
+                raise Fog::AWS::Compute::NotFound.new("The gateway ID '#{options['gatewayId']}' does not exist")
               elsif !options['instanceId'].nil? && self.servers.all('instance-id'=>options['instanceId']).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{options['instanceId']}' does not exist")
+                raise Fog::AWS::Compute::NotFound.new("The instance ID '#{options['instanceId']}' does not exist")
               elsif !options['networkInterfaceId'].nil? && self.network_interfaces.all('networkInterfaceId'=>options['networkInterfaceId']).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The networkInterface ID '#{options['networkInterfaceId']}' does not exist")
+                raise Fog::AWS::Compute::NotFound.new("The networkInterface ID '#{options['networkInterfaceId']}' does not exist")
               elsif route_table['routeSet'].find { |route| route['destinationCidrBlock'].eql? destination_cidr_block }.nil?
-                raise Fog::Compute::AWS::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} doesn't exist."
+                raise Fog::AWS::Compute::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} doesn't exist."
               else
                 response = Excon::Response.new
                 route_set = route_table['routeSet'].find { |routeset| routeset['destinationCidrBlock'].eql? destination_cidr_block }
@@ -66,12 +66,12 @@ module Fog
             else
               message = 'MissingParameter => '
               message << 'The request must contain either a gateway id, a network interface id, or an instance id'
-              raise Fog::Compute::AWS::Error.new(message)
+              raise Fog::AWS::Compute::Error.new(message)
             end
           elsif route_table.nil?
-            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
           elsif destination_cidr_block.empty?
-            raise Fog::Compute::AWS::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
+            raise Fog::AWS::Compute::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/spot_instance_requests'
 
@@ -87,7 +87,7 @@ module Fog
             'LaunchSpecification.ImageId'       => image_id,
             'LaunchSpecification.InstanceType'  => instance_type,
             'SpotPrice'                         => spot_price,
-            :parser                             => Fog::Parsers::Compute::AWS::SpotInstanceRequests.new
+            :parser                             => Fog::Parsers::AWS::Compute::SpotInstanceRequests.new
           }.merge!(options))
         end
       end
@@ -103,19 +103,19 @@ module Fog
             all_instance_types = flavors.map { |f| f.id }
             if !all_instance_types.include?(instance_type)
               message = "InvalidParameterValue => Invalid value '#{instance_type}' for InstanceType."
-              raise Fog::Compute::AWS::Error.new(message)
+              raise Fog::AWS::Compute::Error.new(message)
             end
 
             spot_price = spot_price.to_f
             if !(spot_price > 0)
               message = "InvalidParameterValue => Value (#{spot_price}) for parameter price is invalid."
               message << " \"#{spot_price}\" is an invalid spot instance price"
-              raise Fog::Compute::AWS::Error.new(message)
+              raise Fog::AWS::Compute::Error.new(message)
             end
 
-            if !image_id.match(/^ami-[a-f0-9]{8}$/)
+            if !image_id.match(/^ami-[a-f0-9]{8,17}$/)
               message = "The image id '[#{image_id}]' does not exist"
-              raise Fog::Compute::AWS::NotFound.new(message)
+              raise Fog::AWS::Compute::NotFound.new(message)
             end
 
           else
@@ -128,7 +128,7 @@ module Fog
             else
               message << 'spot_price'
             end
-            raise Fog::Compute::AWS::Error.new(message)
+            raise Fog::AWS::Compute::Error.new(message)
           end
 
           for key in %w(AvailabilityZoneGroup LaunchGroup)

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -19,13 +19,13 @@ module Fog
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/ApiReference-query-DescribeNetworkInterfaceAttribute.html]
         def reset_network_interface_attribute(network_interface_id, attribute)
           if attribute != 'sourceDestCheck'
-            raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+            raise Fog::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
           end
           request(
             'Action'             => 'ResetNetworkInterfaceAttribute',
             'NetworkInterfaceId' => network_interface_id,
             'Attribute'          => attribute,
-            :parser              => Fog::Parsers::Compute::AWS::Basic.new
+            :parser              => Fog::Parsers::AWS::Compute::Basic.new
           )
         end
       end
@@ -43,11 +43,11 @@ module Fog
             if attribute == 'sourceDestCheck'
               self.data[:network_interfaces][network_interface_id]['sourceDestCheck'] = true
             else
-              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+              raise Fog::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
             end
             response
           else
-            raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The network interface '#{network_interface_id}' does not exist")
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/restore_address_to_classic'
 
@@ -18,7 +18,7 @@ module Fog
             'Action' => 'RestoreAddressToClassic',
             'PublicIp' => public_ip,
             :idempotent => true,
-            :parser => Fog::Parsers::Compute::AWS::RestoreAddressToClassic.new
+            :parser => Fog::Parsers::AWS::Compute::RestoreAddressToClassic.new
           )
         end
       end
@@ -31,7 +31,7 @@ module Fog
 
           if address
             if address[:origin] == 'vpc'
-              raise Fog::Compute::AWS::Error.new("InvalidState => You cannot migrate an Elastic IP address that was originally allocated for use in EC2-VPC to EC2-Classic.")
+              raise Fog::AWS::Compute::Error.new("InvalidState => You cannot migrate an Elastic IP address that was originally allocated for use in EC2-VPC to EC2-Classic.")
             end
 
             address['domain']       = 'standard'
@@ -46,7 +46,7 @@ module Fog
 
             response
           else
-            raise Fog::Compute::AWS::NotFound.new("Address does not exist")
+            raise Fog::AWS::Compute::NotFound.new("Address does not exist")
           end
         end
       end

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

@@ -1,13 +1,13 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
         # Remove permissions from a security group
         #
         # ==== Parameters
-        # * group_name<~String> - Name of group, optional (can also be specifed as GroupName in options)
+        # * group_name<~String> - Name of group, optional (can also be specified as GroupName in options)
         # * options<~Hash>:
         #   * 'GroupName'<~String> - Name of security group to modify
         #   * 'GroupId'<~String> - Id of security group to modify
@@ -49,7 +49,7 @@ module Fog
           request({
             'Action'    => 'RevokeSecurityGroupEgress',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(options))
         end
       end
@@ -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::AWS::Compute::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

@@ -1,13 +1,13 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
         # Remove permissions from a security group
         #
         # ==== Parameters
-        # * group_name<~String> - Name of group, optional (can also be specifed as GroupName in options)
+        # * group_name<~String> - Name of group, optional (can also be specified as GroupName in options)
         # * options<~Hash>:
         #   * 'GroupName'<~String> - Name of security group to modify
         #   * 'GroupId'<~String> - Id of security group to modify
@@ -49,7 +49,7 @@ module Fog
           request({
             'Action'    => 'RevokeSecurityGroupIngress',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(options))
         end
       end
@@ -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::AWS::Compute::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