fog-aws 0.11.0 → 3.18.0

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'
 
@@ -71,7 +71,7 @@ module Fog
             options.merge!(Fog::AWS.indexed_param('LaunchSpecification.SecurityGroupId', [*security_group_ids]))
           end
           if options['LaunchSpecification.UserData']
-            options['LaunchSpecification.UserData'] = Base64.encode64(options['LaunchSpecification.UserData'])
+            options['LaunchSpecification.UserData'] = Base64.encode64(options['LaunchSpecification.UserData']).chomp!
           end
 
           if options['ValidFrom'] && options['ValidFrom'].is_a?(Time)
@@ -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
@@ -95,6 +95,7 @@ module Fog
       class Mock
         def request_spot_instances(image_id, instance_type, spot_price, options = {})
           response = Excon::Response.new
+          id       = Fog::AWS::Mock.spot_instance_request_id
 
           if (image_id && instance_type && spot_price)
             response.status = 200
@@ -102,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
@@ -127,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)
@@ -139,32 +140,42 @@ module Fog
 
           launch_spec = {
             'iamInstanceProfile' => {},
-            'blockDeviceMapping' => [],
-            'groupSet'           => [Fog::AWS::Mock.security_group_id],
+            'blockDeviceMapping' => options['LaunchSpecification.BlockDeviceMapping'] || [],
+            'groupSet'           => options['LaunchSpecification.SecurityGroupId']    || ['default'],
             'imageId'            => image_id,
             'instanceType'       => instance_type,
-            'monitoring'         => options['MonitoringEnabled'] || false,
-            'subnetId'           => nil,
-            'ebsOptimized'       => false,
-            'keyName'            => options['KeyName'] || nil
+            'monitoring'         => options['LaunchSpecification.Monitoring.Enabled'] || false,
+            'subnetId'           => options['LaunchSpecification.SubnetId']           || nil,
+            'ebsOptimized'       => options['LaunchSpecification.EbsOptimized']       || false,
+            'keyName'            => options['LaunchSpecification.KeyName']            || nil
           }
 
+          if iam_arn = options['LaunchSpecification.IamInstanceProfile.Arn']
+            launch_spec['iamInstanceProfile'].merge!('Arn' => iam_arn)
+          end
+
+          if iam_name = options['LaunchSpecification.IamInstanceProfile.Name']
+            launch_spec['iamInstanceProfile'].merge!('Name' => iam_name)
+          end
+
+          spot_request = {
+            'launchSpecification'   => launch_spec,
+            'spotInstanceRequestId' => id,
+            'spotPrice'             => spot_price,
+            'type'                  => options['Type'] || 'one-time',
+            'state'                 => 'open',
+            'fault'                 => {
+              'code'    => 'pending-evaluation',
+              'message' => 'Your Spot request has been submitted for review, and is pending evaluation.'
+            },
+            'createTime'         => Time.now,
+            'productDescription' => 'Linux/UNIX'
+          }
+
+          self.data[:spot_requests][id] = spot_request
+
           response.body = {
-            'spotInstanceRequestSet' => [
-              {
-                'launchSpecification'   => launch_spec,
-                'spotInstanceRequestId' => Fog::AWS::Mock.spot_instance_request_id,
-                'spotPrice'             => spot_price,
-                'type'                  => options['Type'] || 'one-time',
-                'state'                 => 'open',
-                'fault'                 => {
-                  'code'    => 'pending-evaluation',
-                  'message' => 'Your Spot request has been submitted for review, and is pending evaluation.'
-                },
-                'createTime'         => Time.now,
-                'productDescription' => 'Linux/UNIX'
-              }
-            ],
+            'spotInstanceRequestSet' => [spot_request],
             'requestId' => Fog::AWS::Mock.request_id
           }
 

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

@@ -0,0 +1,55 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+        require 'fog/aws/parsers/compute/restore_address_to_classic'
+
+        # Move address from VPC to Classic
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~<Hash>:
+        #     * 'publicIp'<~String> - IP address
+        #     * 'requestId'<~String> - Id of the request
+        #     * 'status'<~String> - The status of the move of the IP address (MoveInProgress | InVpc | InClassic)
+
+        def restore_address_to_classic(public_ip)
+          request(
+            'Action' => 'RestoreAddressToClassic',
+            'PublicIp' => public_ip,
+            :idempotent => true,
+            :parser => Fog::Parsers::AWS::Compute::RestoreAddressToClassic.new
+          )
+        end
+      end
+
+      class Mock
+        def restore_address_to_classic(public_ip)
+          response      = Excon::Response.new
+
+          address = self.data[:addresses][public_ip]
+
+          if address
+            if address[:origin] == 'vpc'
+              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'
+            address.delete("allocationId")
+
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'publicIp'  => public_ip,
+              'status'    => "InClassic"
+            }
+
+            response
+          else
+            raise Fog::AWS::Compute::NotFound.new("Address does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Fog
+  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)
+        # * 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-RevokeSecurityGroupEgress.html]
+        def revoke_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'    => 'RevokeSecurityGroupEgress',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def revoke_security_group_egress(group_name, options = {})
+          options = Fog::AWS.parse_security_group_options(group_name, options)
+
+          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
+
+          verify_permission_options(options, group['vpcId'] != nil)
+
+          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']
+
+              if matching_permission['ipRanges'].empty? && matching_permission['groups'].empty?
+                group['ipPermissionsEgress'].delete(matching_permission)
+              end
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/revoke_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'    => '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

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/run_instances'
 
