Class: Fog::AWS::Compute::Mock

Inherits:

Object

Object
Fog::AWS::Compute::Mock

Includes:: Fog::AWS::CredentialFetcher::ConnectionMethods

Defined in:: lib/fog/aws/compute.rb,
lib/fog/aws/requests/compute/copy_image.rb,
lib/fog/aws/requests/compute/create_vpc.rb,
lib/fog/aws/requests/compute/delete_vpc.rb,
lib/fog/aws/requests/compute/create_tags.rb,
lib/fog/aws/requests/compute/delete_tags.rb,
lib/fog/aws/requests/compute/create_image.rb,
lib/fog/aws/requests/compute/create_route.rb,
lib/fog/aws/requests/compute/delete_route.rb,
lib/fog/aws/requests/compute/attach_volume.rb,
lib/fog/aws/requests/compute/copy_snapshot.rb,
lib/fog/aws/requests/compute/create_subnet.rb,
lib/fog/aws/requests/compute/create_volume.rb,
lib/fog/aws/requests/compute/delete_subnet.rb,
lib/fog/aws/requests/compute/delete_volume.rb,
lib/fog/aws/requests/compute/describe_tags.rb,
lib/fog/aws/requests/compute/describe_vpcs.rb,
lib/fog/aws/requests/compute/detach_volume.rb,
lib/fog/aws/requests/compute/modify_volume.rb,
lib/fog/aws/requests/compute/replace_route.rb,
lib/fog/aws/requests/compute/run_instances.rb,
lib/fog/aws/requests/compute/register_image.rb,
lib/fog/aws/requests/compute/stop_instances.rb,
lib/fog/aws/requests/compute/create_key_pair.rb,
lib/fog/aws/requests/compute/create_snapshot.rb,
lib/fog/aws/requests/compute/delete_key_pair.rb,
lib/fog/aws/requests/compute/delete_snapshot.rb,
lib/fog/aws/requests/compute/describe_images.rb,
lib/fog/aws/requests/compute/import_key_pair.rb,
lib/fog/aws/requests/compute/release_address.rb,
lib/fog/aws/requests/compute/start_instances.rb,
lib/fog/aws/requests/compute/allocate_address.rb,
lib/fog/aws/requests/compute/deregister_image.rb,
lib/fog/aws/requests/compute/describe_regions.rb,
lib/fog/aws/requests/compute/describe_subnets.rb,
lib/fog/aws/requests/compute/describe_volumes.rb,
lib/fog/aws/requests/compute/reboot_instances.rb,
lib/fog/aws/requests/compute/associate_address.rb,
lib/fog/aws/requests/compute/get_password_data.rb,
lib/fog/aws/requests/compute/monitor_instances.rb,
lib/fog/aws/requests/compute/create_network_acl.rb,
lib/fog/aws/requests/compute/create_route_table.rb,
lib/fog/aws/requests/compute/delete_network_acl.rb,
lib/fog/aws/requests/compute/delete_route_table.rb,
lib/fog/aws/requests/compute/describe_addresses.rb,
lib/fog/aws/requests/compute/describe_instances.rb,
lib/fog/aws/requests/compute/describe_key_pairs.rb,
lib/fog/aws/requests/compute/describe_snapshots.rb,
lib/fog/aws/requests/compute/get_console_output.rb,
lib/fog/aws/requests/compute/create_dhcp_options.rb,
lib/fog/aws/requests/compute/delete_dhcp_options.rb,
lib/fog/aws/requests/compute/move_address_to_vpc.rb,
lib/fog/aws/requests/compute/terminate_instances.rb,
lib/fog/aws/requests/compute/unmonitor_instances.rb,
lib/fog/aws/requests/compute/disassociate_address.rb,
lib/fog/aws/requests/compute/modify_vpc_attribute.rb,
lib/fog/aws/requests/compute/associate_route_table.rb,
lib/fog/aws/requests/compute/create_security_group.rb,
lib/fog/aws/requests/compute/delete_security_group.rb,
lib/fog/aws/requests/compute/describe_dhcp_options.rb,
lib/fog/aws/requests/compute/describe_network_acls.rb,
lib/fog/aws/requests/compute/describe_route_tables.rb,
lib/fog/aws/requests/compute/associate_dhcp_options.rb,
lib/fog/aws/requests/compute/describe_volume_status.rb,
lib/fog/aws/requests/compute/describe_vpc_attribute.rb,
lib/fog/aws/requests/compute/modify_image_attribute.rb,
lib/fog/aws/requests/compute/request_spot_instances.rb,
lib/fog/aws/requests/compute/attach_classic_link_vpc.rb,
lib/fog/aws/requests/compute/attach_internet_gateway.rb,
lib/fog/aws/requests/compute/create_internet_gateway.rb,
lib/fog/aws/requests/compute/delete_internet_gateway.rb,
lib/fog/aws/requests/compute/detach_classic_link_vpc.rb,
lib/fog/aws/requests/compute/detach_internet_gateway.rb,
lib/fog/aws/requests/compute/enable_vpc_classic_link.rb,
lib/fog/aws/requests/compute/modify_subnet_attribute.rb,
lib/fog/aws/requests/compute/modify_volume_attribute.rb,
lib/fog/aws/requests/compute/attach_network_interface.rb,
lib/fog/aws/requests/compute/create_network_acl_entry.rb,
lib/fog/aws/requests/compute/create_network_interface.rb,
lib/fog/aws/requests/compute/delete_network_acl_entry.rb,
lib/fog/aws/requests/compute/delete_network_interface.rb,
lib/fog/aws/requests/compute/describe_image_attribute.rb,
lib/fog/aws/requests/compute/describe_instance_status.rb,
lib/fog/aws/requests/compute/describe_security_groups.rb,
lib/fog/aws/requests/compute/detach_network_interface.rb,
lib/fog/aws/requests/compute/disable_vpc_classic_link.rb,
lib/fog/aws/requests/compute/disassociate_route_table.rb,
lib/fog/aws/requests/compute/describe_vpc_classic_link.rb,
lib/fog/aws/requests/compute/replace_network_acl_entry.rb,
lib/fog/aws/requests/compute/describe_internet_gateways.rb,
lib/fog/aws/requests/compute/restore_address_to_classic.rb,
lib/fog/aws/requests/compute/assign_private_ip_addresses.rb,
lib/fog/aws/requests/compute/describe_account_attributes.rb,
lib/fog/aws/requests/compute/describe_availability_zones.rb,
lib/fog/aws/requests/compute/describe_instance_attribute.rb,
lib/fog/aws/requests/compute/describe_network_interfaces.rb,
lib/fog/aws/requests/compute/describe_reserved_instances.rb,
lib/fog/aws/requests/compute/describe_spot_price_history.rb,
lib/fog/aws/requests/compute/revoke_security_group_egress.rb,
lib/fog/aws/requests/compute/cancel_spot_instance_requests.rb,
lib/fog/aws/requests/compute/revoke_security_group_ingress.rb,
lib/fog/aws/requests/compute/describe_volumes_modifications.rb,
lib/fog/aws/requests/compute/authorize_security_group_egress.rb,
lib/fog/aws/requests/compute/describe_classic_link_instances.rb,
lib/fog/aws/requests/compute/describe_spot_instance_requests.rb,
lib/fog/aws/requests/compute/replace_network_acl_association.rb,
lib/fog/aws/requests/compute/authorize_security_group_ingress.rb,
lib/fog/aws/requests/compute/reset_network_interface_attribute.rb,
lib/fog/aws/requests/compute/modify_network_interface_attribute.rb,
lib/fog/aws/requests/compute/enable_vpc_classic_link_dns_support.rb,
lib/fog/aws/requests/compute/describe_network_interface_attribute.rb,
lib/fog/aws/requests/compute/disable_vpc_classic_link_dns_support.rb,
lib/fog/aws/requests/compute/purchase_reserved_instances_offering.rb,
lib/fog/aws/requests/compute/describe_reserved_instances_offerings.rb,
lib/fog/aws/requests/compute/describe_vpc_classic_link_dns_support.rb

Constant Summary collapse

MOCKED_TAG_TYPES =

{
  'acl'  => 'network_acl',
  'ami'  => 'image',
  'igw'  => 'internet_gateway',
  'i'    => 'instance',
  'rtb'  => 'route_table',
  'snap' => 'snapshot',
  'vol'  => 'volume',
  'vpc'  => 'vpc'
}

VPC_BLANK_VALUE =

'none'

Instance Attribute Summary collapse

#region ⇒ Object

Returns the value of attribute region.

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Fog::AWS::CredentialFetcher::ConnectionMethods

#refresh_credentials_if_expired

Constructor Details

#initialize(options = {}) ⇒ `Mock`

Returns a new instance of Mock.

# File 'lib/fog/aws/compute.rb', line 319

def initialize(options={})
  @use_iam_profile = options[:use_iam_profile]
  @aws_credentials_expire_at = Time::now + 20
  setup_credentials(options)
  @region = options[:region] || 'us-east-1'

  if @endpoint = options[:endpoint]
    endpoint = URI.parse(@endpoint)
    @host = endpoint.host or raise InvalidURIError.new("could not parse endpoint: #{@endpoint}")
    @path = endpoint.path
    @port = endpoint.port
    @scheme = endpoint.scheme
  else
    @host = options[:host] || "ec2.#{options[:region]}.amazonaws.com"
    @path       = options[:path]        || '/'
    @persistent = options[:persistent]  || false
    @port       = options[:port]        || 443
    @scheme     = options[:scheme]      || 'https'
  end
  Fog::AWS.validate_region!(@region, @host)
end

Instance Attribute Details

#region ⇒ `Object`

Returns the value of attribute region.



317
318
319

# File 'lib/fog/aws/compute.rb', line 317

def region
  @region
end

Class Method Details

.data ⇒ `Object`

# File 'lib/fog/aws/compute.rb', line 205

def self.data
  @data ||= Hash.new do |hash, region|
    hash[region] = Hash.new do |region_hash, key|
      owner_id = Fog::AWS::Mock.owner_id
      security_group_id = Fog::AWS::Mock.security_group_id
      region_hash[key] = {
        :deleted_at => {},
        :addresses  => {},
        :images     => {},
        :image_launch_permissions => Hash.new do |permissions_hash, image_key|
          permissions_hash[image_key] = {
            :users => []
          }
        end,
        :instances  => {},
        :reserved_instances => {},
        :key_pairs  => {},
        :limits     => { :addresses => 5 },
        :owner_id   => owner_id,
        :security_groups => {
          'default' => {
            'groupDescription'    => 'default group',
            'groupName'           => 'default',
            'groupId'             => security_group_id,
            'ipPermissionsEgress' => [],
            'ipPermissions'       => [
              {
                'groups'      => [{'groupName' => 'default', 'userId' => owner_id, 'groupId' => security_group_id }],
                'fromPort'    => -1,
                'toPort'      => -1,
                'ipProtocol'  => 'icmp',
                'ipRanges'    => [],
                'ipv6Ranges'  => []
              },
              {
                'groups'      => [{'groupName' => 'default', 'userId' => owner_id, 'groupId' => security_group_id}],
                'fromPort'    => 0,
                'toPort'      => 65535,
                'ipProtocol'  => 'tcp',
                'ipRanges'    => [],
                'ipv6Ranges'  => []
              },
              {
                'groups'      => [{'groupName' => 'default', 'userId' => owner_id, 'groupId' => security_group_id}],
                'fromPort'    => 0,
                'toPort'      => 65535,
                'ipProtocol'  => 'udp',
                'ipRanges'    => [],
                'ipv6Ranges'  => []
              }
            ],
            'ownerId'             => owner_id
          },
          'amazon-elb-sg' => {
            'groupDescription'   => 'amazon-elb-sg',
            'groupName'          => 'amazon-elb-sg',
            'groupId'            => 'amazon-elb',
            'ownerId'            => 'amazon-elb',
            'ipPermissionsEgree' => [],
            'ipPermissions'      => [],
          },
        },
        :network_acls => {},
        :network_interfaces => {},
        :snapshots => {},
        :volumes => {},
        :internet_gateways => {},
        :tags => {},
        :tag_sets => Hash.new do |tag_set_hash, resource_id|
          tag_set_hash[resource_id] = {}
        end,
        :subnets => [],
        :vpcs => [],
        :dhcp_options => [],
        :route_tables => [],
        :account_attributes => [
          {
            "values"        => ["5"],
            "attributeName" => "vpc-max-security-groups-per-interface"
          },
          {
            "values"        => ["20"],
            "attributeName" => "max-instances"
          },
          {
            "values"        => ["EC2", "VPC"],
            "attributeName" => "supported-platforms"
          },
          {
            "values"        => [VPC_BLANK_VALUE],
            "attributeName" => "default-vpc"
          },
          {
            "values"        => ["5"],
            "attributeName" => "max-elastic-ips"
          },
          {
            "values"        => ["5"],
            "attributeName" => "vpc-max-elastic-ips"
          }
        ],
        :spot_requests => {},
        :volume_modifications => {}
      }
    end
  end
end

.reset ⇒ `Object`



313
314
315

# File 'lib/fog/aws/compute.rb', line 313

def self.reset
  @data = nil
end

Instance Method Details

#allocate_address(domain = 'standard') ⇒ `Object`

# File 'lib/fog/aws/requests/compute/allocate_address.rb', line 29

def allocate_address(domain = 'standard')
  unless describe_addresses.body['addressesSet'].size < self.data[:limits][:addresses]
    raise Fog::AWS::Compute::Error, "AddressLimitExceeded => Too many addresses allocated"
  end

  response = Excon::Response.new
  response.status = 200

  domain    = domain == 'vpc' ? 'vpc' : 'standard'
  public_ip = Fog::AWS::Mock.ip_address

  data = {
    'instanceId' => nil,
    'publicIp'   => public_ip,
    'domain'     => domain,
    :origin      => domain
  }

  if domain == 'vpc'
    data['allocationId'] = "eipalloc-#{Fog::Mock.random_hex(8)}"
  end

  self.data[:addresses][public_ip] = data
  response.body = data.reject {|k, v| k == 'instanceId' }.merge('requestId' => Fog::AWS::Mock.request_id)
  response
end

#apply_tag_filters(resources, filters, resource_id_key) ⇒ `Object`

# File 'lib/fog/aws/compute.rb', line 495

def apply_tag_filters(resources, filters, resource_id_key)
  tag_set_fetcher = lambda {|resource| self.data[:tag_sets][resource[resource_id_key]] }

  # tag-key: match resources tagged with this key (any value)
  if filters.key?('tag-key')
    value = filters.delete('tag-key')
    resources = resources.select{|r| tag_set_fetcher[r].key?(value)}
  end

  # tag-value: match resources tagged with this value (any key)
  if filters.key?('tag-value')
    value = filters.delete('tag-value')
    resources = resources.select{|r| tag_set_fetcher[r].values.include?(value)}
  end

  # tag:key: match resources tagged with a key-value pair.  Value may be an array, which is OR'd.
  tag_filters = {}
  filters.keys.each do |key|
    tag_filters[key.gsub('tag:', '')] = filters.delete(key) if /^tag:/ =~ key
  end
  for tag_key, tag_value in tag_filters
    resources = resources.select{|r| [tag_value].flatten.include? tag_set_fetcher[r][tag_key]}
  end

  resources
end

#assign_private_ip_addresses(network_interface_id, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/assign_private_ip_addresses.rb', line 39

def assign_private_ip_addresses(network_interface_id, options={})
  if options['PrivateIpAddresses'] && options['SecondaryPrivateIpAddressCount']
    raise Fog::AWS::Compute::Error.new("You may specify secondaryPrivateIpAddressCount or specific secondary private IP addresses, but not both.")
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return' => true
  }
  response
end

#associate_address(*args) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/associate_address.rb', line 57

def associate_address(*args)
  if args.first.kind_of? Hash
    params = args.first
  else
    params = {
        :instance_id => args[0],
        :public_ip => args[1],
        :network_interface_id => args[2],
        :allocation_id => args[3],
        :private_ip_address => args[4],
        :allow_reassociation => args[5],
    }
  end
  params[:public_ip] = params[:allocation_id].nil? ? params[:public_ip] : nil
  response = Excon::Response.new
  response.status = 200
  instance = self.data[:instances][params[:instance_id]]
 # address =  self.data[:addresses][params[:public_ip]]
  address = params[:public_ip].nil? ? nil : self.data[:addresses][params[:public_ip]]
  # This is a classic server, a VPC with a single network interface id or a VPC with multiple network interfaces one of which is specified
  if ((instance && address) || (instance &&  !params[:allocation_id].nil?) || (!params[:allocation_id].nil? && !network_interface_id.nil?))
    if !params[:allocation_id].nil?
      allocation_ip = describe_addresses( 'allocation-id'  => "#{params[:allocation_id]}").body['addressesSet'].first
      if !allocation_ip.nil?
        public_ip = allocation_ip['publicIp']
        address = public_ip.nil? ? nil : self.data[:addresses][public_ip]

        if instance['vpcId'] && vpc = self.data[:vpcs].detect { |v| v['vpcId'] == instance['vpcId'] }
          if vpc['enableDnsHostnames']
            instance['dnsName'] = Fog::AWS::Mock.dns_name_for(public_ip)
          end
        end
      end
    end
    if !address.nil?
      if current_instance = self.data[:instances][address['instanceId']]
        current_instance['ipAddress'] = current_instance['originalIpAddress']
      end
      address['instanceId'] = params[:instance_id]
    end
    # detach other address (if any)
    if self.data[:addresses][instance['ipAddress']]
      self.data[:addresses][instance['ipAddress']]['instanceId'] = nil
    end
    if !params[:public_ip].nil?
      instance['ipAddress'] = params[:public_ip]
      instance['dnsName'] = Fog::AWS::Mock.dns_name_for(params[:public_ip])
    end
    response.status = 200
    if !params[:instance_id].nil? && !params[:public_ip].nil?
      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'return'    => true
      }
    elsif !params[:allocation_id].nil?
      association_id = "eipassoc-#{Fog::Mock.random_hex(8)}"
      address['associationId'] = association_id
      response.body = {
        'requestId'     => Fog::AWS::Mock.request_id,
        'return'        => true,
        'associationId' => association_id,
      }
    end
    response
  elsif !instance
    raise Fog::AWS::Compute::NotFound.new("You must specify either an InstanceId or a NetworkInterfaceID")
  elsif !address
    raise Fog::AWS::Compute::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
  elsif params[:network_interface_id].nil? && params[:allocation_id].nil?
    raise Fog::AWS::Compute::NotFound.new("You must specify an AllocationId when specifying a NetworkInterfaceID")
  else (!instance.nil? && params[:network_interface_id].nil?) || (params[:instance_id].nil? && !params[:network_interface_id].nil?)
    raise Fog::AWS::Compute::Error.new("You must specify either an InstanceId or a NetworkInterfaceID")
  end
