fog-aws 3.0.0 → 3.10.0

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'
 
@@ -49,7 +49,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
 
@@ -89,7 +89,7 @@ module Fog
 
           response = Excon::Response.new
           group ||
-            raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
+            raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name}' does not exist"))
 
           verify_permission_options(options, group['vpcId'] != nil)
 
@@ -98,11 +98,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
@@ -128,17 +128,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
@@ -196,7 +196,7 @@ module Fog
                                    self.data[:security_groups][group_id]
                                  end
                 security_group ||
-                  raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
+                  raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
 
                 {
                   'groupName' => authorized_group['GroupName'] || security_group['groupName'],

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,7 +23,7 @@ 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
@@ -34,7 +34,7 @@ module Fog
           spot_request = self.data[:spot_requests][spot_instance_request_id]
 
           unless spot_request
-            raise Fog::Compute::AWS::NotFound.new("The spot instance request ID '#{spot_instance_request_id}' does not exist")
+            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'

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'
 
@@ -33,7 +33,7 @@ module Fog
             'SourceSnapshotId' => source_snapshot_id,
             'SourceRegion'     => source_region,
             'Description'      => options['Description'],
-            :parser            => Fog::Parsers::Compute::AWS::CopySnapshot.new
+            :parser            => Fog::Parsers::AWS::Compute::CopySnapshot.new
           }
           params['Encrypted'] = true if options['Encrypted']
           params['KmsKeyId']  = options['KmsKeyId'] if options['Encrypted'] && options['KmsKeyId']

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,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_network_interface'
 
@@ -54,7 +54,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,7 +65,7 @@ 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'])
@@ -75,7 +75,7 @@ module Fog
                 options['GroupSet'].each do |group_id|
                   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['groupName']
                 end
@@ -93,7 +93,7 @@ module Fog
                   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

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/basic'
 
@@ -25,7 +25,7 @@ module Fog
             'Action'                => 'CreateRoute',
             'RouteTableId'          => route_table_id,
             'DestinationCidrBlock'  => destination_cidr_block,
-            :parser                 => Fog::Parsers::Compute::AWS::Basic.new
+            :parser                 => Fog::Parsers::AWS::Compute::Basic.new
           }
           if internet_gateway_id
             request_vars['GatewayId'] = internet_gateway_id
@@ -45,13 +45,13 @@ module Fog
           if !route_table.nil? && destination_cidr_block
             if !internet_gateway_id.nil? || !instance_id.nil? || !network_interface_id.nil?
               if !internet_gateway_id.nil? && self.internet_gateways.all('internet-gateway-id'=>internet_gateway_id).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The gateway ID '#{internet_gateway_id}' does not exist")
+                raise Fog::AWS::Compute::NotFound.new("The gateway ID '#{internet_gateway_id}' does not exist")
               elsif !instance_id.nil? && self.servers.all('instance-id'=>instance_id).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+                raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
               elsif !network_interface_id.nil? && self.network_interfaces.all('networkInterfaceId'=>network_interface_id).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The networkInterface ID '#{network_interface_id}' does not exist")
+                raise Fog::AWS::Compute::NotFound.new("The networkInterface ID '#{network_interface_id}' 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} already exists."
+                raise Fog::AWS::Compute::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} already exists."
               else
                 response = Excon::Response.new
                 route_table['routeSet'].push({
@@ -73,12 +73,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/create_route_table.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_route_table'
 
@@ -27,7 +27,7 @@ module Fog
           request({
             'Action' => 'CreateRouteTable',
             'VpcId' => vpc_id,
-            :parser => Fog::Parsers::Compute::AWS::CreateRouteTable.new
+            :parser => Fog::Parsers::AWS::Compute::CreateRouteTable.new
           })
         end
       end
@@ -60,7 +60,7 @@ module Fog
             }
             response
           else
-            raise Fog::Compute::AWS::NotFound.new("The vpc ID '#{vpc_id}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The vpc ID '#{vpc_id}' does not exist")
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/create_security_group'
 
@@ -25,7 +25,7 @@ module Fog
             'GroupName'         => name,
             'GroupDescription'  => description,
             'VpcId'             => vpc_id,
-            :parser             => Fog::Parsers::Compute::AWS::CreateSecurityGroup.new
+            :parser             => Fog::Parsers::AWS::Compute::CreateSecurityGroup.new
           )
         end
       end
@@ -38,7 +38,7 @@ module Fog
           group_id = Fog::AWS::Mock.security_group_id
 
           if self.data[:security_groups].find { |_,v| v['groupName'] == name }
-            raise Fog::Compute::AWS::Error,
+            raise Fog::AWS::Compute::Error,
               "InvalidGroup.Duplicate => The security group '#{name}' already exists"
           end