ey-vendored-backup 3.0.27

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

@@ -0,0 +1,133 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/register_image'
+
+        # register an image
+        #
+        # ==== Parameters
+        # * Name<~String> - Name of the AMI to be registered
+        # * Description<~String> - AMI description
+        # * Location<~String> - S3 manifest location (for S3 backed AMIs)
+        # or
+        # * RootDeviceName<~String> - Name of Root Device (for EBS snapshot backed AMIs)
+        # * BlockDevices<~Array>:
+        #   * BlockDeviceOptions<~Hash>:
+        #     * DeviceName<~String> - Name of the Block Device
+        #     * VirtualName<~String> - Name of the Virtual Device
+        #     * SnapshotId<~String> - id of the EBS Snapshot
+        #     * VolumeSize<~Integer> - Size of the snapshot (optional)
+        #     * NoDevice<~Boolean> - Do not use an ebs device (def: true)
+        #     * DeleteOnTermation<~Boolean> - Delete EBS volume on instance term (def: true)
+        # * Options<~Hash>:
+        #   * Architecture<~String> - i386 or x86_64
+        #   * KernelId<~String> - kernelId
+        #   * RamdiskId<~String> - ramdiskId
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'imageId'<~String> - Id of newly created AMI
+
+        #
+
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-RegisterImage.html]
+
+        def register_image(name, description, location, block_devices=[], options={})
+          common_options = {
+            'Action'      => 'RegisterImage',
+            'Name'        => name,
+            'Description' => description,
+            :parser       => Fog::Parsers::Compute::AWS::RegisterImage.new
+          }
+
+          # This determines if we are doing a snapshot or a S3 backed AMI.
+          if(location =~ /^\/dev\/sd[a-p]\d{0,2}$/)
+            common_options['RootDeviceName'] = location
+          else
+            common_options['ImageLocation'] = location
+          end
+
+          block_devices.each_with_index do |bd, index|
+            index += 1
+            ["DeviceName","VirtualName"].each do |n|
+              common_options["BlockDeviceMapping.#{index}.#{n}"] = bd[n] if bd[n]
+            end
+            ["SnapshotId","VolumeSize","NoDevice","DeleteOnTermination"].each do |n|
+              common_options["BlockDeviceMapping.#{index}.Ebs.#{n}"] = bd[n] if bd[n]
+            end
+          end
+
+          request(common_options.merge!(options))
+        end
+      end
+
+      class Mock
+        def register_image(name, description, location, block_devices=[], options={})
+          unless name.empty?
+            image = {
+              'imageId' => Fog::AWS::Mock.image_id,
+              'imageLocation' => '',
+              'imageState' => 'pending',
+              'imageOwnerId' => self.data[:owner_id],
+              'isPublic' => false,
+              'productCodes' => [],
+              'architecture' => options['Architecture'] || 'i386',
+              'imageType' => 'machine',
+              'kernelId' => options['KernelId'] || Fog::AWS::Mock.kernel_id,
+              'ramdiskId' => options['RamdiskId'] || Fog::AWS::Mock.ramdisk_id,
+              'platform' => 'Linux',
+              'stateReason' => {},
+              'imageOwnerAlias' => self.data[:owner_id],
+              'name' => name,
+              'description' => description,
+              'rootDeviceType' => '',
+              'rootDeviceName' => '',
+              'blockDeviceMapping' => [],
+              'virtualizationType' => 'paravirtual',
+              'hypervisor' => 'xen',
+              'registered' => Time.now
+            }
+
+            if location[/^\/dev\/sd[a-p]\d{0,2}$/]
+              image['rootDeviceName'] = location
+              image['rootDeviceType'] = 'ebs'
+            else
+              image['imageLocation'] = location
+            end
+
+            block_devices.each do |bd|
+              block_device_mapping = {
+                'ebs' => {}
+              }
+              ["DeviceName","VirtualName"].each do |n|
+                block_device_mapping[n] = bd[n] if bd[n]
+              end
+              ["SnapshotId","VolumeSize","NoDevice","DeleteOnTermination"].each do |n|
+                block_device_mapping['ebs'][n] = bd[n] if bd[n]
+              end
+              image['blockDeviceMapping'] << block_device_mapping
+            end
+
+            self.data[:images][image['imageId']] = image
+
+            response = Excon::Response.new
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId' => image['imageId']
+            }
+            response
+          else
+            message = 'MissingParameter => '
+            if name.empty?
+              message << 'The request must contain the parameter name'
+            end
+            raise Fog::Compute::AWS::Error.new(message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Release an elastic IP address.
+        #
+        # ==== 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-ReleaseAddress.html]
+        #
+        # non-VPC: requires public_ip only
+        #     VPC: requires allocation_id only
+        def release_address(ip_or_allocation)
+          field = if ip_or_allocation.to_s =~ /^(\d|\.)+$/
+                    "PublicIp"
+                  else
+                    "AllocationId"
+                  end
+          request(
+            'Action'    => 'ReleaseAddress',
+            field       => ip_or_allocation,
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def release_address(public_ip_or_allocation_id)
+          response = Excon::Response.new
+
+          address = self.data[:addresses][public_ip_or_allocation_id] || self.data[:addresses].values.detect {|a| a['allocationId'] == public_ip_or_allocation_id }
+
+          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"
+            end
+
+            self.data[:addresses].delete(address['publicIp'])
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::Error.new("AuthFailure => The address '#{public_ip_or_allocation_id}' does not belong to you.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/spot_instance_requests'
+
+        # Launch specified instances
+        #
+        # ==== Parameters
+        # * 'image_id'<~String> - Id of machine image to load on instances
+        # * 'instance_type'<~String> - Type of instance
+        # * 'spot_price'<~Float> - maximum hourly price for instances launched
+        # * options<~Hash>:
+        #   * 'AvailabilityZoneGroup'<~String> - specify whether or not to launch all instances in the same availability group
+        #   * 'InstanceCount'<~Integer> - maximum number of instances to launch
+        #   * 'LaunchGroup'<~String> - whether or not to launch/shutdown instances as a group
+        #   * 'LaunchSpecification.BlockDeviceMapping'<~Array>: array of hashes
+        #     * 'DeviceName'<~String> - where the volume will be exposed to instance
+        #     * 'VirtualName'<~String> - volume virtual device name
+        #     * 'Ebs.SnapshotId'<~String> - id of snapshot to boot volume from
+        #     * 'Ebs.NoDevice'<~String> - specifies that no device should be mapped
+        #     * 'Ebs.VolumeSize'<~String> - size of volume in GiBs required unless snapshot is specified
+        #     * 'Ebs.DeleteOnTermination'<~String> - specifies whether or not to delete the volume on instance termination
+        #   * 'LaunchSpecification.KeyName'<~String> - Name of a keypair to add to booting instances
+        #   * 'LaunchSpecification.Monitoring.Enabled'<~Boolean> - Enables monitoring, defaults to disabled
+        #   * 'LaunchSpecification.SubnetId'<~String> - VPC subnet ID in which to launch the instance
+        #   * 'LaunchSpecification.Placement.AvailabilityZone'<~String> - Placement constraint for instances
+        #   * 'LaunchSpecification.SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances, not supported in VPC
+        #   * 'LaunchSpecification.SecurityGroupId'<~Array> or <~String> - Id of security group(s) for instances, use this or LaunchSpecification.SecurityGroup
+        #   * 'LaunchSpecification.UserData'<~String> -  Additional data to provide to booting instances
+        #   * 'Type'<~String> - spot instance request type in ['one-time', 'persistent']
+        #   * 'ValidFrom'<~Time> - start date for request
+        #   * 'ValidUntil'<~Time> - end date for request
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'spotInstanceRequestSet'<~Array>:
+        #       * 'createTime'<~Time> - time of instance request creation
+        #       * 'instanceId'<~String> - instance id if one has been launched to fulfill request
+        #       * 'launchedAvailabilityZone'<~String> - availability zone of instance if one has been launched to fulfill request
+        #       * 'launchSpecification'<~Hash>:
+        #         * 'blockDeviceMapping'<~Hash> - list of block device mappings for instance
+        #         * 'groupSet'<~String> - security group(s) for instance
+        #         * 'keyName'<~String> - keypair name for instance
+        #         * 'imageId'<~String> - AMI for instance
+        #         * 'instanceType'<~String> - type for instance
+        #         * 'monitoring'<~Boolean> - monitoring status for instance
+        #         * 'subnetId'<~String> - VPC subnet ID for instance
+        #       * 'productDescription'<~String> - general description of AMI
+        #       * 'spotInstanceRequestId'<~String> - id of spot instance request
+        #       * 'spotPrice'<~Float> - maximum price for instances to be launched
+        #       * 'state'<~String> - spot instance request state
+        #       * 'type'<~String> - spot instance request type
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-RequestSpotInstances.html]
+        def request_spot_instances(image_id, instance_type, spot_price, options = {})
+          if block_device_mapping = options.delete('LaunchSpecification.BlockDeviceMapping')
+            block_device_mapping.each_with_index do |mapping, index|
+              for key, value in mapping
+                options.merge!({ format("LaunchSpecification.BlockDeviceMapping.%d.#{key}", index) => value })
+              end
+            end
+          end
+          if security_groups = options.delete('LaunchSpecification.SecurityGroup')
+            options.merge!(Fog::AWS.indexed_param('LaunchSpecification.SecurityGroup', [*security_groups]))
+          end
+          if security_group_ids = options.delete('LaunchSpecification.SecurityGroupId')
+            options.merge!(Fog::AWS.indexed_param('LaunchSpecification.SecurityGroupId', [*security_group_ids]))
+          end
+          if options['LaunchSpecification.UserData']
+            options['LaunchSpecification.UserData'] = Base64.encode64(options['LaunchSpecification.UserData'])
+          end
+
+          request({
+            'Action'                            => 'RequestSpotInstances',
+            'LaunchSpecification.ImageId'       => image_id,
+            'LaunchSpecification.InstanceType'  => instance_type,
+            'SpotPrice'                         => spot_price,
+            :parser                             => Fog::Parsers::Compute::AWS::SpotInstanceRequests.new
+          }.merge!(options))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_network_interface_attribute'
+        # Resets a network interface attribute value
+        #
+        # ==== Parameters
+        # * network_interface_id<~String> - The ID of the network interface you want to describe an attribute of
+        # * attribute<~String>            - The attribute to reset, only 'sourceDestCheck' is supported.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        #
+        # {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")
+          end
+          request(
+            'Action'             => 'ResetNetworkInterfaceAttribute',
+            'NetworkInterfaceId' => network_interface_id,
+            'Attribute'          => attribute,
+            :parser              => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+      end
+      
+      class Mock
+        def reset_network_interface_attribute(network_interface_id, attribute)
+          response = Excon::Response.new
+          if self.data[:network_interfaces][network_interface_id]
+
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            if attribute == 'sourceDestCheck'
+              self.data[:network_interfaces][network_interface_id]['sourceDestCheck'] = true
+            else
+              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+            end
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Fog
+  module Compute
+    class AWS
+      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-RevokeSecurityGroupIngress.html]
+        def revoke_security_group_ingress(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'    => 'RevokeSecurityGroupIngress',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      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
+
+          response = Excon::Response.new
+          group = self.data[:security_groups][group_name]
+
+          if group
+            verify_permission_options(options, group['vpcId'] != nil)
+
+            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']
+
+                if matching_permission['ipRanges'].empty? && matching_permission['groups'].empty?
+                  group['ipPermissions'].delete(matching_permission)
+                end
+              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
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/run_instances'
+
+        # Launch specified instances
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of machine image to load on instances
+        # * min_count<~Integer> - Minimum number of instances to launch. If this
+        #   exceeds the count of available instances, no instances will be
+        #   launched.  Must be between 1 and maximum allowed for your account
+        #   (by default the maximum for an account is 20)
+        # * max_count<~Integer> - Maximum number of instances to launch. If this
+        #   exceeds the number of available instances, the largest possible
+        #   number of instances above min_count will be launched instead. Must
+        #   be between 1 and maximum allowed for you account
+        #   (by default the maximum for an account is 20)
+        # * options<~Hash>:
+        #   * 'Placement.AvailabilityZone'<~String> - Placement constraint for instances
+        #   * 'Placement.GroupName'<~String> - Name of existing placement group to launch instance into
+        #   * 'Placement.Tenancy'<~String> - Tenancy option in ['dedicated', 'default'], defaults to 'default'
+        #   * 'BlockDeviceMapping'<~Array>: array of hashes
+        #     * 'DeviceName'<~String> - where the volume will be exposed to instance
+        #     * 'VirtualName'<~String> - volume virtual device name
+        #     * 'Ebs.SnapshotId'<~String> - id of snapshot to boot volume from
+        #     * 'Ebs.VolumeSize'<~String> - size of volume in GiBs required unless snapshot is specified
+        #     * 'Ebs.DeleteOnTermination'<~String> - specifies whether or not to delete the volume on instance termination
+        #   * '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', 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'm2.xlarge', m2.2xlarge', 'm2.4xlarge', 'cc1.4xlarge', 'cc2.8xlarge', 'cg1.4xlarge']
+        #     default is 'm1.small'
+        #   * 'KernelId'<~String> - Id of kernel with which to launch
+        #   * 'KeyName'<~String> - Name of a keypair to add to booting instances
+        #   * 'Monitoring.Enabled'<~Boolean> - Enables monitoring, defaults to
+        #     disabled
+        #   * 'PrivateIpAddress<~String> - VPC option to specify ip address within subnet
+        #   * 'RamdiskId'<~String> - Id of ramdisk with which to launch
+        #   * 'SubnetId'<~String> - VPC option to specify subnet to launch instance into
+        #   * 'UserData'<~String> -  Additional data to provide to booting instances
+        #   * 'EbsOptimized'<~Boolean> - Whether the instance is optimized for EBS I/O
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'groupSet'<~Array>: groups the instances are members in
+        #       * 'groupName'<~String> - Name of group
+        #     * 'instancesSet'<~Array>: returned instances
+        #       * instance<~Hash>:
+        #         * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
+        #         * 'architecture'<~String> - architecture of image in [i386, x86_64]
+        #         * 'blockDeviceMapping'<~Array>
+        #           * 'attachTime'<~Time> - time of volume attachment
+        #           * 'deleteOnTermination'<~Boolean> - whether or not to delete volume on termination
+        #           * 'deviceName'<~String> - specifies how volume is exposed to instance
+        #           * 'status'<~String> - status of attached volume
+        #           * 'volumeId'<~String> - Id of attached volume
+        #         * '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
+        #         * 'instanceState'<~Hash>:
+        #           * 'code'<~Integer> - current status code
+        #           * 'name'<~String> - current status name
+        #         * 'instanceType'<~String> - type of instance
+        #         * 'ipAddress'<~String> - public ip address assigned to instance
+        #         * 'kernelId'<~String> - Id of kernel used to launch instance
+        #         * 'keyName'<~String> - name of key used launch instances or blank
+        #         * 'launchTime'<~Time> - time instance was launched
+        #         * 'monitoring'<~Hash>:
+        #           * 'state'<~Boolean - state of monitoring
+        #         * 'placement'<~Hash>:
+        #           * 'availabilityZone'<~String> - Availability zone of the instance
+        #         * 'privateDnsName'<~String> - private dns name, blank until instance is running
+        #         * 'privateIpAddress'<~String> - private ip address assigned to instance
+        #         * 'productCodes'<~Array> - Product codes for the instance
+        #         * 'ramdiskId'<~String> - Id of ramdisk used to launch instance
+        #         * 'reason'<~String> - reason for most recent state transition, or blank
+        #         * 'rootDeviceName'<~String> - specifies how the root device is exposed to the instance
+        #         * 'rootDeviceType'<~String> - root device type used by AMI in [ebs, instance-store]
+        #         * 'ebsOptimized'<~Boolean> - Whether the instance is optimized for EBS I/O
+        #     * 'ownerId'<~String> - Id of owner
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservationId'<~String> - Id of reservation
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-RunInstances.html]
+        def run_instances(image_id, min_count, max_count, options = {})
+          if block_device_mapping = options.delete('BlockDeviceMapping')
+            block_device_mapping.each_with_index do |mapping, index|
+              for key, value in mapping
+                options.merge!({ format("BlockDeviceMapping.%d.#{key}", index) => value })
+              end
+            end
+          end
+          if security_groups = options.delete('SecurityGroup')
+            options.merge!(Fog::AWS.indexed_param('SecurityGroup', [*security_groups]))
+          end
+          if security_group_ids = options.delete('SecurityGroupId')
+            options.merge!(Fog::AWS.indexed_param('SecurityGroupId', [*security_group_ids]))
+          end
+          if options['UserData']
+            options['UserData'] = Base64.encode64(options['UserData'])
+          end
+
+          idempotent = !(options['ClientToken'].nil? || options['ClientToken'].empty?)
+
+          request({
+            'Action'    => 'RunInstances',
+            'ImageId'   => image_id,
+            'MinCount'  => min_count,
+            'MaxCount'  => max_count,
+            :idempotent => idempotent,
+            :parser     => Fog::Parsers::Compute::AWS::RunInstances.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def run_instances(image_id, min_count, max_count, options = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          group_set = [ (options['SecurityGroup'] || 'default') ].flatten
+          instances_set = []
+          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")
+          end
+
+          min_count.times do |i|
+            instance_id = Fog::AWS::Mock.instance_id
+            instance = {
+              'amiLaunchIndex'      => i,
+              'architecture'        => 'i386',
+              'blockDeviceMapping'  => [],
+              'clientToken'         => options['clientToken'],
+              'dnsName'             => nil,
+              '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' => options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone(@region), 'groupName' => nil, 'tenancy' => 'default' },
+              'privateDnsName'      => nil,
+              'productCodes'        => [],
+              'reason'              => nil,
+              'rootDeviceType'      => 'instance-store',
+              'ebsOptimized'        => options['EbsOptimized'] || false
+            }
+            instances_set << instance
+            self.data[:instances][instance_id] = instance.merge({
+              'groupIds'            => [],
+              'groupSet'            => group_set,
+              'iamInstanceProfile'  => {},
+              'networkInterfaces'   => [],
+              'ownerId'             => self.data[:owner_id],
+              'privateIpAddress'    => nil,
+              'reservationId'       => reservation_id,
+              'stateReason'         => {}
+            })
+          end
+          response.body = {
+            'groupSet'      => group_set,
+            'instancesSet'  => instances_set,
+            'ownerId'       => self.data[:owner_id],
+            'requestId'     => Fog::AWS::Mock.request_id,
+            'reservationId' => reservation_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+end