end

#associate_dhcp_options(dhcp_options_id, vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/associate_dhcp_options.rb', line 32

def associate_dhcp_options(dhcp_options_id, vpc_id)
  response = Excon::Response.new
  if dhcp_options_id && vpc_id
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return' => true
    }
    response
  else
    if !dhcp_options_id
      message << 'The request must contain the parameter dhcp_options_id'
    elsif !vpc_id
      message << 'The request must contain the parameter vpc_id'
    end
    raise Fog::AWS::Compute::Error.new(message)
  end
end

#associate_route_table(routeTableId, subnetId) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/associate_route_table.rb', line 30

def associate_route_table(routeTableId, subnetId)
  routetable = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? routeTableId }
  subnet = self.data[:subnets].find { |subnet| subnet["subnetId"].eql? subnetId }

  if !routetable.nil? && !subnet.nil?
    response = Excon::Response.new
    response.status = 200
    association = add_route_association(routeTableId, subnetId)
    routetable["associationSet"].push(association)
    response.body = {
        'requestId'     => Fog::AWS::Mock.request_id,
        'associationId' => association['routeTableAssociationId']
    }
    response
  elsif routetable.nil?
    raise Fog::AWS::Compute::NotFound.new("The routeTable ID '#{routeTableId}' does not exist")
  else
    raise Fog::AWS::Compute::NotFound.new("The subnet ID '#{subnetId}' does not exist")
  end
end

#attach_classic_link_vpc(instance_id, vpc_id, security_group_ids, dry_run = false) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/attach_classic_link_vpc.rb', line 35

def attach_classic_link_vpc(instance_id, vpc_id, security_group_ids, dry_run=false)
  response = Excon::Response.new
  vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
  instance = self.data[:instances][instance_id]
  if vpc && instance
    if instance['instanceState']['name'] != 'running' || instance['vpcId']
      raise Fog::AWS::Compute::Error.new("Client.InvalidInstanceID.NotLinkable => Instance #{instance_id} is unlinkable")
    end
    if instance['classicLinkVpcId']
      raise Fog::AWS::Compute::Error.new("Client.InvalidInstanceID.InstanceAlreadyLinked => Instance #{instance_id} is already linked")
    end

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    unless dry_run
      instance['classicLinkSecurityGroups'] = security_group_ids
      instance['classicLinkVpcId'] = vpc_id
    end
    response
  elsif !instance
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist.")
  elsif !vpc
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist.")
  end

end

#attach_internet_gateway(internet_gateway_id, vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/attach_internet_gateway.rb', line 31

def attach_internet_gateway(internet_gateway_id, vpc_id)
  response = Excon::Response.new
  if internet_gateway_id && vpc_id
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return' => true
    }
    response
  else
    if !internet_gateway_id
      message << 'The request must contain the parameter internet_gateway_id'
    elsif !vpc_id
      message << 'The request must contain the parameter vpc_id'
    end
    raise Fog::AWS::Compute::Error.new(message)
  end
end

#attach_network_interface(nic_id, instance_id, device_index) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/attach_network_interface.rb', line 33

def attach_network_interface(nic_id, instance_id, device_index)
  response = Excon::Response.new
  if ! self.data[:instances].find{ |i,i_conf|
    i_conf['instanceId'] == instance_id
  }
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
  elsif self.data[:network_interfaces].find{ |ni,ni_conf| ni_conf['attachment']['instanceId'] == instance_id && ni_conf['attachment']['deviceIndex'] == device_index }
    raise Fog::AWS::Compute::Error.new("InvalidParameterValue => Instance '#{instance_id}' already has an interface attached at device index '#{device_index}'.")
  elsif self.data[:network_interfaces][nic_id]
    attachment = self.data[:network_interfaces][nic_id]['attachment']
    attachment['attachmentId'] = Fog::AWS::Mock.request_id
    attachment['instanceId']   = instance_id
    attachment['deviceIndex']  = device_index

    response.status = 200
    response.body = {
      'requestId'    => Fog::AWS::Mock.request_id,
      'attachmentId' => attachment['attachmentId']
    }
  else
    raise Fog::AWS::Compute::NotFound.new("The network interface '#{nic_id}' does not exist")
  end

  response
end

#attach_volume(instance_id, volume_id, device) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/attach_volume.rb', line 38

def attach_volume(instance_id, volume_id, device)
  response = Excon::Response.new
  if instance_id && volume_id && device
    response.status = 200
    instance = self.data[:instances][instance_id]
    volume = self.data[:volumes][volume_id]
    if instance && volume
      unless volume['status'] == 'available'
        raise Fog::AWS::Compute::Error.new("Client.VolumeInUse => Volume #{volume_id} is unavailable")
      end

      data = {
        'attachTime'  => Time.now,
        'device'      => device,
        'instanceId'  => instance_id,
        'status'      => 'attaching',
        'volumeId'    => volume_id
      }
      volume['attachmentSet'] = [data]
      volume['status'] = 'attaching'
      response.status = 200
      response.body = {
        'requestId' => Fog::AWS::Mock.request_id
      }.merge!(data)
      response
    elsif !instance
      raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist.")
    elsif !volume
      raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
    end
  else
    message = 'MissingParameter => '
    if !instance_id
      message << 'The request must contain the parameter instance_id'
    elsif !volume_id
      message << 'The request must contain the parameter volume_id'
    else
      message << 'The request must contain the parameter device'
    end
    raise Fog::AWS::Compute::Error.new(message)
  end
end

#authorize_security_group_egress(group_name, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/authorize_security_group_egress.rb', line 58

def authorize_security_group_egress(group_name, options = {})
  options = Fog::AWS.parse_security_group_options(group_name, options)

  group = if options.key?('GroupName')
            self.data[:security_groups].values.find { |v| v['groupName'] == options['GroupName'] }
          else
            self.data[:security_groups][options.fetch('GroupId')]
          end

  response = Excon::Response.new
  group ||
    raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name}' does not exist"))

  verify_permission_options(options, group['vpcId'] != nil)

  normalized_permissions = normalize_permissions(options)

  normalized_permissions.each do |permission|
    if matching_group_permission = find_matching_permission_egress(group, permission)
      if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
        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::AWS::Compute::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
      end
    end
  end

  normalized_permissions.each do |permission|
    if matching_group_permission = find_matching_permission_egress(group, permission)
      matching_group_permission['groups'] += permission['groups']
      matching_group_permission['ipRanges'] += permission['ipRanges']
    else
      group['ipPermissionsEgress'] << permission
    end
  end

  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#authorize_security_group_ingress(group_name, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/authorize_security_group_ingress.rb', line 88

def authorize_security_group_ingress(group_name, options = {})
  options = Fog::AWS.parse_security_group_options(group_name, options)

  group = if options.key?('GroupName')
            self.data[:security_groups].values.find { |v| v['groupName'] == options['GroupName'] }
          else
            self.data[:security_groups][options.fetch('GroupId')]
          end

  response = Excon::Response.new
  group ||
    raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name}' does not exist"))

  verify_permission_options(options, group['vpcId'] != nil)

  normalized_permissions = normalize_permissions(options)

  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::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::AWS::Compute::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
      end
    end
  end

  normalized_permissions.each do |permission|
    if matching_group_permission = find_matching_permission(group, permission)
      matching_group_permission['groups'] += permission['groups']
      matching_group_permission['ipRanges'] += permission['ipRanges']
    else
      group['ipPermissions'] << permission
    end
  end

  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#cancel_spot_instance_requests(spot_instance_request_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/cancel_spot_instance_requests.rb', line 32

def cancel_spot_instance_requests(spot_instance_request_id)
  response = Excon::Response.new
  spot_request = self.data[:spot_requests][spot_instance_request_id]

  unless spot_request
    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'
  spot_request['state'] = 'cancelled'

  response.body = {'spotInstanceRequestSet' => [{'spotInstanceRequestId' => spot_instance_request_id, 'state' => 'cancelled'}], 'requestId' => Fog::AWS::Mock.request_id}
  response
end

#copy_image(source_image_id, source_region, name = nil, description = nil, client_token = nil) ⇒ `Object`

Usage

Fog::AWS.copy_image(“ami-1aad5273”, ‘us-east-1’)

# File 'lib/fog/aws/requests/compute/copy_image.rb', line 43

def copy_image(source_image_id, source_region, name = nil, description = nil, client_token = nil)
  response = Excon::Response.new
  response.status = 200
  image_id = Fog::AWS::Mock.image_id
  data = {
    'imageId'  => image_id,
  }
  self.data[:images][image_id] = data
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id
  }.merge!(data)
  response
end

#copy_snapshot(source_snapshot_id, source_region, options = {}) ⇒ `Object`

Usage

Fog::AWS.copy_snapshot(“snap-1db0a957”, ‘us-east-1’)

# File 'lib/fog/aws/requests/compute/copy_snapshot.rb', line 51

def copy_snapshot(source_snapshot_id, source_region, options = {})
  response = Excon::Response.new
  response.status = 200
  snapshot_id = Fog::AWS::Mock.snapshot_id
  data = {
    'snapshotId'  => snapshot_id,
  }
  self.data[:snapshots][snapshot_id] = data
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id
  }.merge!(data)
  response
end

#create_dhcp_options(dhcp_configurations = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_dhcp_options.rb', line 42

def create_dhcp_options(dhcp_configurations = {})
  params = {}
  params.merge!(indexed_multidimensional_params(dhcp_configurations))
  Excon::Response.new.tap do |response|
    response.status = 200
    self.data[:dhcp_options].push({
      'dhcpOptionsId' => Fog::AWS::Mock.dhcp_options_id,
      'dhcpConfigurationSet'  => {},
      'tagSet'             => {}
    })
    response.body = {
      'requestId'    => Fog::AWS::Mock.request_id,
      'dhcpOptionsSet'      => self.data[:dhcp_options]
    }
  end
end

#create_image(instance_id, name, description, no_reboot = false, options = {}) ⇒ `Object`

Usage

Fog::AWS.create_image(“i-ac65ee8c”, “test”, “something”)

# File 'lib/fog/aws/requests/compute/create_image.rb', line 53

def create_image(instance_id, name, description, no_reboot = false, options = {})
  params = {}
  block_device_mappings = options[:block_device_mappings] || []
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.DeviceName', block_device_mappings.map{|mapping| mapping['DeviceName']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.NoDevice', block_device_mappings.map{|mapping| mapping['NoDevice']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.VirtualName', block_device_mappings.map{|mapping| mapping['VirtualName']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.SnapshotId', block_device_mappings.map{|mapping| mapping['Ebs.SnapshotId']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.DeleteOnTermination', block_device_mappings.map{|mapping| mapping['Ebs.DeleteOnTermination']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.VolumeType', block_device_mappings.map{|mapping| mapping['Ebs.VolumeType']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Encrypted', block_device_mappings.map{|mapping| mapping['Ebs.Encrypted']})
  params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Iops', block_device_mappings.map{|mapping| mapping['Ebs.Iops']})
  params.reject!{|k,v| v.nil?}

  reserved_ebs_root_device  = '/dev/sda1'
  block_devices = options.delete(:block_device_mappings) || []
  register_image_response = register_image(name, description, reserved_ebs_root_device, block_devices, options)

  response = Excon::Response.new
  if instance_id && !name.empty?
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'imageId' => register_image_response.body['imageId']
    }
  else
    response.status = 400
    response.body = {
      'Code' => 'InvalidParameterValue'
    }
    if name.empty?
      response.body['Message'] = "Invalid value '' for name. Must be specified."
    end
  end
  response
end

#create_internet_gateway ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_internet_gateway.rb', line 34

def create_internet_gateway()
  gateway_id = Fog::AWS::Mock.internet_gateway_id
self.data[:internet_gateways][gateway_id] = {
  'internetGatewayId' => gateway_id,
  'attachmentSet'     => {},
  'tagSet'            => {}
}
 Excon::Response.new(
    :status => 200,
    :body   => {
      'requestId' => Fog::AWS::Mock.request_id,
      'internetGatewaySet' => [self.data[:internet_gateways][gateway_id]]
    }
  )
end

#create_key_pair(key_name) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_key_pair.rb', line 31

def create_key_pair(key_name)
  response = Excon::Response.new
  unless self.data[:key_pairs][key_name]
    response.status = 200
    data = {
      'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
      'keyMaterial'     => Fog::AWS::Mock.key_material,
      'keyName'         => key_name
    }
    self.data[:key_pairs][key_name] = data
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id
    }.merge!(data)
    response
  else
    raise Fog::AWS::Compute::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
  end
end

#create_network_acl(vpcId, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_network_acl.rb', line 51

def create_network_acl(vpcId, options = {})
  response = Excon::Response.new
  if vpcId
    id = Fog::AWS::Mock.network_acl_id

    unless self.data[:vpcs].find { |s| s['vpcId'] == vpcId }
      raise Fog::AWS::Compute::Error.new("Unknown VPC '#{vpcId}' specified")
    end

    data = {
      'networkAclId'   => id,
      'vpcId'          => vpcId,
      'default'        => false,
      'entrySet'       => [
        {
          'icmpTypeCode' => {},
          'portRange'    => {},
          'ruleNumber'   => 32767,
          'protocol'     => -1,
          'ruleAction'   => "deny",
          'egress'       => true,
          'cidrBlock'    => "0.0.0.0/0",
        },
        {
          'icmpTypeCode' => {},
          'portRange'    => {},
          'ruleNumber'   => 32767,
          'protocol'     => -1,
          'ruleAction'   => "deny",
          'egress'       => false,
          'cidrBlock'    => "0.0.0.0/0",
        },
      ],
      'associationSet' => [],
      'tagSet'         => {}
    }

    self.data[:network_acls][id] = data
    response.body = {
      'requestId'  => Fog::AWS::Mock.request_id,
      'networkAcl' => data
    }
  else
    response.status = 400
    response.body = {
      'Code'    => 'InvalidParameterValue',
      'Message' => "Invalid value '' for subnetId"
    }
  end
  response
end

#create_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_network_acl_entry.rb', line 44

def create_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
  response = Excon::Response.new
  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::AWS::Compute::Error.new("Already a rule with that number")
    end

    data = {
      'ruleNumber'   => rule_number,
      'protocol'     => protocol,
      'ruleAction'   => rule_action,
      'egress'       => egress,
      'cidrBlock'    => cidr_block,
      'icmpTypeCode' => {},
      'portRange'    => {}
    }
    data['icmpTypeCode']['code'] = options['Icmp.Code']      if options['Icmp.Code']
    data['icmpTypeCode']['type'] = options['Icmp.Type']      if options['Icmp.Type']
    data['portRange']['from']    = options['PortRange.From'] if options['PortRange.From']
    data['portRange']['to']      = options['PortRange.To']   if options['PortRange.To']
    self.data[:network_acls][network_acl_id]['entrySet'] << data

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
  end
end

#create_network_interface(subnetId, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_network_interface.rb', line 64

def create_network_interface(subnetId, options = {})
  response = Excon::Response.new
  if subnetId
    subnet = self.data[:subnets].find{ |s| s['subnetId'] == subnetId }
    if subnet.nil?
      raise Fog::AWS::Compute::Error.new("Unknown subnet '#{subnetId}' specified")
    else
      id = Fog::AWS::Mock.network_interface_id
      cidr_block = IPAddr.new(subnet['cidrBlock'])

      groups = {}
      if options['GroupSet']
        options['GroupSet'].each do |group_id|
          group_obj = self.data[:security_groups][group_id]
          if group_obj.nil?
            raise Fog::AWS::Compute::Error.new("Unknown security group '#{group_id}' specified")
          end
          groups[group_id] = group_obj['groupName']
        end
      end

      if options['PrivateIpAddress'].nil?
        range = cidr_block.to_range
        # Here we try to act like a DHCP server and pick the first
        # available IP (not including the first in the cidr block,
        # which is typically reserved for the gateway).
        range = range.drop(2)[0..-2] if cidr_block.ipv4?

        range.each do |p_ip|
          unless self.data[:network_interfaces].map{ |ni, ni_conf| ni_conf['privateIpAddress'] }.include?p_ip.to_s
            options['PrivateIpAddress'] = p_ip.to_s
            break
          end
        end
      elsif self.data[:network_interfaces].map{ |ni,ni_conf| ni_conf['privateIpAddress'] }.include?options['PrivateIpAddress']
        raise Fog::AWS::Compute::Error.new('InUse => The specified address is already in use.')
      end

      data = {
        'networkInterfaceId' => id,
        'subnetId'           => subnetId,
        'vpcId'              => 'mock-vpc-id',
        'availabilityZone'   => 'mock-zone',
        'description'        => options['Description'],
        'ownerId'            => '',
        'requesterManaged'   => 'false',
        'status'             => 'available',
        'macAddress'         => '00:11:22:33:44:55',
        'privateIpAddress'   => options['PrivateIpAddress'],
        'sourceDestCheck'    => true,
        'groupSet'           => groups,
        'attachment'         => {},
        'association'        => {},
        'tagSet'             => {}
      }
      self.data[:network_interfaces][id] = data
      response.body = {
        'requestId'        => Fog::AWS::Mock.request_id,
        'networkInterface' => data
      }
      response
    end
  else
    response.status = 400
    response.body = {
      'Code'    => 'InvalidParameterValue',
      'Message' => "Invalid value '' for subnetId"
    }
  end
end

#create_route(route_table_id, destination_cidr_block, internet_gateway_id = nil, instance_id = nil, network_interface_id = nil) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_route.rb', line 42

def create_route(route_table_id, destination_cidr_block, internet_gateway_id=nil, instance_id=nil, network_interface_id=nil)
  instance_owner_id = nil
  route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
  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::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::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::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::AWS::Compute::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} already exists."
      else
        response = Excon::Response.new
        route_table['routeSet'].push({
          "destinationCidrBlock" => destination_cidr_block,
          "gatewayId" => internet_gateway_id,
          "instanceId"=>instance_id,
          "instanceOwnerId"=>instance_owner_id,
          "networkInterfaceId"=>network_interface_id,
          "state" => "pending",
          "origin" => "CreateRoute"
        })
        response.status = 200
        response.body = {
          'requestId'=> Fog::AWS::Mock.request_id,
          'return' => true
        }
        response
      end
    else
      message = 'MissingParameter => '
      message << 'The request must contain either a gateway id, a network interface id, or an instance id'
      raise Fog::AWS::Compute::Error.new(message)
    end
  elsif route_table.nil?
    raise Fog::AWS::Compute::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
  elsif destination_cidr_block.empty?
    raise Fog::AWS::Compute::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
  end