@@ -30,6 +30,8 @@ module Fog
         #     * 'Ebs.Encrypted'<~Boolean> - specifies whether or not the volume is to be encrypted unless snapshot is specified
         #     * 'Ebs.VolumeType'<~String> - Type of EBS volue. Valid options in ['standard', 'io1'] default is 'standard'.
         #     * 'Ebs.Iops'<~String> - The number of I/O operations per second (IOPS) that the volume supports. Required when VolumeType is 'io1'
+        #   * 'HibernationOptions'<~Array>: array of hashes
+        #     * 'Configured'<~Boolean> - specifies whether or not the instance is configued for hibernation.  This parameter is valid only if the instance meets the hibernation prerequisites.  
         #   * 'NetworkInterfaces'<~Array>: array of hashes
         #     * 'NetworkInterfaceId'<~String> - An existing interface to attach to a single instance
         #     * 'DeviceIndex'<~String> - The device index. Applies both to attaching an existing network interface and creating a network interface
@@ -42,13 +44,18 @@ module Fog
         #     * 'PrivateIpAddresses.Primary'<~Bool> - Indicates whether the private IP address is the primary private IP address.
         #     * 'SecondaryPrivateIpAddressCount'<~Bool> - The number of private IP addresses to assign to the network interface.
         #     * 'AssociatePublicIpAddress'<~String> - Indicates whether to assign a public IP address to an instance in a VPC. The public IP address is assigned to a specific network interface
+        #   * 'TagSpecifications'<~Array>: array of hashes
+        #     * 'ResourceType'<~String> - Type of resource to apply tags on, e.g: instance or volume
+        #     * 'Tags'<~Array> - List of hashs reprensenting tag to be set
+        #       * 'Key'<~String> - Tag name
+        #       * 'Value'<~String> - Tag value
         #   * 'ClientToken'<~String> - unique case-sensitive token for ensuring idempotency
         #   * 'DisableApiTermination'<~Boolean> - specifies whether or not to allow termination of the instance from the api
         #   * 'SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances (not supported for VPC)
         #   * '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
@@ -75,6 +82,8 @@ module Fog
         #           * 'deviceName'<~String> - specifies how volume is exposed to instance
         #           * 'status'<~String> - status of attached volume
         #           * 'volumeId'<~String> - Id of attached volume
+        #         * 'hibernationOptions'<~Array>
+        #           * 'configured'<~Boolean> - whether or not the instance is enabled for hibernation               
         #         * 'dnsName'<~String> - public dns name, blank until instance is running
         #         * 'imageId'<~String> - image id of ami used to launch instance
         #         * 'instanceId'<~String> - id of the instance
@@ -111,6 +120,13 @@ module Fog
               end
             end
           end
+          if hibernation_options = options.delete('HibernationOptions')
+            hibernation_options.each_with_index do |mapping, index|
+              for key, value in mapping
+                options.merge!({ format("HibernationOptions.%d.#{key}", index) => value })
+              end
+            end
+          end
           if security_groups = options.delete('SecurityGroup')
             options.merge!(Fog::AWS.indexed_param('SecurityGroup', [*security_groups]))
           end
@@ -133,6 +149,45 @@ module Fog
               end
             end
           end
+          if tag_specifications = options.delete('TagSpecifications')
+            # From https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Aws/EC2/Client.html#run_instances-instance_method
+            # And https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html
+            # Discussed at https://github.com/fog/fog-aws/issues/603
+            #
+            # Example
+            #
+            # TagSpecifications: [
+            #     {
+            #       ResourceType: "instance",
+            #       Tags: [
+            #         {
+            #           Key: "Project",
+            #           Value: "MyProject",
+            #         },
+            #       ],
+            #     },
+            #     {
+            #       ResourceType: "volume",
+            #       Tags: [
+            #         {
+            #           Key: "Project",
+            #           Value: "MyProject",
+            #         },
+            #       ],
+            #     },
+            # ]
+            tag_specifications.each_with_index do |val, idx|
+              resource_type = val["ResourceType"]
+              tags = val["Tags"]
+              options["TagSpecification.#{idx}.ResourceType"] = resource_type
+              tags.each_with_index do |tag, tag_idx|
+                aws_tag_key = "TagSpecification.#{idx}.Tag.#{tag_idx}.Key"
+                aws_tag_value = "TagSpecification.#{idx}.Tag.#{tag_idx}.Value"
+                options[aws_tag_key] = tag["Key"]
+                options[aws_tag_value] = tag["Value"]
+              end
+            end
+          end
 
           idempotent = !(options['ClientToken'].nil? || options['ClientToken'].empty?)
 
