brightbox-cli 0.13.0

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/get_password_data.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/get_password_data'
+
+        # Retrieves the encrypted administrator password for an instance running Windows.
+        #
+        # ==== Parameters
+        # * instance_id<~String> - A Windows instance ID
+        #
+        # ==== Returns
+        # # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'instanceId'<~String> - Id of instance
+        #     * 'passwordData'<~String> - The encrypted, base64-encoded password of the instance.
+        #     * 'requestId'<~String> - Id of request
+        #     * 'timestamp'<~Time> - Timestamp of last update to output
+        #
+        # See http://docs.amazonwebservices.com/AWSEC2/2010-08-31/APIReference/index.html?ApiReference-query-GetPasswordData.html
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-GetPasswordData.html]
+        def get_password_data(instance_id)
+          request(
+            'Action'      => 'GetPasswordData',
+            'InstanceId'  => instance_id,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::Compute::AWS::GetPasswordData.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def get_password_data(instance_id)
+          response = Excon::Response.new
+          if instance = self.data[:instances][instance_id]
+            response.status = 200
+            response.body = {
+              'instanceId'   => instance_id,
+              'passwordData' => nil,
+              'requestId'    => Fog::AWS::Mock.request_id,
+              'timestamp'    => Time.now
+            }
+            response
+          else;
+            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/import_key_pair.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/import_key_pair'
+
+        # Import an existing public key to create a new key pair
+        #
+        # ==== Parameters
+        # * key_name<~String> - Unique name for key pair.
+        # * public_key_material<~String> - RSA public key
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'keyFingerprint'<~String> - SHA-1 digest of DER encoded private key
+        #     * 'keyName'<~String> - Name of key
+        #     * 'requestId'<~String> - Id of request
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ImportKeyPair.html]
+        def import_key_pair(key_name, public_key_material)
+          request(
+            'Action'  => 'ImportKeyPair',
+            'KeyName' => key_name,
+            'PublicKeyMaterial' => Base64::encode64(public_key_material),
+            :parser   => Fog::Parsers::Compute::AWS::ImportKeyPair.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def import_key_pair(key_name, public_key_material)
+          response = Excon::Response.new
+          unless self.data[:key_pairs][key_name]
+            response.status = 200
+            data = {
+              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
+              'keyName'         => key_name
+            }
+            self.data[:key_pairs][key_name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+            response
+          else
+            raise Fog::Compute::AWS::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/modify_image_attribute.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # Modify image attributes
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of machine image to modify
+        # * attributes<~Hash>:
+        #   * 'Add.Group'<~Array> - One or more groups to grant launch permission to
+        #   * 'Add.UserId'<~Array> - One or more account ids to grant launch permission to
+        #   * 'Description.Value'<String> - New description for image
+        #   * 'ProductCode'<~Array> - One or more product codes to add to image (these can not be removed)
+        #   * 'Remove.Group'<~Array> - One or more groups to revoke launch permission from
+        #   * 'Remove.UserId'<~Array> - One or more account ids to revoke launch permission from
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ModifyImageAttribute.html]
+        #
+        def modify_image_attribute(image_id, attributes)
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Add.%d.Group', attributes['Add.Group'] || []))
+          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Add.%d.UserId', attributes['Add.UserId'] || []))
+          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Remove.%d.Group', attributes['Remove.Group'] || []))
+          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Remove.%d.UserId', attributes['Remove.UserId'] || []))
+          params.merge!(Fog::AWS.indexed_param('ProductCode', attributes['ProductCode'] || []))
+          request({
+            'Action'        => 'ModifyImageAttribute',
+            'ImageId'       => image_id,
+            :idempotent     => true,
+            :parser         => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(params))
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/modify_instance_attribute.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # Modify instance attributes
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to modify
+        # * attributes<~Hash>:
+        #   'InstanceType.Value'<~String> - New instance type
+        #   'Kernel.Value'<~String> - New kernel value
+        #   'Ramdisk.Value'<~String> - New ramdisk value
+        #   'UserData.Value'<~String> - New userdata value
+        #   'DisableApiTermination.Value'<~Boolean> - Change api termination value
+        #   'InstanceInitiatedShutdownBehavior.Value'<~String> - New instance initiated shutdown behaviour, in ['stop', 'terminate']
+        #   'SourceDestCheck.Value'<~Boolean> - New sourcedestcheck value
+        #   'GroupId'<~Array> - One or more groups to add instance to (VPC only)
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ModifyInstanceAttribute.html]
+        #
+        def modify_instance_attributes(instance_id, attributes)
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('GroupId', attributes['GroupId'] || []))
+          request({
+            'Action'        => 'ModifyInstanceAttribute',
+            'InstanceId'    => instance_id,
+            :idempotent     => true,
+            :parser         => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(params))
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/modify_snapshot_attribute.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        
+        require 'fog/compute/parsers/aws/basic'
+
+        # Modify snapshot attributes
+        #
+        # ==== Parameters
+        # * snapshot_id<~String> - Id of snapshot to modify
+        # * attributes<~Hash>:
+        #   * 'Add.Group'<~Array> - One or more groups to grant volume create permission to
+        #   * 'Add.UserId'<~Array> - One or more account ids to grant volume create permission to
+        #   * 'Remove.Group'<~Array> - One or more groups to revoke volume create permission from
+        #   * 'Remove.UserId'<~Array> - One or more account ids to revoke volume create permission from
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ModifySnapshotAttribute.html]
+        #
+        def modify_snapshot_attribute(snapshot_id, attributes)
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('CreateVolumePermission.Add.%d.Group', attributes['Add.Group'] || []))
+          params.merge!(Fog::AWS.indexed_param('CreateVolumePermission.Add.%d.UserId', attributes['Add.UserId'] || []))
+          params.merge!(Fog::AWS.indexed_param('CreateVolumePermission.Remove.%d.Group', attributes['Remove.Group'] || []))
+          params.merge!(Fog::AWS.indexed_param('CreateVolumePermission.Remove.%d.UserId', attributes['Remove.UserId'] || []))
+          request({
+            'Action'        => 'ModifySnapshotAttribute',
+            'SnapshotId'    => snapshot_id,
+            :idempotent     => true,
+            :parser         => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(params))
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/monitor_instances.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class AWS
+
+      class Real
+
+        require 'fog/compute/parsers/aws/monitor_unmonitor_instances'
+
+        # Monitor specified instance
+        # http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-MonitorInstances.html
+        #
+        # ==== Parameters
+        # * instance_ids<~Array> - Arrays of instances Ids to monitor
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'instancesSet': http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-ItemType-MonitorInstancesResponseSetItemType.html
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-MonitorInstances.html]
+        def monitor_instances(instance_ids)
+          params = Fog::AWS.indexed_param('InstanceId', instance_ids)
+          request({
+                          'Action' => 'MonitorInstances',
+                          :idempotent => true,
+                          :parser => Fog::Parsers::Compute::AWS::MonitorUnmonitorInstances.new
+                  }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def monitor_instances(instance_ids)
+          response        = Excon::Response.new
+          response.status = 200
+          [*instance_ids].each do |instance_id|
+            if instance = self.data[:instances][instance_id]
+              instance['monitoring']['state'] = 'enabled'
+            else
+              raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_ids}' does not exist")
+            end
+          end
+          instances_set = [*instance_ids].inject([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'enabled'} }
+          response.body = {'requestId' => 'some_request_id', 'instancesSet' => instances_set}
+          response
+        end
+
+      end
+    end
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/purchase_reserved_instances_offering.rb

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/purchase_reserved_instances_offering'
+
+        # Purchases a Reserved Instance for use with your account.
+        #
+        # ==== Parameters
+        # * reserved_instances_offering_id<~String> - ID of the Reserved Instance offering you want to purchase.
+        # * instance_count<~Integer> - The number of Reserved Instances to purchase.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservedInstancesId'<~String> - Id of the purchased reserved instances.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-PurchaseReservedInstancesOffering.html]
+        def purchase_reserved_instances_offering(reserved_instances_offering_id, instance_count = 1)
+          request({
+            'Action'                      => 'PurchaseReservedInstancesOffering',
+            'ReservedInstancesOfferingId' => reserved_instances_offering_id,
+            'InstanceCount'               => instance_count,
+            :idempotent                   => true,
+            :parser                       => Fog::Parsers::Compute::AWS::PurchaseReservedInstancesOffering.new
+          })
+        end
+
+      end
+
+      class Mock
+        def purchase_reserved_instances_offering(reserved_instances_offering_id, instance_count = 1)
+          response = Excon::Response.new
+          response.status = 200
+
+          # Need to implement filters in the mock to find this there instead of here
+          # Also there's no information about what to do when the specified reserved_instances_offering_id doesn't exist
+          raise unless reserved_instance_offering = Compute[:aws].describe_reserved_instances_offerings.body["reservedInstancesOfferingsSet"].find { |offering| offering["reservedInstancesOfferingId"] == reserved_instances_offering_id }
+
+          reserved_instances_id = Fog::AWS::Mock.reserved_instances_id
+          reserved_instance_offering.delete('reservedInstancesOfferingId')
+
+          self.data[:reserved_instances][reserved_instances_id] = reserved_instance_offering.merge({
+            'reservedInstancesId' => reserved_instances_id,
+            'start'               => Time.now,
+            'instanceCount'       => instance_count,
+            'state'               => 'payment-pending',
+            'tagSet'              => []
+          })
+
+          response.body = {
+            'reservedInstancesId' => reserved_instances_id,
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/reboot_instances.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # Reboot specified instances
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - Ids of instances to reboot
+        #
+        # ==== 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-RebootInstances.html]
+        def reboot_instances(instance_id = [])
+          params = Fog::AWS.indexed_param('InstanceId', instance_id)
+          request({
+            'Action'    => 'RebootInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def reboot_instances(instance_id = [])
+          response = Excon::Response.new
+          instance_id = [*instance_id]
+          if (self.data[:instances].keys & instance_id).length == instance_id.length
+            for instance_id in instance_id
+              self.data[:instances][instance_id]['status'] = 'rebooting'
+            end
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/register_image.rb

@@ -0,0 +1,134 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/compute/parsers/aws/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' => 'i386',
+              'imageType' => 'machine',
+              'kernelId' => Fog::AWS::Mock.kernel_id,
+              'ramdiskId' => Fog::AWS::Mock.ramdisk_id,
+              'platform' => 'Linux',
+              'stateReason' => {},
+              'imageOwnerAlias' => self.data[:owner_id],
+              'name' => name,
+              'description' => description,
+              'rootDeviceType' => '',
+              'rootDeviceName' => '',
+              'blockDeviceMapping' => [],
+              'virtualizationType' => 'paravirtual',
+              'tagSet' => {},
+              '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 = 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/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/release_address.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/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]
+        def release_address(public_ip)
+          request(
+            'Action'    => 'ReleaseAddress',
+            'PublicIp'  => public_ip,
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def release_address(public_ip)
+          response = Excon::Response.new
+          if (address = self.data[:addresses].delete(public_ip))
+            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}' does not belong to you.")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/request_spot_instances.rb

@@ -0,0 +1,83 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/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.Placement.AvailabilityZone'<~String> - Placement constraint for instances
+        #   * 'LaunchSpecification.SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances
+        #   * '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
+        #       * '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 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