end

#create_route_table(vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_route_table.rb', line 36

def create_route_table(vpc_id)
  response = Excon::Response.new
  vpc = self.data[:vpcs].find { |vpc| vpc["vpcId"].eql? vpc_id }
  unless vpc.nil?
    response.status = 200
    route_table = {
      'routeTableId' => Fog::AWS::Mock.route_table_id,
      'vpcId' => vpc["vpcId"],
      'routeSet' => [{
        "destinationCidrBlock" => vpc["cidrBlock"],
        "gatewayId" => "local",
        "instanceId"=>nil,
        "instanceOwnerId"=>nil,
        "networkInterfaceId"=>nil,
        "state" => "pending",
        "origin" => "CreateRouteTable"
      }],
      'associationSet' => [],
      'tagSet' => {}
    }
    self.data[:route_tables].push(route_table)
    response.body = {
      'requestId'=> Fog::AWS::Mock.request_id,
      'routeTable' => [route_table]
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The vpc ID '#{vpc_id}' does not exist")
  end
end

#create_security_group(name, description, vpc_id = nil) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_security_group.rb', line 34

def create_security_group(name, description, vpc_id=nil)
  response = Excon::Response.new

  vpc_id ||= Fog::AWS::Mock.default_vpc_for(region)
  group_id = Fog::AWS::Mock.security_group_id

  if self.data[:security_groups].find { |_,v| v['groupName'] == name }
    raise Fog::AWS::Compute::Error,
      "InvalidGroup.Duplicate => The security group '#{name}' already exists"
  end

  self.data[:security_groups][group_id] = {
    'groupDescription'    => description,
    'groupName'           => name,
    'groupId'             => group_id,
    'ipPermissionsEgress' => [],
    'ipPermissions'       => [],
    'ownerId'             => self.data[:owner_id],
    'vpcId'               => vpc_id
  }

  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'groupId'   => group_id,
    'return'    => true
  }
  response
end

#create_snapshot(volume_id, description = nil) ⇒ `Object`

Usage

Fog::AWS.create_snapshot(“vol-f7c23423”, “latest snapshot”)

# File 'lib/fog/aws/requests/compute/create_snapshot.rb', line 41

def create_snapshot(volume_id, description = nil)
  response = Excon::Response.new
  if volume = self.data[:volumes][volume_id]
    response.status = 200
    snapshot_id = Fog::AWS::Mock.snapshot_id
    data = {
      'description' => description,
      'encrypted'   => false,
      'ownerId'     => self.data[:owner_id],
      'progress'    => nil,
      'snapshotId'  => snapshot_id,
      'startTime'   => Time.now,
      'status'      => 'pending',
      'volumeId'    => volume_id,
      'volumeSize'  => volume['size']
    }
    self.data[:snapshots][snapshot_id] = data
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id
    }.merge!(data)
  else
    response.status = 400
    raise(Excon::Errors.status_error({:expects => 200}, response))
  end
  response
end

#create_subnet(vpcId, cidrBlock, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_subnet.rb', line 45

def create_subnet(vpcId, cidrBlock, options = {})
  av_zone = options['AvailabilityZone'].nil? ? 'us-east-1c' : options['AvailabilityZone']
  Excon::Response.new.tap do |response|
    if cidrBlock && vpcId
      vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpcId }
      if vpc.nil?
        raise Fog::AWS::Compute::NotFound.new("The vpc ID '#{vpcId}' does not exist")
      end
      if ! ::IPAddr.new(vpc['cidrBlock']).include?(::IPAddr.new(cidrBlock))
        raise Fog::AWS::Compute::Error.new("Range => The CIDR '#{cidrBlock}' is invalid.")
      end
      self.data[:subnets].select{ |s| s['vpcId'] == vpcId }.each do |subnet|
        if ::IPAddr.new(subnet['cidrBlock']).include?(::IPAddr.new(cidrBlock))
          raise Fog::AWS::Compute::Error.new("Conflict => The CIDR '#{cidrBlock}' conflicts with another subnet")
        end
      end

      response.status = 200
      data = {
        'subnetId'                 => Fog::AWS::Mock.subnet_id,
        'state'                    => 'pending',
        'vpcId'                    => vpcId,
        'cidrBlock'                => cidrBlock,
        'availableIpAddressCount'  => "255",
        'availabilityZone'         => av_zone,
        'tagSet'                   => {},
        'mapPublicIpOnLaunch'      => true,
        'defaultForAz'             => true
      }

      # Add this subnet to the default network ACL
      accid = Fog::AWS::Mock.network_acl_association_id
      default_nacl = self.data[:network_acls].values.find { |nacl| nacl['vpcId'] == vpcId && nacl['default'] }
      default_nacl['associationSet'] << {
        'networkAclAssociationId' => accid,
        'networkAclId'            => default_nacl['networkAclId'],
        'subnetId'                => data['subnetId'],
      }

      self.data[:subnets].push(data)
      response.body = {
        'requestId'    => Fog::AWS::Mock.request_id,
        'subnet'       => data,
      }
    else
      response.status = 400
      response.body = {
        'Code' => 'InvalidParameterValue'
      }
      if cidrBlock.empty?
        response.body['Message'] = "Invalid value '' for cidrBlock. Must be specified."
      end
      if vpcId.empty?
        response.body['Message'] = "Invalid value '' for vpcId. Must be specified."
      end
    end
  end
end

#create_tags(resources, tags) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_tags.rb', line 40

def create_tags(resources, tags)
  resources = [*resources]
  tagged = tagged_resources(resources)

  tags.each do |key, value|
    self.data[:tags][key] ||= {}
    self.data[:tags][key][value] ||= []
    self.data[:tags][key][value] |= tagged

    tagged.each do |resource|
      self.data[:tag_sets][resource['resourceId']][key] = value
    end
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#create_volume(availability_zone, size, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_volume.rb', line 48

def create_volume(availability_zone, size, options = {})
  unless options.is_a?(Hash)
    Fog::Logger.deprecation("create_volume with a bare snapshot_id is deprecated, use create_volume(availability_zone, size, 'SnapshotId' => snapshot_id) instead [light_black](#{caller.first})[/]")
    options = { 'SnapshotId' => options }
  end

  response = Excon::Response.new
  if availability_zone && (size || options['SnapshotId'])
    snapshot = self.data[:snapshots][options['SnapshotId']]
    if options['SnapshotId'] && !snapshot
      raise Fog::AWS::Compute::NotFound.new("The snapshot '#{options['SnapshotId']}' does not exist.")
    end

    if snapshot && size && size < snapshot['volumeSize']
      raise Fog::AWS::Compute::NotFound.new("The snapshot '#{options['SnapshotId']}' has size #{snapshot['volumeSize']} which is greater than #{size}.")
    elsif snapshot && !size
      size = snapshot['volumeSize']
    end

    if options['VolumeType'] == 'io1'
      iops = options['Iops']
      if !iops
        raise Fog::AWS::Compute::Error.new("InvalidParameterCombination => The parameter iops must be specified for io1 volumes.")
      end

      if size < 10
        raise Fog::AWS::Compute::Error.new("InvalidParameterValue => Volume of #{size}GiB is too small; minimum is 10GiB.")
      end

      if (iops_to_size_ratio = iops.to_f / size.to_f) > 30.0
        raise Fog::AWS::Compute::Error.new("InvalidParameterValue => Iops to volume size ratio of #{"%.1f" % iops_to_size_ratio} is too high; maximum is 30.0")
      end

      if iops < 100
        raise Fog::AWS::Compute::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too low; minimum is 100.")
      end

      if iops > 4000
        raise Fog::AWS::Compute::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too high; maximum is 4000.")
      end
    end

    if options['KmsKeyId'] && !options['Encrypted']
      raise Fog::AWS::Compute::Error.new("InvalidParameterDependency => The parameter KmsKeyId requires the parameter Encrypted to be set.")
    end

    response.status = 200
    volume_id = Fog::AWS::Mock.volume_id
    data = {
      'availabilityZone' => availability_zone,
      'attachmentSet'    => [],
      'createTime'       => Time.now,
      'iops'             => options['Iops'],
      'encrypted'        => options['Encrypted'] || false,
      'size'             => size,
      'snapshotId'       => options['SnapshotId'],
      'kmsKeyId'         => options['KmsKeyId'] || nil, # @todo validate
      'status'           => 'creating',
      'volumeId'         => volume_id,
      'volumeType'       => options['VolumeType'] || 'standard'
    }
    self.data[:volumes][volume_id] = data
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id
    }.merge!(data.reject {|key,value| !['availabilityZone','createTime','encrypted','size','snapshotId','status','volumeId','volumeType'].include?(key) })
  else
    response.status = 400
    response.body = {
      'Code' => 'MissingParameter'
    }
    unless availability_zone
      response.body['Message'] = 'The request must contain the parameter availability_zone'
    else
      response.body['Message'] = 'The request must contain the parameter size'
    end
  end
  response
end

#create_vpc(cidrBlock, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/create_vpc.rb', line 39

def create_vpc(cidrBlock, options = {})
  Excon::Response.new.tap do |response|
    if cidrBlock
      response.status = 200
      vpc_id = Fog::AWS::Mock.vpc_id
      vpc = {
        'vpcId'                       => vpc_id,
        'state'                       => 'pending',
        'cidrBlock'                   => cidrBlock,
        'dhcpOptionsId'               => Fog::AWS::Mock.request_id,
        'tagSet'                      => {},
        'enableDnsSupport'            => true,
        'enableDnsHostnames'          => false,
        'mapPublicIpOnLaunch'         => false,
        'classicLinkEnabled'          => false,
        'classicLinkDnsSupport'       => false,
        'cidrBlockAssociationSet'     => [{ 'cidrBlock' => cidrBlock, 'state' => 'associated', 'associationId' => "vpc-cidr-assoc-#{vpc_id}" }],
        'ipv6CidrBlockAssociationSet' => [],
        'instanceTenancy'             => options['InstanceTenancy'] || 'default'
      }
      self.data[:vpcs].push(vpc)

      #Creates a default route for the subnet
      default_route = self.route_tables.new(:vpc_id => vpc_id)
      default_route.save

      # You are not able to push a main route in the normal AWS, so we are re-implementing some of the
      # associate_route_table here in order to accomplish this.
      route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? default_route.id }

      # This pushes a main route to the associationSet
      # add_route_association(routeTableId, subnetId, main=false) is declared in assocate_route_table.rb
      assoc = add_route_association(default_route.id, nil, true)
      route_table["associationSet"].push(assoc)

      # Create a default network ACL
      default_nacl = self.network_acls.new(:vpc_id => vpc_id)
      default_nacl.save
      # Manually override since Amazon doesn't let you create a default one
      self.data[:network_acls][default_nacl.network_acl_id]['default'] = true


      # create default security groups
      default_elb_group_name = "default_elb_#{Fog::Mock.random_hex(6)}"
      default_elb_group_id = Fog::AWS::Mock.security_group_id

      Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:security_groups][default_elb_group_id] = {
        'groupDescription'    => 'default_elb security group',
        'groupName'           => default_elb_group_name,
        'groupId'             => default_elb_group_id,
        'ipPermissions'       => [],
        'ownerId'             => self.data[:owner_id],
        'vpcId'               => vpc_id
      }

      default_group_name = 'default'
      default_group_id = Fog::AWS::Mock.security_group_id

      Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:security_groups][default_group_id] = {
        'groupDescription'    => default_group_name,
        'groupName'           => default_group_name,
        'groupId'             => default_group_id,
        'ipPermissions'       => [],
        'ownerId'             => self.data[:owner_id],
        'vpcId'               => vpc_id
      }

      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'vpcSet'    => [vpc]
      }
    else
      response.status = 400
      response.body = {
        'Code' => 'InvalidParameterValue'
      }
      if cidrBlock.empty?
        response.body['Message'] = "Invalid value '' for cidrBlock. Must be specified."
      end
    end
  end
end

#data ⇒ `Object`



345
346
347

# File 'lib/fog/aws/compute.rb', line 345

def data
  self.region_data[@aws_access_key_id]
end

#default_vpc ⇒ `Object`

# File 'lib/fog/aws/compute.rb', line 385

def default_vpc
  vpc_id = describe_account_attributes.body["accountAttributeSet"].find{ |h| h["attributeName"] == "default-vpc" }["values"].first
  vpc_id == VPC_BLANK_VALUE ? nil : vpc_id
end

#default_vpc=(value) ⇒ `Object`



390
391
392

# File 'lib/fog/aws/compute.rb', line 390

def default_vpc=(value)
  self.data[:account_attributes].find { |h| h["attributeName"] == "default-vpc" }["values"] = [value]
end

#delete_dhcp_options(dhcp_options_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_dhcp_options.rb', line 30

def delete_dhcp_options(dhcp_options_id)
  Excon::Response.new.tap do |response|
    if dhcp_options_id
      response.status = 200
      self.data[:dhcp_options].reject! { |v| v['dhcpOptionsId'] == dhcp_options_id }

      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'return' => true
      }
    else
      message = 'MissingParameter => '
      message << 'The request must contain the parameter dhcp_options_id'
      raise Fog::AWS::Compute::Error.new(message)
    end
  end
end

#delete_internet_gateway(internet_gateway_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_internet_gateway.rb', line 28

def delete_internet_gateway(internet_gateway_id)
  Excon::Response.new.tap do |response|
    if internet_gateway_id
      response.status = 200
      self.data[:internet_gateways].delete(internet_gateway_id)

      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'return' => true
      }
    else
      message = 'MissingParameter => '
      message << 'The request must contain the parameter internet_gateway_id'
      raise Fog::AWS::Compute::Error.new(message)
    end
  end
end

#delete_key_pair(key_name) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_key_pair.rb', line 30

def delete_key_pair(key_name)
  response = Excon::Response.new
  self.data[:key_pairs].delete(key_name)
  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#delete_network_acl(network_acl_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_network_acl.rb', line 29

def delete_network_acl(network_acl_id)
  response = Excon::Response.new
  if self.data[:network_acls][network_acl_id]

    if self.data[:network_acls][network_acl_id]['associationSet'].any?
      raise Fog::AWS::Compute::Error.new("ACL is in use")
    end

    self.data[:network_acls].delete(network_acl_id)

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
  end
end

#delete_network_acl_entry(network_acl_id, rule_number, egress) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_network_acl_entry.rb', line 33