@@ -142,7 +197,7 @@ module Fog
             'MinCount'  => min_count,
             'MaxCount'  => max_count,
             :idempotent => idempotent,
-            :parser     => Fog::Parsers::Compute::AWS::RunInstances.new
+            :parser     => Fog::Parsers::AWS::Compute::RunInstances.new
           }.merge!(options))
         end
       end
@@ -157,7 +212,7 @@ module Fog
           reservation_id = Fog::AWS::Mock.reservation_id
 
           if options['KeyName'] && describe_key_pairs('key-name' => options['KeyName']).body['keySet'].empty?
-            raise Fog::Compute::AWS::NotFound.new("The key pair '#{options['KeyName']}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The key pair '#{options['KeyName']}' does not exist")
           end
 
           min_count.times do |i|
@@ -182,6 +237,14 @@ module Fog
               }
             end
 
+	    hibernation_options = (options['HibernationOptions'] || []).reduce([]) do |mapping, device|
+              configure = device.fetch("Configure", true)
+
+              mapping << {
+                "Configure" => configure,
+              }
+            end
+
             if options['SubnetId']
               if options['PrivateIpAddress']
                 ni_options = {'PrivateIpAddress' => options['PrivateIpAddress']}
@@ -217,30 +280,33 @@ module Fog
             end
 
             instance = {
-              'amiLaunchIndex'      => i,
-              'associatePublicIP'   => options['associatePublicIP'] || false,
-              'architecture'        => 'i386',
-              'blockDeviceMapping'  => block_device_mapping,
-              'networkInterfaces'   => network_interfaces,
-              'clientToken'         => options['clientToken'],
-              'dnsName'             => nil,
-              'ebsOptimized'        => options['EbsOptimized'] || false,
-              'hypervisor'          => 'xen',
-              'imageId'             => image_id,
-              'instanceId'          => instance_id,
-              'instanceState'       => { 'code' => 0, 'name' => 'pending' },
-              'instanceType'        => options['InstanceType'] || 'm1.small',
-              'kernelId'            => options['KernelId'] || Fog::AWS::Mock.kernel_id,
-              'keyName'             => options['KeyName'],
-              'launchTime'          => Time.now,
-              'monitoring'          => { 'state' => options['Monitoring.Enabled'] || false },
-              'placement'           => { 'availabilityZone' => availability_zone, 'groupName' => nil, 'tenancy' => options['Placement.Tenancy'] || 'default' },
-              'privateDnsName'      => nil,
-              'productCodes'        => [],
-              'reason'              => nil,
-              'rootDeviceName'      => block_device_mapping.first && block_device_mapping.first["deviceName"],
-              'rootDeviceType'      => 'instance-store',
-              'virtualizationType'  => 'paravirtual'
+              'amiLaunchIndex'        => i,
+              'associatePublicIP'     => options['associatePublicIP'] || false,
+              'architecture'          => 'i386',
+              'blockDeviceMapping'    => block_device_mapping,
+              'hibernationOptions'    => hibernation_options,
+              'networkInterfaces'     => network_interfaces,
+              'clientToken'           => options['clientToken'],
+              'dnsName'               => nil,
+              'ebsOptimized'          => options['EbsOptimized'] || false,
+              'hypervisor'            => 'xen',
+              'imageId'               => image_id,
+              'instanceId'            => instance_id,
+              'instanceState'         => { 'code' => 0, 'name' => 'pending' },
+              'instanceType'          => options['InstanceType'] || 'm1.small',
+              'kernelId'              => options['KernelId'] || Fog::AWS::Mock.kernel_id,
+              'keyName'               => options['KeyName'],
+              'launchTime'            => Time.now,
+              'monitoring'            => { 'state' => options['Monitoring.Enabled'] || false },
+              'placement'             => { 'availabilityZone' => availability_zone, 'groupName' => nil, 'tenancy' => options['Placement.Tenancy'] || 'default' },
+              'privateDnsName'        => nil,
+              'productCodes'          => [],
+              'reason'                => nil,
+              'rootDeviceName'        => block_device_mapping.first && block_device_mapping.first["deviceName"],
+              'rootDeviceType'        => 'instance-store',
+              'spotInstanceRequestId' => options['SpotInstanceRequestId'],
+              'subnetId'              => options['SubnetId'],
+              'virtualizationType'    => 'paravirtual'
             }
             instances_set << instance
             self.data[:instances][instance_id] = instance.merge({

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/start_stop_instances'
 
@@ -21,7 +21,7 @@ module Fog
           request({
             'Action'    => 'StartInstances',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::StartStopInstances.new
+            :parser     => Fog::Parsers::AWS::Compute::StartStopInstances.new
           }.merge!(params))
         end
       end
@@ -35,7 +35,7 @@ module Fog
           instance_set = instance_set.select {|x| instance_ids.include?(x["instanceId"]) }
 
           if instance_set.empty?
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_ids.first}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids.first}' does not exist")
           else
             response = Excon::Response.new
             response.status = 200