class Fog::AWS::Compute::Mock
Constants
- MOCKED_TAG_TYPES
- VPC_BLANK_VALUE
Attributes
region[RW]
Public Class Methods
data()
click to toggle source
# 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
new(options={})
click to toggle source
# 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
reset()
click to toggle source
# File lib/fog/aws/compute.rb, line 313 def self.reset @data = nil end
Public Instance Methods
allocate_address(domain = 'standard')
click to toggle source
# 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)
click to toggle source
# 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={})
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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
cancel_spot_instance_requests(spot_instance_request_id)
click to toggle source
# 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)
click to toggle source
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 = {})
click to toggle source
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 = {})
click to toggle source
# 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 = {})
click to toggle source
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()
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
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 = {})
click to toggle source
# 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_volume(availability_zone, size, options = {})
click to toggle source
# 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 = {})
click to toggle source
# 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()
click to toggle source
# File lib/fog/aws/compute.rb, line 345 def data self.region_data[@aws_access_key_id] end
default_vpc()
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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_volume(volume_id)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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={})
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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_volume_status(filters = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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={})
click to toggle source
# 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={})
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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()
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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()
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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={})
click to toggle source
# 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={})
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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 = [])
click to toggle source
# 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()
click to toggle source
# File lib/fog/aws/compute.rb, line 341 def region_data self.class.data[@region] end
register_image(name, description, location, block_devices=[], options={})
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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()
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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 = {})
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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!()
click to toggle source
# 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)
click to toggle source
# 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 = {})
click to toggle source
# 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()
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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)
click to toggle source
# 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()
click to toggle source
# 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
Private Instance Methods
add_route_association(routeTableId, subnetId, main=nil)
click to toggle source
# File lib/fog/aws/requests/compute/associate_route_table.rb, line 53 def add_route_association(routeTableId, subnetId, main=nil) response = { "routeTableAssociationId" => "rtbassoc-#{Fog::Mock.random_hex(8)}", "routeTableId" => routeTableId, "subnetId" => nil, "main" => false } if main response['main'] = true else response['subnetId'] = subnetId end response end
deep_clone(obj)
click to toggle source
# File lib/fog/aws/requests/compute/describe_tags.rb, line 91 def deep_clone(obj) case obj when Hash obj.reduce({}) { |h, pair| h[pair.first] = deep_clone(pair.last); h } when Array obj.map { |o| deep_clone(o) } else obj end end
filter_resources(tag_set, filter, value)
click to toggle source
# File lib/fog/aws/requests/compute/describe_tags.rb, line 82 def filter_resources(tag_set, filter, value) value_hash_list = tag_set.values value_hash_list.each do |value_hash| value_hash.each do |_, resource_list| resource_list.reject! { |resource| resource[filter] != value } end end end
find_matching_permission(group, permission)
click to toggle source
# File lib/fog/aws/requests/compute/authorize_security_group_ingress.rb, line 245 def find_matching_permission(group, permission) group['ipPermissions'].find {|group_permission| permission['ipProtocol'] == group_permission['ipProtocol'] && permission['fromPort'] == group_permission['fromPort'] && permission['toPort'] == group_permission['toPort'] } end
indexed_multidimensional_params(multi_params)
click to toggle source
# File lib/fog/aws/requests/compute/create_dhcp_options.rb, line 59 def indexed_multidimensional_params(multi_params) params = {} multi_params.keys.each_with_index do |key, key_index| key_index += 1 params[format('DhcpConfiguration.%d.Key', key_index)] = key [*multi_params[key]].each_with_index do |value, value_index| value_index += 1 params[format('DhcpConfiguration.%d.Value.%d', key_index, value_index)] = value end end params end
normalize_permissions(options)
click to toggle source
# File lib/fog/aws/requests/compute/authorize_security_group_ingress.rb, line 154 def normalize_permissions(options) normalized_permissions = [] if options['SourceSecurityGroupName'] group_name = if options['SourceSecurityGroupName'] =~ /default_elb/ "default" else options['SourceSecurityGroupName'] end source_group_id, _ = self.data[:security_groups].find { |_,v| v['groupName'] == group_name } ['tcp', 'udp'].each do |protocol| normalized_permissions << { 'ipProtocol' => protocol, 'fromPort' => 1, 'toPort' => 65535, 'groups' => [{ 'groupName' => group_name, 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id], 'groupId' => source_group_id }], 'ipRanges' => [] } end normalized_permissions << { 'ipProtocol' => 'icmp', 'fromPort' => -1, 'toPort' => -1, 'groups' => [{ 'groupName' => group_name, 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id], 'groupId' => source_group_id }], 'ipRanges' => [] } elsif options['CidrIp'] normalized_permissions << { 'ipProtocol' => options['IpProtocol'], 'fromPort' => Integer(options['FromPort']), 'toPort' => Integer(options['ToPort']), 'groups' => [], 'ipRanges' => [{'cidrIp' => options['CidrIp']}] } elsif options['CidrIpv6'] normalized_permissions << { 'ipProtocol' => options['IpProtocol'], 'fromPort' => Integer(options['FromPort']), 'toPort' => Integer(options['ToPort']), 'groups' => [], 'ipv6Ranges' => [{'cidrIpv6' => options['CidrIpv6']}] } elsif options['IpPermissions'] options['IpPermissions'].each do |permission| groups = (permission['Groups'] || []).map do |authorized_group| security_group = if group_name = authorized_group['GroupName'] self.data[:security_groups].values.find { |sg| sg['groupName'] == group_name } elsif group_id = authorized_group['GroupId'] self.data[:security_groups][group_id] end security_group || raise(Fog::AWS::Compute::NotFound.new("The security group '#{group_name || group_id}' does not exist")) { 'groupName' => authorized_group['GroupName'] || security_group['groupName'], 'userId' => authorized_group['UserId'] || self.data[:owner_id], 'groupId' => authorized_group["GroupId"] || security_group['groupId'] } end if ['tcp', 'udp', 'icmp'].include?(permission['IpProtocol']) normalized_permissions << { 'ipProtocol' => permission['IpProtocol'], 'fromPort' => Integer(permission['FromPort']), 'toPort' => Integer(permission['ToPort']), 'groups' => groups, 'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } } } else normalized_permissions << { 'ipProtocol' => permission['IpProtocol'], 'groups' => groups, 'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } } } end end end normalized_permissions end
verify_permission_options(options, is_vpc)
click to toggle source
# File lib/fog/aws/requests/compute/authorize_security_group_ingress.rb, line 136 def verify_permission_options(options, is_vpc) if options.size <= 1 raise Fog::AWS::Compute::Error.new("InvalidRequest => The request received was invalid.") end if !is_vpc && options['IpProtocol'] && !['tcp', 'udp', 'icmp'].include?(options['IpProtocol']) raise Fog::AWS::Compute::Error.new("InvalidPermission.Malformed => Unsupported IP protocol \"#{options['IpProtocol']}\" - supported: [tcp, udp, icmp]") end if !is_vpc && (options['IpProtocol'] && (!options['FromPort'] || !options['ToPort'])) raise Fog::AWS::Compute::Error.new("InvalidPermission.Malformed => TCP/UDP port (-1) out of range") end if options.key?('IpPermissions') if !options['IpPermissions'].is_a?(Array) || options['IpPermissions'].empty? raise Fog::AWS::Compute::Error.new("InvalidRequest => The request received was invalid.") end options['IpPermissions'].each {|p| verify_permission_options(p, is_vpc) } end end