def delete_network_acl_entry(network_acl_id, rule_number, egress)
  response = Excon::Response.new
  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 }
      self.data[:network_acls][network_acl_id]['entrySet'].delete_if { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
    else
      raise Fog::AWS::Compute::Error.new("No rule with that number and egress value")
    end

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
  end
end

#delete_network_interface(network_interface_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_network_interface.rb', line 28

def delete_network_interface(network_interface_id)
  response = Excon::Response.new
  if self.data[:network_interfaces][network_interface_id]

    if self.data[:network_interfaces][network_interface_id]['attachment']['attachmentId']
      raise Fog::AWS::Compute::Error.new("Interface is in use")
    end

    self.data[:network_interfaces].delete(network_interface_id)

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network interface '#{network_interface_id}' does not exist")
  end
end

#delete_route(route_table_id, destination_cidr_block) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_route.rb', line 31

def delete_route(route_table_id, destination_cidr_block)
  route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
  unless route_table.nil?
    route = route_table['routeSet'].find { |route| route["destinationCidrBlock"].eql? destination_cidr_block }
    if !route.nil? && route['gatewayId'] != "local"
      route_table['routeSet'].delete(route)
      response = Excon::Response.new
      response.status = 200
      response.body = {
        'requestId'=> Fog::AWS::Mock.request_id,
        'return' => true
      }
      response
    elsif route['gatewayId'] == "local"
      # Cannot delete the default route
      raise Fog::AWS::Compute::Error, "InvalidParameterValue => cannot remove local route #{destination_cidr_block} in route table #{route_table_id}"
    else
      raise Fog::AWS::Compute::NotFound.new("no route with destination-cidr-block #{destination_cidr_block} in route table #{route_table_id}")
    end
  else
    raise Fog::AWS::Compute::NotFound.new("no route with destination-cidr-block #{destination_cidr_block} in route table #{route_table_id}")
  end
end

#delete_route_table(route_table_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_route_table.rb', line 29

def delete_route_table(route_table_id)
  route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
  if !route_table.nil? && route_table['associationSet'].empty?
    self.data[:route_tables].delete(route_table)
      response = Excon::Response.new
      response.status = 200
      response.body = {
        'requestId'=> Fog::AWS::Mock.request_id,
        'return' => true
      }
      response
  elsif route_table.nil?
    raise Fog::AWS::Compute::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
  elsif !route_table['associationSet'].empty?
    raise Fog::AWS::Compute::Error, "DependencyViolation => The routeTable '#{route_table_id}' has dependencies and cannot be deleted."
  end
end

#delete_security_group(name, id = nil) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_security_group.rb', line 41

def delete_security_group(name, id = nil)
  if name == 'default'
    raise Fog::AWS::Compute::Error.new("InvalidGroup.Reserved => The security group 'default' is reserved")
  end

  if name && id
    raise Fog::AWS::Compute::Error.new("May not specify both group_name and group_id")
  end

  if name
    id, _ = self.data[:security_groups].find { |_,v| v['groupName'] == name }
  end

  unless self.data[:security_groups][id]
    raise Fog::AWS::Compute::NotFound.new("The security group '#{id}' does not exist")
  end

  response = Excon::Response.new

  used_by_groups = []

  # ec2 authorizations
  self.region_data.each do |_, key_data|
    key_data[:security_groups].each do |group_id, group|
      next if group == self.data[:security_groups][group_id]

      group['ipPermissions'].each do |group_ip_permission|
        group_ip_permission['groups'].each do |group_group_permission|
          if group_group_permission['groupId'] == group_id &&
              group_group_permission['userId'] == self.data[:owner_id]
            used_by_groups << "#{key_data[:owner_id]}:#{group['groupName']}"
          end
        end
      end
    end
  end

  # rds authorizations
  Fog::AWS::RDS::Mock.data[self.region].each do |_, data|
    (data[:security_groups] || []).each do |group_name, group|
      (group["EC2SecurityGroups"] || []).each do |ec2_group|
        if ec2_group["EC2SecurityGroupName"] == name
          used_by_groups << "#{group["OwnerId"]}:#{group_name}"
        end
      end
    end
  end

  active_instances = self.data[:instances].values.select do |instance|
    if instance['groupSet'].include?(name) && instance['instanceState'] != "terminated"
      instance
    end
  end

  unless used_by_groups.empty?
    raise Fog::AWS::Compute::Error.new("InvalidGroup.InUse => Group #{self.data[:owner_id]}:#{name} is used by groups: #{used_by_groups.uniq.join(" ")}")
  end

  if active_instances.any?
    raise Fog::AWS::Compute::Error.new("InUse => There are active instances using security group '#{name}'")
  end

  self.data[:security_groups].delete(id)
  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#delete_snapshot(snapshot_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_snapshot.rb', line 30

def delete_snapshot(snapshot_id)
  response = Excon::Response.new
  if snapshot = self.data[:snapshots].delete(snapshot_id)
    response.status = true
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The snapshot '#{snapshot_id}' does not exist.")
  end
end

#delete_subnet(subnet_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_subnet.rb', line 29

def delete_subnet(subnet_id)
  Excon::Response.new.tap do |response|
    if subnet_id
      self.data[:subnets].reject! { |v| v['subnetId'] == subnet_id }
      response.status = 200

      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'return' => true
      }
    else
      message = 'MissingParameter => '
      message << 'The request must contain the parameter subnet_id'
      raise Fog::AWS::Compute::Error.new(message)
    end
  end
end

#delete_tags(resources, tags) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_tags.rb', line 42

def delete_tags(resources, tags)
  tagged = tagged_resources(resources)

  tags.each do |key, value|
    self.data[:tags][key][value] = self.data[:tags][key][value] - tagged
  end

  tagged.each do |resource|
    tags.each do |key, value|
      tagset = self.data[:tag_sets][resource['resourceId']]
      tagset.delete(key) if tagset.key?(key) && (value.nil? || tagset[key] == value)
    end
  end

  response = Excon::Response.new
  response.status = true
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#delete_volume(volume_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_volume.rb', line 30

def delete_volume(volume_id)
  response = Excon::Response.new
  if volume = self.data[:volumes][volume_id]
    if volume["attachmentSet"].any?
      attach = volume["attachmentSet"].first
      raise Fog::AWS::Compute::Error.new("Client.VolumeInUse => Volume #{volume_id} is currently attached to #{attach["instanceId"]}")
    end
    self.data[:deleted_at][volume_id] = Time.now
    volume['status'] = 'deleting'
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
  end
end

#delete_vpc(vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/delete_vpc.rb', line 32

def delete_vpc(vpc_id)
  Excon::Response.new.tap do |response|
    if vpc_id
      response.status = 200
      self.data[:vpcs].reject! { |v| v['vpcId'] == vpc_id }

      # Delete the default network ACL
      network_acl_id = self.network_acls.all('vpc-id' => vpc_id, 'default' => true).first.network_acl_id
      self.data[:network_acls].delete(network_acl_id)

      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'return' => true
      }
    else
      message = 'MissingParameter => '
      message << 'The request must contain the parameter vpc_id'
      raise Fog::AWS::Compute::Error.new(message)
    end
  end
end

#deregister_image(image_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/deregister_image.rb', line 29

def deregister_image(image_id)
  response = Excon::Response.new
  if image_id
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return' => "true"
    }
    response
  else
    message = 'MissingParameter => '
    if !instance_id
      message << 'The request must contain the parameter image_id'
    end
    raise Fog::AWS::Compute::Error.new(message)
  end
end

#describe_account_attributes(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_account_attributes.rb', line 34

def describe_account_attributes(filters = {})
  account_attributes = self.data[:account_attributes]

  Excon::Response.new(
    :status => 200,
    :body => {
      'requestId'           => Fog::AWS::Mock.request_id,
      'accountAttributeSet' => account_attributes
    }
  )
end

#describe_addresses(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_addresses.rb', line 36

def describe_addresses(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_addresses with #{filters.class} param is deprecated, use describe_addresses('public-ip' => []) instead [light_black](#{caller.first})[/]")
    filters = {'public-ip' => [*filters]}
  end

  response = Excon::Response.new

  addresses_set = self.data[:addresses].values

  aliases = {'public-ip' => 'publicIp', 'instance-id' => 'instanceId', 'allocation-id' => 'allocationId'}
  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    addresses_set = addresses_set.reject{|address| ![*filter_value].include?(address[aliased_key])}
  end

  response.status = 200
  response.body = {
    'requestId'     => Fog::AWS::Mock.request_id,
    'addressesSet'  => addresses_set
  }
  response
end

#describe_availability_zones(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_availability_zones.rb', line 37

def describe_availability_zones(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead [light_black](#{caller.first})[/]")
    filters = {'zone-name' => [*filters]}
  end

  response = Excon::Response.new

  all_zones = [
    {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1b", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1c", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1d", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1e", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "us-east-2", "zoneName" => "us-east-2a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-east-2", "zoneName" => "us-east-2b", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-east-2", "zoneName" => "us-east-2c", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "us-west-1", "zoneName" => "us-west-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-west-1", "zoneName" => "us-west-1b", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-west-1", "zoneName" => "us-west-1c", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "us-west-2", "zoneName" => "us-west-2a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "us-west-2", "zoneName" => "us-west-2b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "sa-east-1", "zoneName" => "sa-east-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "sa-east-1", "zoneName" => "sa-east-1b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1b", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1c", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "eu-west-2", "zoneName" => "eu-west-2a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "eu-west-2", "zoneName" => "eu-west-2b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "eu-west-3", "zoneName" => "eu-west-3a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "eu-west-3", "zoneName" => "eu-west-3b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "eu-central-1", "zoneName" => "eu-central-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "eu-central-1", "zoneName" => "eu-central-1b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "ca-central-1", "zoneName" => "ca-central-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "ca-central-1", "zoneName" => "ca-central-1b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "ap-northeast-1", "zoneName" => "ap-northeast-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "ap-northeast-1", "zoneName" => "ap-northeast-1b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "ap-northeast-2", "zoneName" => "ap-northeast-2a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "ap-northeast-2", "zoneName" => "ap-northeast-2b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "ap-southeast-1", "zoneName" => "ap-southeast-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "ap-southeast-1", "zoneName" => "ap-southeast-1b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "ap-southeast-2", "zoneName" => "ap-southeast-2a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "ap-southeast-2", "zoneName" => "ap-southeast-2b", "zoneState" => "available"},

    {"messageSet" => [], "regionName" => "ap-south-1", "zoneName" => "ap-south-1a", "zoneState" => "available"},
    {"messageSet" => [], "regionName" => "ap-south-1", "zoneName" => "ap-south-1b", "zoneState" => "available"},
  ]

  availability_zone_info = all_zones.select { |zoneinfo| zoneinfo["regionName"] == @region }

  aliases = {'region-name' => 'regionName', 'zone-name' => 'zoneName', 'state' => 'zoneState'}
  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    availability_zone_info = availability_zone_info.reject{|availability_zone| ![*filter_value].include?(availability_zone[aliased_key])}
  end

  response.status = 200
  response.body = {
    'availabilityZoneInfo'  => availability_zone_info,
    'requestId'             => Fog::AWS::Mock.request_id
  }
  response
end

#describe_classic_link_instances(options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_classic_link_instances.rb', line 41

def describe_classic_link_instances(options={})
  response = Excon::Response.new
  instances = self.data[:instances].values.select {|instance| instance['classicLinkVpcId']}
  if options[:filters]
    instances = apply_tag_filters(instances, options[:filters], 'instanceId')
    instances = instances.select {|instance| instance['classicLinkVpcId'] == options[:filters]['vpc-id']} if options[:filters]['vpc-id']
    instances = instances.select {|instance| instance['instanceId'] == options[:filters]['instance-id']} if options[:filters]['instance-id']
    instances = instances.select {|instance| instance['classicLinkSecurityGroups'].include?(options[:filters]['group-id'])} if options[:filters]['group-id']
  end
  instances = instances.select {|instance| options[:instance_ids].include?(instance['instanceId'])} if options[:instance_ids]



  response.status = 200
  instance_data = instances.collect do |instance| 
    groups = self.data[:security_groups].values.select {|data| instance['classicLinkSecurityGroups'].include?(data['groupId'])}
    {
      'instanceId' => instance['instanceId'],
      'vpcId' => instance['classicLinkVpcId'],
      'groups' => groups.collect {|group| {'groupId' => group['groupId'], 'groupName' => group['groupName']}},
      'tagSet' => self.data[:tag_sets][instance['instanceId']] || {}
    }
  end
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'instancesSet' => instance_data
  }
  response
end

#describe_dhcp_options(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_dhcp_options.rb', line 42

def describe_dhcp_options(filters = {})
  Excon::Response.new.tap do |response|
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'dhcpOptionsSet'    => self.data[:dhcp_options]
    }
  end
end

#describe_image_attribute(image_id, attribute) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_image_attribute.rb', line 42

def describe_image_attribute(image_id, attribute)
  response = Excon::Response.new
  if image = self.data[:images].values.find{ |i| i['imageId'] == image_id }
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'imageId'     => image_id
    }
    case attribute
    when 'kernel'
      response.body[attribute] = image["kernelId"]
    when 'ramdisk'
      response.body[attribute] = image["ramdiskId"]
    when 'sriovNetSupport'
      response.body[attribute] = 'simple'
    when 'launchPermission'
      if image_launch_permissions = self.data[:image_launch_permissions][image_id]
        response.body[attribute] = image_launch_permissions[:users]
      else
        response.body[attribute] = []
      end
    else
      response.body[attribute] = image[attribute]
    end
  response
  else
    raise Fog::AWS::Compute::NotFound.new("The Image '#{image_id}' does not exist")
  end
end

#describe_images(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_images.rb', line 60

def describe_images(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_images with #{filters.class} param is deprecated, use describe_images('image-id' => []) instead [light_black](#{caller.first})[/]")
    filters = {'image-id' => [*filters]}
  end

  if filters.keys.any? {|key| key =~ /^block-device/}
    Fog::Logger.warning("describe_images block-device-mapping filters are not yet mocked [light_black](#{caller.first})[/]")
    Fog::Mock.not_implemented
  end

  if owner = filters.delete('Owner')
    if owner == 'self'
      filters['owner-id'] = self.data[:owner_id]
    else
      filters['owner-alias'] = owner
    end
  end

  response = Excon::Response.new

  aliases = {
    'architecture'        => 'architecture',
    'description'         => 'description',
    'hypervisor'          => 'hypervisor',
    'image-id'            => 'imageId',
    'image-type'          => 'imageType',
    'is-public'           => 'isPublic',
    'kernel-id'           => 'kernelId',
    'manifest-location'   => 'manifestLocation',
    'name'                => 'name',
    'owner-alias'         => 'imageOwnerAlias',
    'owner-id'            => 'imageOwnerId',
    'ramdisk-id'          => 'ramdiskId',
    'root-device-name'    => 'rootDeviceName',
    'root-device-type'    => 'rootDeviceType',
    'state'               => 'imageState',
    'virtualization-type' => 'virtualizationType'
  }

  image_set = visible_images.values
  image_set = apply_tag_filters(image_set, filters, 'imageId')

  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    image_set = image_set.reject{|image| ![*filter_value].include?(image[aliased_key])}
  end

  image_set = image_set.map do |image|
    case image['imageState']
    when 'pending'
      if Time.now - image['registered'] >= Fog::Mock.delay
        image['imageState'] = 'available'
      end
    end
    image.reject { |key, value| ['registered'].include?(key) }.merge('tagSet' => self.data[:tag_sets][image['imageId']])
  end

  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'imagesSet' => image_set
  }
  response
end

#describe_instance_attribute(instance_id, attribute) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_instance_attribute.rb', line 55

def describe_instance_attribute(instance_id, attribute)
  response = Excon::Response.new
  if instance = self.data[:instances].values.find{ |i| i['instanceId'] == instance_id }
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'instanceId'     => instance_id
    }
    case attribute
    when 'kernel'
      response.body[attribute] = instance["kernelId"]
    when 'ramdisk'
      response.body[attribute] = instance["ramdiskId"]
    when 'disableApiTermination'
      response.body[attribute] = false
    when 'instanceInitiatedShutdownBehavior'
      response.body['instanceInitiatedShutdownBehavior'] = 'stop'
    when 'sourceDestCheck'
      response.body[attribute] = true
    when 'sriovNetSupport'
      response.body[attribute] = 'simple'
    else
      response.body[attribute] = instance[attribute]
    end
  response
  else
    raise Fog::AWS::Compute::NotFound.new("The Instance '#{instance_id}' does not exist")
  end
end

#describe_instance_status(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_instance_status.rb', line 32

def describe_instance_status(filters = {})
  response = Excon::Response.new
  response.status = 200

  response.body = {
    'instanceStatusSet' => [],
    'requestId' => Fog::AWS::Mock.request_id
  }

  response
end

#describe_instances(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_instances.rb', line 90

def describe_instances(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead [light_black](#{caller.first})[/]")
    filters = {'instance-id' => [*filters]}
  end

  response = Excon::Response.new

  instance_set = self.data[:instances].values
  instance_set = apply_tag_filters(instance_set, filters, 'instanceId')

  aliases = {
    'architecture'             => 'architecture',
    'availability-zone'        => 'availabilityZone',
    'client-token'             => 'clientToken',
    'dns-name'                 => 'dnsName',
    'group-id'                 => 'groupId',
    'image-id'                 => 'imageId',
    'instance-id'              => 'instanceId',
    'instance-lifecycle'       => 'instanceLifecycle',
    'instance-type'            => 'instanceType',
    'ip-address'               => 'ipAddress',
    'kernel-id'                => 'kernelId',
    'key-name'                 => 'key-name',
    'launch-index'             => 'launchIndex',
    'launch-time'              => 'launchTime',
    'monitoring-state'         => 'monitoringState',
    'owner-id'                 => 'ownerId',
    'placement-group-name'     => 'placementGroupName',
    'platform'                 => 'platform',
    'private-dns-name'         => 'privateDnsName',
    'private-ip-address'       => 'privateIpAddress',
    'product-code'             => 'productCode',
    'ramdisk-id'               => 'ramdiskId',
    'reason'                   => 'reason',
    'requester-id'             => 'requesterId',
    'reservation-id'           => 'reservationId',
    'root-device-name'         => 'rootDeviceName',
    'root-device-type'         => 'rootDeviceType',
    'spot-instance-request-id' => 'spotInstanceRequestId',
    'subnet-id'                => 'subnetId',
    'virtualization-type'      => 'virtualizationType',
    'vpc-id'                   => 'vpcId'
  }
  block_device_mapping_aliases = {
    'attach-time'           => 'attachTime',
    'delete-on-termination' => 'deleteOnTermination',
    'device-name'           => 'deviceName',
    'status'                => 'status',
    'volume-id'             => 'volumeId',
  }
  instance_state_aliases = {
    'code' => 'code',
    'name' => 'name'
  }
  state_reason_aliases = {
    'code'    => 'code',
    'message' => 'message'
  }
  for filter_key, filter_value in filters
    if block_device_mapping_key = filter_key.split('block-device-mapping.')[1]
      aliased_key = block_device_mapping_aliases[block_device_mapping_key]
      instance_set = instance_set.reject{|instance| !instance['blockDeviceMapping'].find {|block_device_mapping| [*filter_value].include?(block_device_mapping[aliased_key])}}
    elsif instance_state_key = filter_key.split('instance-state-')[1]
      aliased_key = instance_state_aliases[instance_state_key]
      instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['instanceState'][aliased_key])}
    elsif state_reason_key = filter_key.split('state-reason-')[1]
      aliased_key = state_reason_aliases[state_reason_key]
      instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['stateReason'][aliased_key])}
    elsif filter_key == "availability-zone"
      aliased_key = aliases[filter_key]
      instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['placement'][aliased_key])}
    elsif filter_key == "group-name"
      instance_set = instance_set.reject {|instance| !instance['groupSet'].include?(filter_value)}
    elsif filter_key == "group-id"
      group_ids = [*filter_value]
      security_group_names = self.data[:security_groups].values.select { |sg| group_ids.include?(sg['groupId']) }.map { |sg| sg['groupName'] }
      instance_set = instance_set.reject {|instance| (security_group_names & instance['groupSet']).empty?}
    else
      aliased_key = aliases[filter_key]
      instance_set = instance_set.reject {|instance| ![*filter_value].include?(instance[aliased_key])}
    end
  end

  brand_new_instances = instance_set.select do |instance|
    instance['instanceState']['name'] == 'pending' &&
      Time.now - instance['launchTime'] < Fog::Mock.delay * 2
  end

  # Error if filtering for a brand new instance directly
  if (filters['instance-id'] || filters['instanceId']) && !brand_new_instances.empty?
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{brand_new_instances.first['instanceId']}' does not exist")
  end

  # Otherwise don't include it in the list
  instance_set = instance_set.reject {|instance| brand_new_instances.include?(instance) }

  response.status = 200
  reservation_set = {}

  instance_set.each do |instance|
    case instance['instanceState']['name']
    when 'pending'
      if Time.now - instance['launchTime'] >= Fog::Mock.delay * 2
        instance['ipAddress']         = Fog::AWS::Mock.ip_address
        instance['originalIpAddress'] = instance['ipAddress']
        instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
        instance['instanceState']     = { 'code' => 16, 'name' => 'running' }
      end
    when 'rebooting'
      instance['instanceState'] = { 'code' => 16, 'name' => 'running' }
    when 'stopping'
      instance['instanceState'] = { 'code' => 0, 'name' => 'stopped' }
      instance['stateReason'] = { 'code' => 0 }
    when 'shutting-down'
      if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay * 2
        self.data[:deleted_at].delete(instance['instanceId'])
        self.data[:instances].delete(instance['instanceId'])
      elsif Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay
        instance['instanceState'] = { 'code' => 48, 'name' => 'terminating' }
      end
    when 'terminating'
      if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay
        self.data[:deleted_at].delete(instance['instanceId'])
        self.data[:instances].delete(instance['instanceId'])
      end
    end

    if self.data[:instances][instance['instanceId']]

      nics = self.data[:network_interfaces].select{|ni,ni_conf|
        ni_conf['attachment']['instanceId'] == instance['instanceId']
      }
      instance['networkInterfaces'] = nics.map{|ni,ni_conf|
        {
          'ownerId' => ni_conf['ownerId'],
          'subnetId' => ni_conf['subnetId'],
          'vpcId' => ni_conf['vpcId'],
          'networkInterfaceId' => ni_conf['networkInterfaceId'],
          'groupSet' => ni_conf['groupSet'],
          'attachmentId' => ni_conf['attachment']['attachmentId']
        }
      }
      if nics.count > 0

        instance['privateIpAddress'] = nics.sort_by {|ni, ni_conf|
          ni_conf['attachment']['deviceIndex']
        }.map{ |ni, ni_conf| ni_conf['privateIpAddress'] }.first

        instance['privateDnsName'] = Fog::AWS::Mock.private_dns_name_for(instance['privateIpAddress'])
      else
        instance['privateIpAddress'] = ''
        instance['privateDnsName'] = ''
      end

      reservation_set[instance['reservationId']] ||= {
        'groupSet'      => instance['groupSet'],
        'groupIds'      => instance['groupIds'],
        'instancesSet'  => [],
        'ownerId'       => instance['ownerId'],
        'reservationId' => instance['reservationId']
      }
      reservation_set[instance['reservationId']]['instancesSet'] << instance.reject{|key,value| !['amiLaunchIndex', 'architecture', 'blockDeviceMapping', 'clientToken', 'dnsName', 'ebsOptimized', 'hypervisor', 'iamInstanceProfile', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'ipAddress', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'networkInterfaces', 'ownerId', 'placement', 'platform', 'privateDnsName', 'privateIpAddress', 'productCodes', 'ramdiskId', 'reason', 'rootDeviceName', 'rootDeviceType', 'spotInstanceRequestId', 'stateReason', 'subnetId', 'virtualizationType'].include?(key)}.merge('tagSet' => self.data[:tag_sets][instance['instanceId']])
    end
  end

  response.body = {
    'requestId'       => Fog::AWS::Mock.request_id,
    'reservationSet' => reservation_set.values
  }
  response
end

#describe_internet_gateways(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_internet_gateways.rb', line 41

def describe_internet_gateways(filters = {})
  internet_gateways = self.data[:internet_gateways].values

  if filters['internet-gateway-id']
    internet_gateways = internet_gateways.reject {|internet_gateway| internet_gateway['internetGatewayId'] != filters['internet-gateway-id']}
  end

  Excon::Response.new(
    :status => 200,
    :body   => {
      'requestId'           => Fog::AWS::Mock.request_id,
      'internetGatewaySet'  => internet_gateways
    }
  )
end

#describe_key_pairs(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_key_pairs.rb', line 36

def describe_key_pairs(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_key_pairs with #{filters.class} param is deprecated, use describe_key_pairs('key-name' => []) instead [light_black](#{caller.first})[/]")
    filters = {'key-name' => [*filters]}
  end

  response = Excon::Response.new

  key_set = self.data[:key_pairs].values

  aliases = {'fingerprint' => 'keyFingerprint', 'key-name' => 'keyName'}
  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    key_set = key_set.reject{|key_pair| ![*filter_value].include?(key_pair[aliased_key])}
  end

  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'keySet'    => key_set.map do |key_pair|
      key_pair.reject {|key,value| !['keyFingerprint', 'keyName'].include?(key)}
    end
  }
  response
end

#describe_network_acls(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_network_acls.rb', line 52

def describe_network_acls(filters = {})
  response = Excon::Response.new

  network_acls = self.data[:network_acls].values
  network_acls = apply_tag_filters(network_acls, filters, 'networkAclId')

  aliases = {
    'vpc-id'         => 'vpcId',
    'network-acl-id' => 'networkAclId',
    'default'        => 'default',
  }
  association_aliases = {
    'association-id' => 'networkAclAssociationId',
    'network-acl-id' => 'networkAclId',
    'subnet-id'      => 'subnetId',
  }
  entry_aliases = {
    'cidr'        => 'cidrBlock',
    'egress'      => 'egress',
    'rule-action' => 'ruleAction',
    'rule-number' => 'ruleNumber',
    'protocol'    => 'protocol'
  }
  for filter_key, filter_value in filters
    filter_key = filter_key.to_s
    if association_key = filter_key.split('association.')[1]
      aliased_key = association_aliases[association_key]
      network_acls = network_acls.reject{|nacl| !nacl['associationSet'].find {|association| [*filter_value].include?(association[aliased_key])}}
    elsif entry_key = filter_key.split('entry.icmp.')[1]
      network_acls = network_acls.reject{|nacl| !nacl['entrySet'].find {|association| [*filter_value].include?(association['icmpTypeCode'][entry_key])}}
    elsif entry_key = filter_key.split('entry.port-range.')[1]
      network_acls = network_acls.reject{|nacl| !nacl['entrySet'].find {|association| [*filter_value].include?(association['portRange'][entry_key])}}
    elsif entry_key = filter_key.split('entry.')[1]
      aliased_key = entry_aliases[entry_key]
      network_acls = network_acls.reject{|nacl| !nacl['entrySet'].find {|association| [*filter_value].include?(association[aliased_key])}}
    else
      aliased_key = aliases[filter_key]
      network_acls = network_acls.reject{|nacl| ![*filter_value].include?(nacl[aliased_key])}
    end
  end

  network_acls.each do |acl|
    tags = self.data[:tag_sets][acl['networkAclId']]
    acl.merge!('tagSet' => tags) if tags
  end

  response.status = 200
  response.body = {
    'requestId'     => Fog::AWS::Mock.request_id,
    'networkAclSet' => network_acls
  }
  response
end

#describe_network_interface_attribute(network_interface_id, attribute) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_network_interface_attribute.rb', line 43

def describe_network_interface_attribute(network_interface_id, attribute)
  response = Excon::Response.new
  network_interface = self.data[:network_interfaces][network_interface_id]


  unless network_interface
    raise Fog::AWS::Compute::NotFound.new("The network interface '#{network_interface_id}' does not exist")
  end

  response.status = 200
  response.body = {
    'requestId'          => Fog::AWS::Mock.request_id,
    'networkInterfaceId' => network_interface_id
  }
  case attribute
  when 'description', 'groupSet', 'sourceDestCheck', 'attachment'
    response.body[attribute] = network_interface[attribute]
  else
    raise Fog::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
  end
  response
end

#describe_network_interfaces(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_network_interfaces.rb', line 66

def describe_network_interfaces(filters = {})
  response = Excon::Response.new

  network_interface_info = self.data[:network_interfaces].values

  if subnet_filter = filters.delete('subnet-id')
    filters['subnetId'] = subnet_filter
  end

  for filter_key, filter_value in filters
    network_interface_info = network_interface_info.reject{|nic| ![*filter_value].include?(nic[filter_key])}
  end

  response.status = 200
  response.body = {
    'requestId'           => Fog::AWS::Mock.request_id,
    'networkInterfaceSet' => network_interface_info
  }
  response
end

#describe_regions(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_regions.rb', line 36

def describe_regions(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_regions with #{filters.class} param is deprecated, use describe_regions('region-name' => []) instead [light_black](#{caller.first})[/]")
    filters = {'region-name' => [*filters]}
  end

  response = Excon::Response.new
  region_info = [
    {"regionName"=>"eu-west-1", "regionEndpoint"=>"eu-west-1.ec2.amazonaws.com"},
    {"regionName"=>"us-east-1", "regionEndpoint"=>"us-east-1.ec2.amazonaws.com"}
  ]

  aliases = {'region-name' => 'regionName', 'endpoint' => 'regionEndpoint'}
  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    region_info = region_info.reject{|region| ![*filter_value].include?(region[aliased_key])}
  end

  response.status = 200
  response.body = {
    'requestId'   => Fog::AWS::Mock.request_id,
    'regionInfo'  => region_info
  }
  response
end

#describe_reserved_instances(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_reserved_instances.rb', line 49

def describe_reserved_instances(filters = {})
  response = Excon::Response.new
  response.status = 200

  response.body = {
    'reservedInstancesSet' => self.data[:reserved_instances].values,
    'requestId' => Fog::AWS::Mock.request_id
  }

  response
end

#describe_reserved_instances_offerings(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_reserved_instances_offerings.rb', line 56

def describe_reserved_instances_offerings(filters = {})
  response = Excon::Response.new
  response.status = 200

  self.data[:reserved_instances_offerings] ||= [{
    'reservedInstancesOfferingId' => Fog::AWS::Mock.reserved_instances_offering_id,
    'instanceType'                => 'm1.small',
    'availabilityZone'            => 'us-east-1d',
    'duration'                    => 31536000,
    'fixedPrice'                  => 350.0,
    'offeringType'                => 'Medium Utilization',
    'usagePrice'                  => 0.03,
    'productDescription'          => 'Linux/UNIX',
    'instanceTenancy'             => 'default',
    'currencyCode'                => 'USD'
  }]

  response.body = {
    'reservedInstancesOfferingsSet' => self.data[:reserved_instances_offerings],
    'requestId' => Fog::AWS::Mock.request_id,
    'nextToken' => (0...64).map { ('a'..'z').to_a[rand(26)] }.join
  }

  response
end

#describe_route_tables(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_route_tables.rb', line 56

def describe_route_tables(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_route_tables with #{filters.class} param is deprecated, use describe_route_tables('route-table-id' => []) instead [light_black](#{caller.first})[/]")
    filters = {'route-table-id' => [*filters]}
  end

  display_routes = self.data[:route_tables].dup

  aliases = {
    'route-table-id'  => 'routeTableId',
    'vpc-id'          => 'vpcId'
  }

  for filter_key, filter_value in filters
    filter_attribute = aliases[filter_key]
    case filter_attribute
    when 'routeTableId', 'vpcId'
      display_routes.reject! { |routetable| routetable[filter_attribute] != filter_value }
    end
  end

  display_routes.each do |route|
    tags = self.data[:tag_sets][route['routeTableId']]
    route.merge!('tagSet' => tags) if tags
  end

  Excon::Response.new(
    :status => 200,
    :body   => {
      'requestId' => Fog::AWS::Mock.request_id,
      'routeTableSet'    => display_routes
    }
  )
end

#describe_security_groups(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_security_groups.rb', line 60

def describe_security_groups(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_security_groups with #{filters.class} param is deprecated, use describe_security_groups('group-name' => []) instead [light_black](#{caller.first})[/]")
    filters = {'group-name' => [*filters]}
  end

  response = Excon::Response.new

  security_group_info = self.data[:security_groups].reject { |k,v| k['amazon-elb-sg'] }.values

  aliases = {
    'description' => 'groupDescription',
    'group-name'  => 'groupName',
    'group-id'    => 'groupId',
    'owner-id'    => 'ownerId'
  }
  permission_aliases = {
    'cidr'      => 'cidrIp',
    'from-port' => 'fromPort',
    'protocol'  => 'ipProtocol',
    'to-port'   => 'toPort'
  }

  security_group_groups = lambda do |security_group|
    (security_group['ipPermissions'] || []).map do |permission|
      permission['groups']
    end.flatten.compact.uniq
  end

  for filter_key, filter_value in filters
    if permission_key = filter_key.split('ip-permission.')[1]
      if permission_key == 'group-name'
        security_group_info = security_group_info.reject do |security_group|
          !security_group_groups.call(security_group).find do |group|
            [*filter_value].include?(group['groupName'])
          end
        end
      elsif permission_key == 'group-id'
        security_group_info = security_group_info.reject do |security_group|
          !security_group_groups.call(security_group).find do |group|
            [*filter_value].include?(group['groupId'])
          end
        end
      elsif permission_key == 'user-id'
        security_group_info = security_group_info.reject do |security_group|
          !security_group_groups.call(security_group).find do |group|
            [*filter_value].include?(group['userId'])
          end
        end
      else
        aliased_key = permission_aliases[filter_key]
        security_group_info = security_group_info.reject do |security_group|
          !security_group['ipPermissions'].find do |permission|
            [*filter_value].include?(permission[aliased_key])
          end
        end
      end
    else
      aliased_key = aliases[filter_key]
      security_group_info = security_group_info.reject do |security_group|
        ![*filter_value].include?(security_group[aliased_key])
      end
    end
  end

  response.status = 200
  response.body = {
    'requestId'         => Fog::AWS::Mock.request_id,
    'securityGroupInfo' => security_group_info
  }
  response
end

#describe_snapshots(filters = {}, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_snapshots.rb', line 53

def describe_snapshots(filters = {}, options = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_snapshots with #{filters.class} param is deprecated, use describe_snapshots('snapshot-id' => []) instead [light_black](#{caller.first})[/]")
    filters = {'snapshot-id' => [*filters]}
  end
  unless options.empty?
    Fog::Logger.deprecation("describe_snapshots with a second param is deprecated, use describe_snapshots(options) instead [light_black](#{caller.first})[/]")
  end

  response = Excon::Response.new

  snapshot_set = self.data[:snapshots].values

  if filters.delete('owner-alias')
    Fog::Logger.warning("describe_snapshots with owner-alias is not mocked [light_black](#{caller.first})[/]")
  end
  if (restorable_by = filters.delete('RestorableBy')) && restorable_by != 'self'
    Fog::Logger.warning("describe_snapshots with RestorableBy other than 'self' (wanted #{restorable_by.inspect}) is not mocked [light_black](#{caller.first})[/]")
  end

  snapshot_set = apply_tag_filters(snapshot_set, filters, 'snapshotId')

  aliases = {
    'description' => 'description',
    'encrypted'   => 'encrypted',
    'owner-id'    => 'ownerId',
    'progress'    => 'progress',
    'snapshot-id' => 'snapshotId',
    'start-time'  => 'startTime',
    'status'      => 'status',
    'volume-id'   => 'volumeId',
    'volume-size' => 'volumeSize'
  }

  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    snapshot_set = snapshot_set.reject{|snapshot| ![*filter_value].include?(snapshot[aliased_key])}
  end

  snapshot_set.each do |snapshot|
    case snapshot['status']
    when 'in progress', 'pending'
      if Time.now - snapshot['startTime'] >= Fog::Mock.delay * 2
        snapshot['progress']  = '100%'
        snapshot['status']    = 'completed'
      elsif Time.now - snapshot['startTime'] >= Fog::Mock.delay
        snapshot['progress']  = '50%'
        snapshot['status']    = 'in progress'
      else
        snapshot['progress']  = '0%'
        snapshot['status']    = 'in progress'
      end
    end
  end

  snapshot_set = snapshot_set.map {|snapshot| snapshot.merge('tagSet' => self.data[:tag_sets][snapshot['snapshotId']]) }

  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'snapshotSet' => snapshot_set
  }
  response
end

#describe_spot_instance_requests(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_spot_instance_requests.rb', line 46

def describe_spot_instance_requests(filters = {})
  response = Excon::Response.new
  spot_requests = self.data[:spot_requests].values

  if id = Array(filters['spot-instance-request-id']).first
    spot_requests = spot_requests.select { |r| r['spotInstanceRequestId'] == id }
  end

  spot_requests.select { |r| r['instanceId'].nil? }.each do |request|
    run_instance_options = {
      'BlockDeviceMapping'    => request['launchSpecification']['blockDeviceMapping'],
      'EbsOptimized'          => request['launchSpecification']['ebsOptimized'],
      'KeyName'               => request['launchSpecification']['keyName'],
      'SecurityGroupId'       => request['launchSpecification']['groupSet'].first,
      'SpotInstanceRequestId' => request['spotInstanceRequestId'],
      'SubnetId'              => request['launchSpecification']['subnetId']
    }
    instances = run_instances(request['launchSpecification']['imageId'], 1,1, run_instance_options).body['instancesSet']

    request['instanceId'] = instances.first['instanceId']
    request['state'] = 'active'
    request['fault'] = {'code' => 'fulfilled', 'message' => 'Your Spot request is fulfilled.'}
    request['launchedAvailabilityZone'] = instances.first['placement']['availabilityZone']

    self.data[:spot_requests][request['spotInstanceRequestId']] = request
  end

  response.body = {'spotInstanceRequestSet' => spot_requests, 'requestId' => Fog::AWS::Mock.request_id}
  response
end

#describe_spot_price_history(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_spot_price_history.rb', line 61

def describe_spot_price_history(filters = {})
  params = {}
  spot_price_history_set = []

  response = Excon::Response.new
  response.status = 200

  for key in %w(StartTime EndTime NextToken)
    if filters.is_a?(Hash) && filters.key?(key)
      Fog::Logger.warning("#{key} filters are not yet mocked [light_black](#{caller.first})[/]")
      Fog::Mock.not_implemented
    end
  end

  for key in %w(AvailabilityZone MaxResults)
    if filters.is_a?(Hash) && filters.key?(key)
      params[key] = filters.delete(key)
    end
  end

  all_zones = describe_availability_zones.body['availabilityZoneInfo'].map { |z| z['zoneName'] }
  zones = params['AvailabilityZone']
  if (!zones.nil? && !all_zones.include?([*zones].shuffle.first))
    az_error = "InvalidParameterValue => Invalid availability zone: [#{zones}]"
    raise Fog::AWS::Compute::Error, az_error
  end
  zones = all_zones if zones.nil?

  max_results = params['MaxResults'] || Fog::Mock.random_numbers(3).to_i
  if !(max_results.is_a?(Integer) && max_results > 0)
    max_results_error = "InvalidParameterValue => Invalid value '#{max_results}' for maxResults"
    raise Fog::AWS::Compute::Error, max_results_error
  end

  all_instance_types = flavors.map { |f| f.id }
  instance_types = filters.delete('InstanceType') || all_instance_types
  product_descriptions = filters.delete('ProductDescription') || Fog::AWS::Mock.spot_product_descriptions

  max_results.times do
    spot_price_history_set << {
      'instanceType'       => [*instance_types].shuffle.first,
      'productDescription' => [*product_descriptions].shuffle.first,
      'spotPrice'          => ((rand + [0 , 1].shuffle.first) * 10000).round / 10000.0,
      'timestamp'          => Time.now - (1 + rand(86400)),
      'availabilityZone'   => [*zones].shuffle.first
    }
  end
  spot_price_history_set.sort! { |x,y| x['timestamp'] <=> y['timestamp'] }

  response.body = {
    'spotPriceHistorySet' => spot_price_history_set,
    'requestId'           => Fog::AWS::Mock.request_id,
    'nextToken'           => nil
  }
  response
end

#describe_subnets(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_subnets.rb', line 46

def describe_subnets(filters = {})
  subnets = self.data[:subnets]

  # Transition from pending to available
  subnets.each do |subnet|
    case subnet['state']
      when 'pending'
        subnet['state'] = 'available'
    end
  end

  if filters['subnet-id']
    subnets = subnets.reject {|subnet| subnet['subnetId'] != filters['subnet-id']}
  end

  Excon::Response.new(
    :status => 200,
    :body   => {
      'requestId' => Fog::AWS::Mock.request_id,
      'subnetSet' => subnets
    }
  )
end

#describe_tags(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_tags.rb', line 34

def describe_tags(filters = {})
  response = Excon::Response.new

  tag_set = deep_clone(self.data[:tags])

  aliases = {
    'key'               => 'key',
    'resource-id'       => 'resourceId',
    'resource-type'     => 'resourceType',
    'value'             => 'value'
  }

  for filter_key, filter_value in filters
    filter_attribute = aliases[filter_key]
    case filter_attribute
    when 'key'
      tag_set.reject! { |k,_| k != filter_value }
    when 'value'
      tag_set.each { |k,values| values.reject! { |v, _| v != filter_value } }
    when 'resourceId'
      filter_resources(tag_set, 'resourceId', filter_value)
    when 'resourceType'
      filter_resources(tag_set, 'resourceType', filter_value)
    end
  end

  tagged_resources = []
  tag_set.each do |key, values|
    values.each do |value, resources|
      resources.each do |resource|
        tagged_resources << resource.merge({
          'key' => key,
          'value' => value
        })
      end
    end
  end

  response.status = 200
  response.body = {
    'requestId'       => Fog::AWS::Mock.request_id,
    'tagSet'          => tagged_resources
  }
  response
end

#describe_volume_status(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_volume_status.rb', line 29

def describe_volume_status(filters = {})
  response = Excon::Response.new
  response.status = 200

  response.body = {
    'volumeStatusSet' => [],
    'requestId' => Fog::AWS::Mock.request_id
  }

  response
end

#describe_volumes(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_volumes.rb', line 49

def describe_volumes(filters = {})
  unless filters.is_a?(Hash)
    Fog::Logger.deprecation("describe_volumes with #{filters.class} param is deprecated, use describe_volumes('volume-id' => []) instead [light_black](#{caller.first})[/]")
    filters = {'volume-id' => [*filters]}
  end

  response = Excon::Response.new

  volume_set = self.data[:volumes].values
  volume_set = apply_tag_filters(volume_set, filters, 'volumeId')

  aliases = {
    'availability-zone' => 'availabilityZone',
    'create-time' => 'createTime',
    'encrypted' => 'encrypted',
    'size' => 'size',
    'snapshot-id' => 'snapshotId',
    'status' => 'status',
    'volume-id' => 'volumeId'
  }
  attachment_aliases = {
    'attach-time' => 'attachTime',
    'delete-on-termination' => 'deleteOnTermination',
    'device'      => 'device',
    'instance-id' => 'instanceId',
    'status'      => 'status'
  }

  for filter_key, filter_value in filters
    if attachment_key = filter_key.split('attachment.')[1]
      aliased_key = attachment_aliases[filter_key]
      volume_set = volume_set.reject{|volume| !volume['attachmentSet'].find {|attachment| [*filter_value].include?(attachment[aliased_key])}}
    else
      aliased_key = aliases[filter_key]
      volume_set = volume_set.reject{|volume| ![*filter_value].include?(volume[aliased_key])}
    end
  end

  volume_set.each do |volume|
    case volume['status']
    when 'attaching'
      if Time.now - volume['attachmentSet'].first['attachTime'] >= Fog::Mock.delay
        volume['attachmentSet'].first['status'] = 'in-use'
        volume['status'] = 'in-use'
      end
    when 'creating'
      if Time.now - volume['createTime'] >= Fog::Mock.delay
        volume['status'] = 'available'
      end
    when 'deleting'
      if Time.now - self.data[:deleted_at][volume['volumeId']] >= Fog::Mock.delay
        self.data[:deleted_at].delete(volume['volumeId'])
        self.data[:volumes].delete(volume['volumeId'])
      end
    end
  end
  volume_set = volume_set.reject {|volume| !self.data[:volumes][volume['volumeId']]}
  volume_set = volume_set.map {|volume| volume.merge('tagSet' => self.data[:tag_sets][volume['volumeId']]) }

  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'volumeSet' => volume_set
  }
  response
end

#describe_volumes_modifications(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_volumes_modifications.rb', line 43

def describe_volumes_modifications(filters = {})
  response = Excon::Response.new

  modification_set = self.data[:volume_modifications].values

  aliases = {
    'volume-id'            => 'volumeId',
    'modification-state'   => 'modificationState',
    'target-size'          => 'targetSize',
    'target-iops'          => 'targetIops',
    'target-volume-type'   => 'targetVolumeType',
    'original-size'        => 'originalSize',
    'original-iops'        => 'originalIops',
    'original-volume-type' => 'originalVolumeType',
    'start-time'           => 'startTime'
  }

  attribute_aliases = {
    'targetSize'       => 'size',
    'targetVolumeType' => 'volumeType',
    'targetIops'       => 'iops'
  }

  for filter_key, filter_value in filters
    aliased_key = aliases[filter_key]
    modification_set = modification_set.reject { |m| ![*filter_value].include?(m[aliased_key]) }
  end

  modification_set.each do |modification|
    case modification['modificationState']
    when 'modifying'
      volume = self.data[:volumes][modification['volumeId']]
      modification['modificationState'] = 'optimizing'
      %w(targetSize targetIops targetVolumeType).each do |attribute|
        aliased_attribute = attribute_aliases[attribute]
        volume[aliased_attribute] = modification[attribute] if modification[attribute]
      end
      self.data[:volumes][modification['volumeId']] = volume
    when 'optimizing'
      modification['modificationState'] = 'completed'
      modification['endTime']           = Time.now
    end
  end

  response.body = {'requestId' => Fog::AWS::Mock.request_id, 'volumeModificationSet' => modification_set}
  response
end

#describe_vpc_attribute(vpc_id, attribute) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_vpc_attribute.rb', line 32

def describe_vpc_attribute(vpc_id, attribute)
  response = Excon::Response.new
  if vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'vpcId'     => vpc_id
    }

    case attribute
    when 'enableDnsSupport', 'enableDnsHostnames'
      response.body[attribute] = vpc[attribute]
    else
      raise Fog::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
    end
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist")
  end
end

#describe_vpc_classic_link(options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_vpc_classic_link.rb', line 35

def describe_vpc_classic_link(options={})
  response = Excon::Response.new
  vpcs = self.data[:vpcs]
  if vpc_ids = options[:vpc_ids]
    vpcs = vpc_ids.collect do |vpc_id|
      vpc = vpcs.find{ |v| v['vpcId'] == vpc_id }
      raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist") unless vpc
      vpc
    end
  end
  vpcs = apply_tag_filters(vpcs, options[:filters], 'vpcId') if options[:filters]

  response.status = 200
  vpc_data = vpcs.collect do |vpc|
    {
      'vpcId' => vpc['vpcId'],
      'classicLinkEnabled' => vpc['classicLinkEnabled'],
      'tagSet' => self.data[:tag_sets][vpc['vpcId']] || {}
    }
  end
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'vpcSet' => vpc_data
  }
  response
end

#describe_vpc_classic_link_dns_support(options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_vpc_classic_link_dns_support.rb', line 38

def describe_vpc_classic_link_dns_support(options={})
  response = Excon::Response.new

  vpcs = self.data[:vpcs]

  if options[:vpc_ids]
    vpcs = vpcs.select { |v| options[:vpc_ids].include?(v['vpcId']) }
  end

  response.body = {'vpcs' => vpcs.map { |v| {"vpcId" => v['vpcId'], "classicLinkDnsSupported" => v['classicLinkDnsSupport']} } }
  response
end

#describe_vpcs(filters = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/describe_vpcs.rb', line 42

def describe_vpcs(filters = {})
  vpcs = self.data[:vpcs]
  vpcs = apply_tag_filters(vpcs, filters, 'vpcId')

  # Transition from pending to available
  vpcs.each do |vpc|
    case vpc['state']
      when 'pending'
        vpc['state'] = 'available'
    end
  end

  if filters['vpc-id']
    vpcs = vpcs.reject {|vpc| vpc['vpcId'] != filters['vpc-id']}
  end

  vpcs.each do |vpc|
    tags = self.data[:tag_sets][vpc['vpcId']]
    vpc.merge!('tagSet' => tags) if tags
  end

  Excon::Response.new(
    :status => 200,
    :body   => {
      'requestId' => Fog::AWS::Mock.request_id,
      'vpcSet'    => vpcs
    }
  )
end

#detach_classic_link_vpc(instance_id, vpc_id, dry_run = false) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/detach_classic_link_vpc.rb', line 34

def detach_classic_link_vpc(instance_id, vpc_id, dry_run=false)
  response = Excon::Response.new
  vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
  instance = self.data[:instances][instance_id]
  if vpc && instance
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    unless dry_run
      instance['classicLinkSecurityGroups'] = nil
      instance['classicLinkVpcId'] = nil
    end
    response
  elsif !instance
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist.")
  elsif !vpc
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist.")
  end
end

#detach_internet_gateway(internet_gateway_id, vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/detach_internet_gateway.rb', line 31

def detach_internet_gateway(internet_gateway_id, vpc_id)
  response = Excon::Response.new
  if internet_gateway_id && vpc_id
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return' => true
    }
    response
  else
    if !internet_gateway_id
      message << 'The request must contain the parameter internet_gateway_id'
    elsif !vpc_id
      message << 'The request must contain the parameter vpc_id'
    end
    raise Fog::AWS::Compute::Error.new(message)
  end
end

#detach_network_interface(attachment_id, force = false) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/detach_network_interface.rb', line 30

def detach_network_interface(attachment_id, force = false)
  response = Excon::Response.new
  nic_id = self.data[:network_interfaces].select { |k,v| v['attachment']['attachmentId'] == attachment_id} .first.first
  if nic_id
    self.data[:network_interfaces][nic_id]["attachment"] = {}
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network interface '#{network_interface_id}' does not exist")
  end
end

#detach_volume(volume_id, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/detach_volume.rb', line 38

def detach_volume(volume_id, options = {})
  response = Excon::Response.new
  response.status = 200
  if (volume = self.data[:volumes][volume_id])
    if !volume['attachmentSet'].empty?
      data = volume['attachmentSet'].pop
      volume['status'] = 'available'
      response.status = 200
      response.body = {
        'requestId' => Fog::AWS::Mock.request_id
      }.merge!(data)
      response
    else
      # real response has spacing issue below
      raise Fog::AWS::Compute::Error.new("IncorrectState => Volume '#{volume_id}'is in the 'available' state.")
    end
  else
    raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
  end
end

#disable_ec2_classic ⇒ `Object`



377
378
379

# File 'lib/fog/aws/compute.rb', line 377

def disable_ec2_classic
  set_supported_platforms(%w[VPC])
end

#disable_vpc_classic_link(vpc_id, dry_run = false) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/disable_vpc_classic_link.rb', line 30

def disable_vpc_classic_link(vpc_id, dry_run=false)
  response = Excon::Response.new
  if vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    vpc['classicLinkEnabled'] = false unless dry_run
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist")
  end
end

#disable_vpc_classic_link_dns_support(vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/disable_vpc_classic_link_dns_support.rb', line 30

def disable_vpc_classic_link_dns_support(vpc_id)
  response = Excon::Response.new
  unless vpc = self.data[:vpcs].find { |v| v['vpcId'] == vpc_id }
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist")
  end
  vpc['classicLinkDnsSupport'] = false
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#disassociate_address(public_ip, association_id = nil) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/disassociate_address.rb', line 32

def disassociate_address(public_ip, association_id=nil)
  response = Excon::Response.new
  response.status = 200
  if address = self.data[:addresses][public_ip]
    if address['allocationId'] && association_id.nil?
      raise Fog::AWS::Compute::Error.new("InvalidParameterValue => You must specify an association id when unmapping an address from a VPC instance")
    end
    instance_id = address['instanceId']
    if instance = self.data[:instances][instance_id]
      instance['ipAddress']         = instance['originalIpAddress']
      instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
    end
    address['instanceId'] = nil
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
  end
end

#disassociate_route_table(association_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/disassociate_route_table.rb', line 29

def disassociate_route_table(association_id)
  assoc_array = nil
  routetable = self.data[:route_tables].find { |routetable|
    assoc_array = routetable["associationSet"].find { |association|
      association['routeTableAssociationId'].eql? association_id
    }
  }
  if !assoc_array.nil? && assoc_array['main'] == false
    routetable['associationSet'].delete(assoc_array)
    response = Excon::Response.new
    response.status = 200
    response.body = {
        'requestId'     => Fog::AWS::Mock.request_id,
        'return'        => true
    }
    response
  elsif assoc_array.nil?
    raise Fog::AWS::Compute::NotFound.new("The association ID '#{association_id}' does not exist")
  elsif assoc_array['main'] == true
    raise Fog::AWS::Compute::Error, "InvalidParameterValue => cannot disassociate the main route table association #{association_id}"
  end
end

#enable_ec2_classic ⇒ `Object`



373
374
375

# File 'lib/fog/aws/compute.rb', line 373

def enable_ec2_classic
  set_supported_platforms(%w[EC2 VPC])
end

#enable_vpc_classic_link(vpc_id, dry_run = false) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/enable_vpc_classic_link.rb', line 30

def enable_vpc_classic_link(vpc_id, dry_run=false)
  response = Excon::Response.new
  if vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    vpc['classicLinkEnabled'] = true unless dry_run
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist")
  end
end

#enable_vpc_classic_link_dns_support(vpc_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/enable_vpc_classic_link_dns_support.rb', line 30

def enable_vpc_classic_link_dns_support(vpc_id)
  response = Excon::Response.new
  unless vpc = self.data[:vpcs].find { |v| v['vpcId'] == vpc_id }
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist")
  end
  vpc['classicLinkDnsSupport'] = true
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'return'    => true
  }
  response
end

#find_matching_permission_egress(group, permission) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/authorize_security_group_egress.rb', line 104

def find_matching_permission_egress(group, permission)
  group['ipPermissionsEgress'].find do |group_permission|
    permission['ipProtocol'] == group_permission['ipProtocol'] &&
      permission['fromPort'] == group_permission['fromPort'] &&
      permission['toPort'] == group_permission['toPort']
  end
end

#get_console_output(instance_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/get_console_output.rb', line 32

def get_console_output(instance_id)
  response = Excon::Response.new
  if instance = self.data[:instances][instance_id]
    response.status = 200
    response.body = {
      'instanceId'    => instance_id,
      'output'        => (Time.now - instance['launchTime'] >= Fog::Mock.delay) ? nil : Fog::AWS::Mock.console_output,
      'requestId'     => Fog::AWS::Mock.request_id,
      'timestamp'     => Time.now
    }
    response
  else;
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
  end
end

#get_password_data(instance_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/get_password_data.rb', line 34

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::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
  end
end

#import_key_pair(key_name, public_key_material) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/import_key_pair.rb', line 32

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::AWS::Compute::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
  end
end

#modify_image_attribute(image_id, attributes) ⇒ `Object`

Raises:

(ArgumentError)

# File 'lib/fog/aws/requests/compute/modify_image_attribute.rb', line 40

def modify_image_attribute(image_id, attributes)
  raise ArgumentError.new("image_id is required") unless image_id

  unless self.data[:images][image_id]
    raise Fog::AWS::Compute::NotFound.new("The AMI ID '#{image_id}' does not exist")
  end

  (attributes['Add.UserId'] || []).each do |user_id|
    if image_launch_permissions = self.data[:image_launch_permissions][image_id]
      image_launch_permissions[:users].push(user_id)
    end
  end

  (attributes['Remove.UserId'] || []).each do |user_id|
    if image_launch_permissions = self.data[:image_launch_permissions][image_id]
      image_launch_permissions[:users].delete(user_id)
    end
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'return'        => true,
    'requestId'     => Fog::AWS::Mock.request_id
  }
  response
end

#modify_network_interface_attribute(network_interface_id, attribute, value) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/modify_network_interface_attribute.rb', line 46

def modify_network_interface_attribute(network_interface_id, attribute, value)
  response = Excon::Response.new
  if self.data[:network_interfaces][network_interface_id]
    nic = self.data[:network_interfaces][network_interface_id]

    case attribute
    when 'description'
      nic['description'] = value.clone
    when 'groupSet'
      groups = {}
      value.each do |group_id|
        security_group = self.data[:security_groups][group_id]
        if security_group.nil?
          raise Fog::AWS::Compute::Error.new("Unknown security group '#{group_id}' specified")
        end
        groups[group_id] = security_group['groupName']
      end
      nic['groupSet'] = groups
    when 'sourceDestCheck'
      nic['sourceDestCheck'] = value
    when 'attachment'
      if nic['attachment'].nil? || value['attachmentId'] != nic['attachment']['attachmentId']
        raise Fog::AWS::Compute::Error.new("Illegal attachment '#{value['attachmentId']}' specified")
      end
      nic['attachment']['deleteOnTermination'] = value['deleteOnTermination']
    else
      raise Fog::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
    end

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }

    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network interface '#{network_interface_id}' does not exist")
  end
end

#modify_subnet_attribute(subnet_id, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/modify_subnet_attribute.rb', line 35

def modify_subnet_attribute(subnet_id, options={})
  Excon::Response.new.tap do |response|
    subnet = self.data[:subnets].detect { |v| v['subnetId'] == subnet_id }            
    if subnet
      subnet['mapPublicIpOnLaunch'] = options['MapPublicIpOnLaunch']

      response.status = 200
      
      response.body = {
        'requestId' => Fog::AWS::Mock.request_id,
        'return'    => true
      }
    else
      response.status = 404
      response.body = {
        'Code' => 'InvalidParameterValue'
      }
    end
  end
end

#modify_volume(volume_id, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/modify_volume.rb', line 41

def modify_volume(volume_id, options={})
  response = Excon::Response.new
  volume   = self.data[:volumes][volume_id]

  if volume["volumeType"] == 'standard' && options['VolumeType']
    raise Fog::AWS::Compute::Error.new("InvalidParameterValue => Volume type EBS Magnetic is not supported.")
  end

  volume_modification = {
    'modificationState' => 'modifying',
    'progress'          => 0,
    'startTime'         => Time.now,
    'volumeId'          => volume_id
  }

  if options['Size']
    volume_modification.merge!(
      'originalSize' => volume['size'],
      'targetSize'   => options['Size']
    )
  end

  if options['Iops']
    volume_modification.merge!(
      'originalIops' => volume['iops'],
      'targetIops'   => options['Iops']
    )
  end

  if options['VolumeType']
    if options["VolumeType"] == 'standard'
      raise Fog::AWS::Compute::Error.new("InvalidParameterValue => Volume type EBS Magnetic is not supported.")
    end
    volume_modification.merge!(
      'originalVolumeType' => volume['volumeType'],
      'targetVolumeType'   => options['VolumeType']
    )
  end

  self.data[:volume_modifications][volume_id] = volume_modification

  response.body = {'volumeModification' => volume_modification, 'requestId' => Fog::AWS::Mock.request_id}
  response
end

#modify_volume_attribute(volume_id = nil, auto_enable_io_value = false) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/modify_volume_attribute.rb', line 32

def modify_volume_attribute(volume_id=nil, auto_enable_io_value=false)
  response = Excon::Response.new
  if volume = self.data[:volumes][volume_id]
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
  end
end

#modify_vpc_attribute(vpc_id, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/modify_vpc_attribute.rb', line 36

def modify_vpc_attribute(vpc_id, options = {})
  response = Excon::Response.new
  if options.size == 0
    raise Fog::AWS::Compute::Error.new("InvalidParameterCombination => No attributes specified.")
  elsif options.size > 1
    raise Fog::AWS::Compute::Error.new("InvalidParameterCombination =>  InvalidParameterCombination => Fields for multiple attribute types specified: #{options.keys.join(', ')}")
  elsif vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }

    attribute = options.keys.first
    case attribute
    when 'EnableDnsSupport.Value'
      vpc['enableDnsSupport'] = options[attribute]
    when 'EnableDnsHostnames.Value'
      vpc['enableDnsHostnames'] = options[attribute]
    else
      raise Fog::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
    end
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The VPC '#{vpc_id}' does not exist.")
  end
end

#monitor_instances(instance_ids) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/monitor_instances.rb', line 31

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::AWS::Compute::NotFound.new("The instance ID '#{instance_ids}' does not exist")
    end
  end
  instances_set = [*instance_ids].reduce([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'enabled'} }
  response.body = {'requestId' => 'some_request_id', 'instancesSet' => instances_set}
  response
end

#move_address_to_vpc(public_ip) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/move_address_to_vpc.rb', line 27

def move_address_to_vpc(public_ip)
  response      = Excon::Response.new
  allocation_id = "eip-#{Fog::Mock.random_hex(8)}"

  address = self.data[:addresses][public_ip]

  if address
    address['domain']       = 'vpc'
    address['allocationId'] = allocation_id

    response.status = 200
    response.body = {
      'requestId'    => Fog::AWS::Mock.request_id,
      'allocationId' => allocation_id,
      'status'       => "InVpc"
    }

    response
  else
    raise Fog::AWS::Compute::NotFound.new("Address does not exist")
  end
end

#purchase_reserved_instances_offering(reserved_instances_offering_id, instance_count = 1) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/purchase_reserved_instances_offering.rb', line 32

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 = 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,
    'end'                 => Time.now,
    'instanceCount'       => instance_count,
    'state'               => 'payment-pending',
    'tagSet'              => []
  })

  response.body = {
    'reservedInstancesId' => reserved_instances_id,
    'requestId' => Fog::AWS::Mock.request_id
  }

  response
end

#reboot_instances(instance_id = []) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/reboot_instances.rb', line 30

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::AWS::Compute::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
  end
end

#region_data ⇒ `Object`



341
342
343

# File 'lib/fog/aws/compute.rb', line 341

def region_data
  self.class.data[@region]
end

#register_image(name, description, location, block_devices = [], options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/register_image.rb', line 67

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\/(xvd|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::AWS::Compute::Error.new(message)
  end
end

#release_address(public_ip_or_allocation_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/release_address.rb', line 35

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.find {|a| a['allocationId'] == public_ip_or_allocation_id }

  if address
    if address['allocationId'] && public_ip_or_allocation_id == address['publicIp']
      raise Fog::AWS::Compute::Error, "InvalidParameterValue => You must specify an allocation id when releasing a VPC elastic IP address"
    end

    self.data[:addresses].delete(address['publicIp'])
    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::Error.new("AuthFailure => The address '#{public_ip_or_allocation_id}' does not belong to you.")
  end
end

#replace_network_acl_association(association_id, network_acl_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/replace_network_acl_association.rb', line 31

def replace_network_acl_association(association_id, network_acl_id)
  response = Excon::Response.new
  if self.data[:network_acls][network_acl_id]
    # find the old assoc
    old_nacl = self.data[:network_acls].values.find do |n|
      n['associationSet'].find { |assoc| assoc['networkAclAssociationId'] == association_id }
    end

    unless old_nacl
      raise Fog::AWS::Compute::Error.new("Invalid association_id #{association_id}")
    end

    subnet_id = old_nacl['associationSet'].find { |assoc| assoc['networkAclAssociationId'] == association_id }['subnetId']
    old_nacl['associationSet'].delete_if { |assoc| assoc['networkAclAssociationId'] == association_id }

    id = Fog::AWS::Mock.network_acl_association_id
    self.data[:network_acls][network_acl_id]['associationSet'] << {
      'networkAclAssociationId' => id,
      'networkAclId'            => network_acl_id,
      'subnetId'                => subnet_id,
    }

    response.status = 200
    response.body = {
      'requestId'        => Fog::AWS::Mock.request_id,
      'newAssociationId' => id
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
  end
end

#replace_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/replace_network_acl_entry.rb', line 44

def replace_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
  response = Excon::Response.new
  if self.data[:network_acls][network_acl_id]

    unless self.data[:network_acls][network_acl_id]['entrySet'].find { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
      raise Fog::AWS::Compute::Error.new("No rule with that number")
    end
    self.data[:network_acls][network_acl_id]['entrySet'].delete_if { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }

    data = {
      'ruleNumber'   => rule_number,
      'protocol'     => protocol,
      'ruleAction'   => rule_action,
      'egress'       => egress,
      'cidrBlock'    => cidr_block,
      'icmpTypeCode' => {},
      'portRange'    => {}
    }
    data['icmpTypeCode']['code'] = options['Icmp.Code']      if options['Icmp.Code']
    data['icmpTypeCode']['type'] = options['Icmp.Type']      if options['Icmp.Type']
    data['portRange']['from']    = options['PortRange.From'] if options['PortRange.From']
    data['portRange']['to']      = options['PortRange.To']   if options['PortRange.To']
    self.data[:network_acls][network_acl_id]['entrySet'] << data

    response.status = 200
    response.body = {
      'requestId' => Fog::AWS::Mock.request_id,
      'return'    => true
    }
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
  end
end

#replace_route(route_table_id, destination_cidr_block, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/replace_route.rb', line 37

def replace_route(route_table_id, destination_cidr_block, options = {})
  options['instanceOwnerId'] ||= nil
  options['DestinationCidrBlock'] ||= destination_cidr_block

  route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
  if !route_table.nil? && destination_cidr_block
    if !options['gatewayId'].nil? || !options['instanceId'].nil? || !options['networkInterfaceId'].nil?
      if !options['gatewayId'].nil? && self.internet_gateways.all('internet-gateway-id'=>options['gatewayId']).first.nil?
        raise Fog::AWS::Compute::NotFound.new("The gateway ID '#{options['gatewayId']}' does not exist")
      elsif !options['instanceId'].nil? && self.servers.all('instance-id'=>options['instanceId']).first.nil?
        raise Fog::AWS::Compute::NotFound.new("The instance ID '#{options['instanceId']}' does not exist")
      elsif !options['networkInterfaceId'].nil? && self.network_interfaces.all('networkInterfaceId'=>options['networkInterfaceId']).first.nil?
        raise Fog::AWS::Compute::NotFound.new("The networkInterface ID '#{options['networkInterfaceId']}' does not exist")
      elsif route_table['routeSet'].find { |route| route['destinationCidrBlock'].eql? destination_cidr_block }.nil?
        raise Fog::AWS::Compute::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} doesn't exist."
      else
        response = Excon::Response.new
        route_set = route_table['routeSet'].find { |routeset| routeset['destinationCidrBlock'].eql? destination_cidr_block }
        route_set.merge!(options)
        route_set['state'] = 'pending'
        route_set['origin'] = 'ReplaceRoute'

        response.status = 200
        response.body = {
          'requestId'=> Fog::AWS::Mock.request_id,
          'return' => true
        }
        response
      end
    else
      message = 'MissingParameter => '
      message << 'The request must contain either a gateway id, a network interface id, or an instance id'
      raise Fog::AWS::Compute::Error.new(message)
    end
  elsif route_table.nil?
    raise Fog::AWS::Compute::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
  elsif destination_cidr_block.empty?
    raise Fog::AWS::Compute::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
  end
end

#request_spot_instances(image_id, instance_type, spot_price, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/request_spot_instances.rb', line 96

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

    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::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::AWS::Compute::Error.new(message)
    end

    if !image_id.match(/^ami-[a-f0-9]{8,17}$/)
      message = "The image id '[#{image_id}]' does not exist"
      raise Fog::AWS::Compute::NotFound.new(message)
    end

  else
    message = 'MissingParameter => '
    message << 'The request must contain the parameter '
    if !image_id
      message << 'image_id'
    elsif !instance_type
      message << 'instance_type'
    else
      message << 'spot_price'
    end
    raise Fog::AWS::Compute::Error.new(message)
  end

  for key in %w(AvailabilityZoneGroup LaunchGroup)
    if options.is_a?(Hash) && options.key?(key)
      Fog::Logger.warning("#{key} filters are not yet mocked [light_black](#{caller.first})[/]")
      Fog::Mock.not_implemented
    end
  end

  launch_spec = {
    'iamInstanceProfile' => {},
    'blockDeviceMapping' => options['LaunchSpecification.BlockDeviceMapping'] || [],
    'groupSet'           => options['LaunchSpecification.SecurityGroupId']    || ['default'],
    'imageId'            => image_id,
    'instanceType'       => instance_type,
    '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' => [spot_request],
    'requestId' => Fog::AWS::Mock.request_id
  }

  response
end

#reset_data ⇒ `Object`



349
350
351

# File 'lib/fog/aws/compute.rb', line 349

def reset_data
  self.region_data.delete(@aws_access_key_id)
end

#reset_network_interface_attribute(network_interface_id, attribute) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/reset_network_interface_attribute.rb', line 34

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::AWS::Compute::Error.new("Illegal attribute '#{attribute}' specified")
    end
    response
  else
    raise Fog::AWS::Compute::NotFound.new("The network interface '#{network_interface_id}' does not exist")
  end
end

#restore_address_to_classic(public_ip) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/restore_address_to_classic.rb', line 27

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

#revoke_security_group_egress(group_name, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/revoke_security_group_egress.rb', line 58

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

#revoke_security_group_ingress(group_name, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/revoke_security_group_ingress.rb', line 58

def revoke_security_group_ingress(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(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
end

#run_instances(image_id, min_count, max_count, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/run_instances.rb', line 206

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::AWS::Compute::NotFound.new("The key pair '#{options['KeyName']}' does not exist")
  end

  min_count.times do |i|
    instance_id = Fog::AWS::Mock.instance_id
    availability_zone = options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone(@region)

    block_device_mapping = (options['BlockDeviceMapping'] || []).reduce([]) do |mapping, device|
      device_name           = device.fetch("DeviceName", "/dev/sda1")
      volume_size           = device.fetch("Ebs.VolumeSize", 15)            # @todo should pull this from the image
      delete_on_termination = device.fetch("Ebs.DeleteOnTermination", true) # @todo should pull this from the image

      volume_id = create_volume(availability_zone, volume_size).data[:body]["volumeId"]

      self.data[:volumes][volume_id].merge!("DeleteOnTermination" => delete_on_termination)

      mapping << {
        "deviceName"          => device_name,
        "volumeId"            => volume_id,
        "status"              => "attached",
        "attachTime"          => Time.now,
        "deleteOnTermination" => delete_on_termination,
      }
    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']}
      else
        ni_options = {}
      end

      network_interface_id = create_network_interface(options['SubnetId'], ni_options).body['networkInterface']['networkInterfaceId']
    end

    network_interfaces = (options['NetworkInterfaces'] || []).reduce([]) do |mapping, device|
      device_index          = device.fetch("DeviceIndex", 0)
      subnet_id             = device.fetch("SubnetId", options[:subnet_id] ||  Fog::AWS::Mock.subnet_id)
      private_ip_address    = device.fetch("PrivateIpAddress", options[:private_ip_address] || Fog::AWS::Mock.private_ip_address)
      delete_on_termination = device.fetch("DeleteOnTermination", true)
      description           = device.fetch("Description", "mock_network_interface")
      security_group_id     = device.fetch("SecurityGroupId", self.data[:security_groups]['default']['groupId'])
      interface_options     = {
          "PrivateIpAddress"   => private_ip_address,
          "GroupSet"           => device.fetch("GroupSet", [security_group_id]),
          "Description"        => description
      }

      interface_id = device.fetch("NetworkInterfaceId", create_network_interface(subnet_id, interface_options))

      mapping << {
        "networkInterfaceId"  => interface_id,
        "subnetId"            => subnet_id,
        "status"              => "attached",
        "attachTime"          => Time.now,
        "deleteOnTermination" => delete_on_termination,
      }
    end

    instance = {
      '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({
      'groupIds'            => [],
      'groupSet'            => group_set,
      'iamInstanceProfile'  => {},
      'ownerId'             => self.data[:owner_id],
      'reservationId'       => reservation_id,
      'stateReason'         => {}
    })

    if options['SubnetId']
      self.data[:instances][instance_id]['vpcId'] = self.data[:subnets].find{|subnet| subnet['subnetId'] == options['SubnetId'] }['vpcId']

      attachment_id = attach_network_interface(network_interface_id, instance_id, '0').data[:body]['attachmentId']
      modify_network_interface_attribute(network_interface_id, 'attachment', {'attachmentId' => attachment_id, 'deleteOnTermination' => 'true'})
    end
  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

#set_supported_platforms(values) ⇒ `Object`



381
382
383

# File 'lib/fog/aws/compute.rb', line 381

def set_supported_platforms(values)
  self.data[:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"] = values
end

#setup_credentials(options) ⇒ `Object`



522
523
524

# File 'lib/fog/aws/compute.rb', line 522

def setup_credentials(options)
  @aws_access_key_id = options[:aws_access_key_id]
end

#setup_default_vpc! ⇒ `Object`

# File 'lib/fog/aws/compute.rb', line 394

def setup_default_vpc!
  return if default_vpc.present?

  disable_ec2_classic

  vpc_id = Fog::AWS::Mock.default_vpc_for(region)
  self.default_vpc = vpc_id

  data[:vpcs] << {
    'vpcId' => vpc_id,
    'state' => 'available',
    'cidrBlock' => '172.31.0.0/16',
    'dhcpOptionsId' => Fog::AWS::Mock.dhcp_options_id,
    'tagSet' => {},
    'instanceTenancy' => 'default',
    'enableDnsSupport' => true,
    'enableDnsHostnames' => true,
    'isDefault' => true
  }

  internet_gateway_id = Fog::AWS::Mock.internet_gateway_id
  data[:internet_gateways][internet_gateway_id] = {
    'internetGatewayId' => internet_gateway_id,
    'attachmentSet' => {
      'vpcId' => vpc_id,
      'state' => 'available'
    },
    'tagSet' => {}
  }

  data[:route_tables] << {
    'routeTableId' => Fog::AWS::Mock.route_table_id,
    'vpcId' => vpc_id,
    'routes' => [
      {
        'destinationCidrBlock' => '172.31.0.0/16',
        'gatewayId' => 'local',
        'state' => 'active',
        'origin' => 'CreateRouteTable'
      },
      {
        'destinationCidrBlock' => '0.0.0.0/0',
        'gatewayId' => internet_gateway_id,
        'state' => 'active',
        'origin' => 'CreateRoute'
      }
    ]
  }

  describe_availability_zones.body['availabilityZoneInfo'].map { |z| z['zoneName'] }.each_with_index do |zone, i|
    data[:subnets] << {
      'subnetId'                 => Fog::AWS::Mock.subnet_id,
      'state'                    => 'available',
      'vpcId'                    => vpc_id,
      'cidrBlock'                => "172.31.#{i}.0/16",
      'availableIpAddressCount'  => '251',
      'availabilityZone'         => zone,
      'tagSet'                   => {},
      'mapPublicIpOnLaunch'      => true,
      'defaultForAz'             => true
    }
  end
end

#start_instances(instance_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/start_instances.rb', line 30

def start_instances(instance_id)
  instance_ids = Array(instance_id)

  instance_set = self.data[:instances].values
  instance_set = apply_tag_filters(instance_set, {'instance_id' => instance_ids}, 'instanceId')
  instance_set = instance_set.select {|x| instance_ids.include?(x["instanceId"]) }

  if instance_set.empty?
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids.first}' does not exist")
  else
    response = Excon::Response.new
    response.status = 200

    response.body = {
      'requestId'    => Fog::AWS::Mock.request_id,
      'instancesSet' => instance_set.reduce([]) do |ia, instance|
                          ia << {'currentState' => { 'code' => 0, 'name' => 'pending' },
                                 'previousState' => instance['instanceState'],
                                 'instanceId' => instance['instanceId'] }
                          instance['instanceState'] = {'code'=>0, 'name'=>'pending'}
                          ia
      end
    }
    response
  end
end

#stop_instances(instance_id, options = {}) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/stop_instances.rb', line 39

def stop_instances(instance_id, options = {})
  instance_ids = Array(instance_id)

  instance_set = self.data[:instances].values
  instance_set = apply_tag_filters(instance_set, {'instance_id' => instance_ids}, 'instanceId')
  instance_set = instance_set.select {|x| instance_ids.include?(x["instanceId"]) }

  if instance_set.empty?
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids.first}' does not exist")
  else
    response = Excon::Response.new
    response.status = 200

    response.body = {
      'requestId'    => Fog::AWS::Mock.request_id,
      'instancesSet' => instance_set.reduce([]) do |ia, instance|
                          instance['classicLinkSecurityGroups'] = nil
                          instance['classicLinkVpcId'] = nil
                          ia << {'currentState' => { 'code' => 0, 'name' => 'stopping' },
                                 'previousState' => instance['instanceState'],
                                 'instanceId' => instance['instanceId'] }
                          instance['instanceState'] = {'code'=>0, 'name'=>'stopping'}
                          ia
      end
    }
    response
  end
end

#supported_platforms ⇒ `Object`



369
370
371

# File 'lib/fog/aws/compute.rb', line 369

def supported_platforms
  describe_account_attributes.body["accountAttributeSet"].find{ |h| h["attributeName"] == "supported-platforms" }["values"]
end

#tagged_resources(resources) ⇒ `Object`

# File 'lib/fog/aws/compute.rb', line 458

def tagged_resources(resources)
  Array(resources).map do |resource_id|
    if match = resource_id.match(/^(\w+)-[a-z0-9]{8,17}/i)
      id = match.captures.first
    else
      raise(Fog::Service::NotFound.new("Unknown resource id #{resource_id}"))
    end

    if MOCKED_TAG_TYPES.has_key? id
      type = MOCKED_TAG_TYPES[id]
    else
      raise(Fog::Service::NotFound.new("Mocking tags of resource #{resource_id} has not been implemented"))
    end

    case type
      when 'image'
        unless visible_images.has_key? resource_id
         raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the image does not exist"))
        end
      when 'vpc'
        if self.data[:vpcs].select {|v| v['vpcId'] == resource_id }.empty?
          raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the vpc does not exist"))
        end
      when 'route_table'
        unless self.data[:route_tables].detect { |r| r['routeTableId'] == resource_id }
          raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the route table does not exist"))
        end
      else
        unless self.data[:"#{type}s"][resource_id]
         raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the #{type} does not exist"))
        end
    end
    { 'resourceId' => resource_id, 'resourceType' => type }
  end
end

#terminate_instances(instance_id) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/terminate_instances.rb', line 37

def terminate_instances(instance_id)
  response = Excon::Response.new
  instance_id = [*instance_id]
  if (self.data[:instances].keys & instance_id).length == instance_id.length
    response.body = {
      'requestId'     => Fog::AWS::Mock.request_id,
      'instancesSet'  => []
    }
    response.status = 200
    for id in instance_id
      instance = self.data[:instances][id]
      instance['classicLinkSecurityGroups'] = nil
      instance['classicLinkVpcId'] = nil
      self.data[:deleted_at][id] = Time.now
      code = case instance['instanceState']['name']
      when 'pending'
        0
      when 'running'
        16
      when 'shutting-down'
        32
      when 'terminated'
        48
      when 'stopping'
        64
      when 'stopped'
        80
      end
      state = { 'name' => 'shutting-down', 'code' => 32}
      response.body['instancesSet'] << {
        'instanceId'    => id,
        'previousState' => instance['instanceState'],
        'currentState'  => state
      }
      instance['instanceState'] = state
    end

    describe_addresses.body['addressesSet'].each do |address|
      if instance_id.include?(address['instanceId'])
        disassociate_address(address['publicIp'], address['associationId'])
      end
    end

    describe_volumes.body['volumeSet'].each do |volume|
      if volume['attachmentSet'].first && instance_id.include?(volume['attachmentSet'].first['instanceId'])
        detach_volume(volume['volumeId'])
      end
    end

    response
  else
    raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
  end
end

#unmonitor_instances(instance_ids) ⇒ `Object`

# File 'lib/fog/aws/requests/compute/unmonitor_instances.rb', line 31

def unmonitor_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::AWS::Compute::NotFound.new("The instance ID '#{instance_ids}' does not exist")
    end
  end
  instances_set = [*instance_ids].reduce([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'disabled'} }
  response.body = {'requestId' => 'some_request_id', 'instancesSet' => instances_set}
  response
end

#visible_images ⇒ `Object`

# File 'lib/fog/aws/compute.rb', line 353

def visible_images
  images = self.data[:images].values.reduce({}) do |h, image|
    h.update(image['imageId'] => image)
  end

  self.region_data.each do |aws_access_key_id, data|
    data[:image_launch_permissions].each do |image_id, list|
      if list[:users].include?(self.data[:owner_id])
        images.update(image_id => data[:images][image_id])
      end
    end
  end

  images
end

Class: Fog::AWS::Compute::Mock

Constant Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Fog::AWS::CredentialFetcher::ConnectionMethods

Constructor Details

#initialize(options = {}) ⇒ Mock

Instance Attribute Details

#region ⇒ Object

Class Method Details

.data ⇒ Object

.reset ⇒ Object

Instance Method Details

#allocate_address(domain = 'standard') ⇒ Object

#apply_tag_filters(resources, filters, resource_id_key) ⇒ Object

#assign_private_ip_addresses(network_interface_id, options = {}) ⇒ Object

#associate_address(*args) ⇒ Object

#associate_dhcp_options(dhcp_options_id, vpc_id) ⇒ Object

#associate_route_table(routeTableId, subnetId) ⇒ Object

#attach_classic_link_vpc(instance_id, vpc_id, security_group_ids, dry_run = false) ⇒ Object

#attach_internet_gateway(internet_gateway_id, vpc_id) ⇒ Object

#attach_network_interface(nic_id, instance_id, device_index) ⇒ Object

#attach_volume(instance_id, volume_id, device) ⇒ Object

#authorize_security_group_egress(group_name, options = {}) ⇒ Object

#authorize_security_group_ingress(group_name, options = {}) ⇒ Object

#cancel_spot_instance_requests(spot_instance_request_id) ⇒ Object

#copy_image(source_image_id, source_region, name = nil, description = nil, client_token = nil) ⇒ Object

#copy_snapshot(source_snapshot_id, source_region, options = {}) ⇒ Object

#create_dhcp_options(dhcp_configurations = {}) ⇒ Object

#create_image(instance_id, name, description, no_reboot = false, options = {}) ⇒ Object

#create_internet_gateway ⇒ Object

#create_key_pair(key_name) ⇒ Object

#create_network_acl(vpcId, options = {}) ⇒ Object

#create_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {}) ⇒ Object

#create_network_interface(subnetId, options = {}) ⇒ Object

#create_route(route_table_id, destination_cidr_block, internet_gateway_id = nil, instance_id = nil, network_interface_id = nil) ⇒ Object

#create_route_table(vpc_id) ⇒ Object

#create_security_group(name, description, vpc_id = nil) ⇒ Object

#create_snapshot(volume_id, description = nil) ⇒ Object

#create_subnet(vpcId, cidrBlock, options = {}) ⇒ Object

#create_tags(resources, tags) ⇒ Object

#create_volume(availability_zone, size, options = {}) ⇒ Object

#create_vpc(cidrBlock, options = {}) ⇒ Object

#data ⇒ Object

#default_vpc ⇒ Object

#default_vpc=(value) ⇒ Object

#delete_dhcp_options(dhcp_options_id) ⇒ Object

#delete_internet_gateway(internet_gateway_id) ⇒ Object

#delete_key_pair(key_name) ⇒ Object

#delete_network_acl(network_acl_id) ⇒ Object

#delete_network_acl_entry(network_acl_id, rule_number, egress) ⇒ Object

#delete_network_interface(network_interface_id) ⇒ Object

#delete_route(route_table_id, destination_cidr_block) ⇒ Object

#delete_route_table(route_table_id) ⇒ Object

#delete_security_group(name, id = nil) ⇒ Object

#delete_snapshot(snapshot_id) ⇒ Object

#delete_subnet(subnet_id) ⇒ Object

#delete_tags(resources, tags) ⇒ Object

#delete_volume(volume_id) ⇒ Object

#delete_vpc(vpc_id) ⇒ Object

#deregister_image(image_id) ⇒ Object

#describe_account_attributes(filters = {}) ⇒ Object

#describe_addresses(filters = {}) ⇒ Object

#describe_availability_zones(filters = {}) ⇒ Object

#describe_classic_link_instances(options = {}) ⇒ Object

#describe_dhcp_options(filters = {}) ⇒ Object

#describe_image_attribute(image_id, attribute) ⇒ Object

#describe_images(filters = {}) ⇒ Object

#describe_instance_attribute(instance_id, attribute) ⇒ Object

#describe_instance_status(filters = {}) ⇒ Object

#describe_instances(filters = {}) ⇒ Object

#describe_internet_gateways(filters = {}) ⇒ Object

#describe_key_pairs(filters = {}) ⇒ Object

#describe_network_acls(filters = {}) ⇒ Object

#describe_network_interface_attribute(network_interface_id, attribute) ⇒ Object

#describe_network_interfaces(filters = {}) ⇒ Object

#describe_regions(filters = {}) ⇒ Object

#describe_reserved_instances(filters = {}) ⇒ Object

#describe_reserved_instances_offerings(filters = {}) ⇒ Object

#initialize(options = {}) ⇒ `Mock`

#region ⇒ `Object`

.data ⇒ `Object`

.reset ⇒ `Object`

#allocate_address(domain = 'standard') ⇒ `Object`

#apply_tag_filters(resources, filters, resource_id_key) ⇒ `Object`

#assign_private_ip_addresses(network_interface_id, options = {}) ⇒ `Object`

#associate_address(*args) ⇒ `Object`

#associate_dhcp_options(dhcp_options_id, vpc_id) ⇒ `Object`

#associate_route_table(routeTableId, subnetId) ⇒ `Object`

#attach_classic_link_vpc(instance_id, vpc_id, security_group_ids, dry_run = false) ⇒ `Object`

#attach_internet_gateway(internet_gateway_id, vpc_id) ⇒ `Object`

#attach_network_interface(nic_id, instance_id, device_index) ⇒ `Object`

#attach_volume(instance_id, volume_id, device) ⇒ `Object`

#authorize_security_group_egress(group_name, options = {}) ⇒ `Object`

#authorize_security_group_ingress(group_name, options = {}) ⇒ `Object`

#cancel_spot_instance_requests(spot_instance_request_id) ⇒ `Object`

#copy_image(source_image_id, source_region, name = nil, description = nil, client_token = nil) ⇒ `Object`

#copy_snapshot(source_snapshot_id, source_region, options = {}) ⇒ `Object`

#create_dhcp_options(dhcp_configurations = {}) ⇒ `Object`

#create_image(instance_id, name, description, no_reboot = false, options = {}) ⇒ `Object`

#create_internet_gateway ⇒ `Object`

#create_key_pair(key_name) ⇒ `Object`

#create_network_acl(vpcId, options = {}) ⇒ `Object`

#create_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {}) ⇒ `Object`

#create_network_interface(subnetId, options = {}) ⇒ `Object`

#create_route(route_table_id, destination_cidr_block, internet_gateway_id = nil, instance_id = nil, network_interface_id = nil) ⇒ `Object`

#create_route_table(vpc_id) ⇒ `Object`

#create_security_group(name, description, vpc_id = nil) ⇒ `Object`

#create_snapshot(volume_id, description = nil) ⇒ `Object`

#create_subnet(vpcId, cidrBlock, options = {}) ⇒ `Object`

#create_tags(resources, tags) ⇒ `Object`

#create_volume(availability_zone, size, options = {}) ⇒ `Object`

#create_vpc(cidrBlock, options = {}) ⇒ `Object`

#data ⇒ `Object`

#default_vpc ⇒ `Object`

#default_vpc=(value) ⇒ `Object`

#delete_dhcp_options(dhcp_options_id) ⇒ `Object`

#delete_internet_gateway(internet_gateway_id) ⇒ `Object`

#delete_key_pair(key_name) ⇒ `Object`

#delete_network_acl(network_acl_id) ⇒ `Object`

#delete_network_acl_entry(network_acl_id, rule_number, egress) ⇒ `Object`

#delete_network_interface(network_interface_id) ⇒ `Object`

#delete_route(route_table_id, destination_cidr_block) ⇒ `Object`

#delete_route_table(route_table_id) ⇒ `Object`

#delete_security_group(name, id = nil) ⇒ `Object`

#delete_snapshot(snapshot_id) ⇒ `Object`

#delete_subnet(subnet_id) ⇒ `Object`

#delete_tags(resources, tags) ⇒ `Object`

#delete_volume(volume_id) ⇒ `Object`

#delete_vpc(vpc_id) ⇒ `Object`

#deregister_image(image_id) ⇒ `Object`

#describe_account_attributes(filters = {}) ⇒ `Object`

#describe_addresses(filters = {}) ⇒ `Object`

#describe_availability_zones(filters = {}) ⇒ `Object`

#describe_classic_link_instances(options = {}) ⇒ `Object`

#describe_dhcp_options(filters = {}) ⇒ `Object`

#describe_image_attribute(image_id, attribute) ⇒ `Object`

#describe_images(filters = {}) ⇒ `Object`

#describe_instance_attribute(instance_id, attribute) ⇒ `Object`

#describe_instance_status(filters = {}) ⇒ `Object`

#describe_instances(filters = {}) ⇒ `Object`

#describe_internet_gateways(filters = {}) ⇒ `Object`

#describe_key_pairs(filters = {}) ⇒ `Object`

#describe_network_acls(filters = {}) ⇒ `Object`

#describe_network_interface_attribute(network_interface_id, attribute) ⇒ `Object`

#describe_network_interfaces(filters = {}) ⇒ `Object`

#describe_regions(filters = {}) ⇒ `Object`

#describe_reserved_instances(filters = {}) ⇒ `Object`

#describe_reserved_instances_offerings(filters = {}) ⇒ `Object`

#describe_route_tables(filters = {}) ⇒ `Object`

#describe_security_groups(filters = {}) ⇒ `Object`

#describe_snapshots(filters = {}, options = {}) ⇒ `Object`

#describe_spot_instance_requests(filters = {}) ⇒ `Object`

#describe_spot_price_history(filters = {}) ⇒ `Object`

#describe_subnets(filters = {}) ⇒ `Object`

#describe_tags(filters = {}) ⇒ `Object`

#describe_volume_status(filters = {}) ⇒ `Object`

#describe_volumes(filters = {}) ⇒ `Object`

#describe_volumes_modifications(filters = {}) ⇒ `Object`