Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ec2): resolve a NAT gateway's network interface and mark its Elastic IP associated (#5622)
Allen Sanborn1e423420ed6e
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex e6006163cf..48e27efdde 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -162,7 +162,7 @@ cross-resource references.| ElastiCache | `CacheCluster` (starts a real container; modifying an existing cluster in place is not supported), `SubnetGroup`, `User` (Tags are ignored), `UserGroup` (Tags are ignored), `ServerlessCache` (GetAtt uses the dotted Endpoint.* and ReaderEndpoint.* form) || Redshift | `Cluster` (single-node container; Port and non-dev DBName ignored; ManageMasterPassword unsupported), `ClusterParameterGroup`, `ClusterSubnetGroup`, `ClusterSecurityGroup` (accepted; no EC2-Classic security group model) || Redshift Serverless | `Namespace` (ManageAdminPassword is accepted and not applied; GetAtt uses the dotted Namespace.* form), `Workgroup` (starts a real container; one workgroup per namespace; capacity, VPC and price-performance settings are stored only; snapshot restore properties are ignored; GetAtt uses the dotted Workgroup.* form) |-| EC2 | `VPC` (deleted on stack teardown; a VPC with dependents outside the stack, including anything still holding a network interface in its subnets (an instance that is not terminated, a NAT gateway that is not deleted, a standalone interface, an interface endpoint), fails the delete with `DependencyViolation`, as on AWS), `Subnet`, `SecurityGroup` (inline `SecurityGroupIngress`/`SecurityGroupEgress` supported), `SecurityGroupIngress`, `SecurityGroupEgress`, `InternetGateway`, `RouteTable`, `SubnetRouteTableAssociation`, `Route`, `NatGateway`, `EIP`, `Instance`, `LaunchTemplate`, `VPCGatewayAttachment`, `VPCEndpoint`, `NetworkAcl`, `NetworkAclEntry`, `SubnetNetworkAclAssociation`, `FlowLog` |+| EC2 | `VPC` (deleted on stack teardown; a VPC with dependents outside the stack, including anything still holding a network interface in its subnets (an instance that is not terminated, a NAT gateway that is not deleted or failed, a standalone interface, an interface endpoint), fails the delete with `DependencyViolation`, as on AWS), `Subnet`, `SecurityGroup` (inline `SecurityGroupIngress`/`SecurityGroupEgress` supported), `SecurityGroupIngress`, `SecurityGroupEgress`, `InternetGateway`, `RouteTable`, `SubnetRouteTableAssociation`, `Route`, `NatGateway`, `EIP`, `Instance`, `LaunchTemplate`, `VPCGatewayAttachment`, `VPCEndpoint`, `NetworkAcl`, `NetworkAclEntry`, `SubnetNetworkAclAssociation`, `FlowLog` || Elastic Load Balancing v2 | `LoadBalancer`, `TargetGroup`, `Listener`, `ListenerRule` || Auto Scaling | `LaunchConfiguration`, `AutoScalingGroup`, `LifecycleHook`, `ScalingPolicy` || Application Auto Scaling | `ScalableTarget` (`ScheduledActions` are accepted and not run; Floci has no scheduled scaling), `ScalingPolicy` |diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 49df196569..f6e3b72dc8 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -222,7 +222,7 @@ Floci seeds the following resources on first use in each region so Terraform, th|--------|-------------|| CreateVpc | Creates a VPC with the requested CIDR block. `InstanceTenancy` accepts `default` or `dedicated`; `host` is rejected with `InvalidParameterValue`, as on AWS. || DescribeVpcs | Lists or returns stored VPCs. |-| DeleteVpc | Deletes a VPC from the local EC2 store, together with its default security group and rules, main route table and default network ACL. Fails with `DependencyViolation` while the VPC still has a subnet, a security group, route table or network ACL other than those defaults, a VPC endpoint, an attached internet gateway, a transit gateway attachment, or anything still holding a network interface in one of its subnets: an instance that is not terminated, a NAT gateway that is not deleted, a standalone network interface, or an interface endpoint. |+| DeleteVpc | Deletes a VPC from the local EC2 store, together with its default security group and rules, main route table and default network ACL. Fails with `DependencyViolation` while the VPC still has a subnet, a security group, route table or network ACL other than those defaults, a VPC endpoint, an attached internet gateway, a transit gateway attachment, or anything still holding a network interface in one of its subnets: an instance that is not terminated, a NAT gateway that is not deleted or failed, a standalone network interface, or an interface endpoint. || ModifyVpcAttribute | Updates supported VPC attributes. || DescribeVpcAttribute | Returns a supported VPC attribute. || DescribeVpcEndpointServices | Lists common AWS interface endpoint services and S3 (gateway and interface) in every availability zone, named per partition (see [Partitions](../configuration/partitions.md)). A `ServiceName` filter is echoed back as asked. |@@ -247,7 +247,7 @@ gateway lifecycles.|--------|-------------|| CreateSubnet | Creates a subnet in a VPC. || DescribeSubnets | Lists or returns stored subnets. |-| DeleteSubnet | Deletes a subnet from the local EC2 store. Fails with `DependencyViolation` while the subnet still has a transit gateway attachment or anything holding a network interface in it: an instance that is not terminated, a NAT gateway that is not deleted, a standalone network interface, or an interface endpoint. |+| DeleteSubnet | Deletes a subnet from the local EC2 store. Fails with `DependencyViolation` while the subnet still has a transit gateway attachment or anything holding a network interface in it: an instance that is not terminated, a NAT gateway that is not deleted or failed, a standalone network interface, or an interface endpoint. || ModifySubnetAttribute | Updates supported subnet attributes. |### Security Groupsdiff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisioner.javaindex 57da848c80..ec9efd8a8d 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisioner.java@@ -573,6 +573,11 @@ public class Ec2NetworkCfnProvisioner implements CfnResourceProvisioner {&& connectivityType.equalsIgnoreCase(existing.getConnectivityType() == null ? "public" : existing.getConnectivityType());NatGateway nat = reuse ? existing: ec2Service.createNatGateway(ctx.region(), subnetId, allocationId, connectivityType, tagList(props, ctx));+ if ("failed".equals(nat.getState())) {+ // The resource fails and its failed gateway is not left behind.+ ec2Service.deleteNatGateway(ctx.region(), nat.getNatGatewayId());+ throw new AwsException(nat.getFailureCode(), nat.getFailureMessage(), 400);+ }if (reuse) {CfnRollback.guarded(r, ctx, false, () -> { }, () -> undoInPlace(r), () -> applyTags(r, true, nat.getNatGatewayId(), existing.getTags(), props, ctx));}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex c1b0f2b1d8..628ba99af1 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -5117,6 +5117,8 @@ public class Ec2QueryHandler {.elem("subnetId", natGateway.getSubnetId()).elem("vpcId", natGateway.getVpcId()).elem("state", natGateway.getState())+ .elem("failureCode", natGateway.getFailureCode())+ .elem("failureMessage", natGateway.getFailureMessage()).elem("connectivityType", natGateway.getConnectivityType());if (natGateway.getCreateTime() != null) {xml.elem("createTime", ISO_FMT.format(natGateway.getCreateTime()));diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex 8506c5bded..1b8a272437 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -4790,7 +4790,8 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab* it the VPC: an instance, a NAT gateway, a standalone network interface, or an interface or* Gateway Load Balancer endpoint. A {@code shutting-down} instance still holds its interface and* a {@code deleting} NAT gateway still holds its address, so only {@code terminated} and- * {@code deleted} release the subnet; a standalone interface is removed from the store on+ * {@code deleted} release the subnet. A {@code failed} NAT gateway was never created and holds+ * no interface, so it does not count either; a standalone interface is removed from the store on* delete, so its presence alone counts. AWS answers {@code DependencyViolation} until then.*/private void requireNoSubnetResidents(String region, Set<String> subnetIds, String message) {@@ -4804,7 +4805,8 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab|| !"terminated".equals(instance.getState().getName())))|| natGateways.scan(k -> k.startsWith(regionPrefix)).stream().anyMatch(natGateway -> subnetIds.contains(natGateway.getSubnetId())- && !"deleted".equals(natGateway.getState()))+ && !"deleted".equals(natGateway.getState())+ && !"failed".equals(natGateway.getState()))|| networkInterfaces.scan(k -> k.startsWith(regionPrefix)).stream().anyMatch(ni -> subnetIds.contains(ni.getSubnetId()))|| vpcEndpoints.scan(k -> k.startsWith(regionPrefix)).stream()@@ -5340,7 +5342,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab* <p>Split out so that everything reporting an endpoint's interfaces -- the ids on* the wire, the objects flow-log attribution reads -- comes from one place and* cannot disagree. The alternative, deriving ids independently from the same- * {@link #endpointEniId}, looks equivalent and is not: this method skips a subnet+ * {@link #eniIdFromSeed}, looks equivalent and is not: this method skips a subnet* whose record has gone, and a second derivation that forgot to would report an* interface the first one denies exists. Congruence by construction beats congruence* by inspection, and the two had in fact already diverged.@@ -5372,7 +5374,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabcontinue;}NetworkInterface ni = new NetworkInterface();- ni.setNetworkInterfaceId(endpointEniId(endpoint.getVpcEndpointId(), subnetId));+ ni.setNetworkInterfaceId(eniIdFromSeed(endpoint.getVpcEndpointId() + "|" + subnetId));ni.setSubnetId(subnetId);ni.setVpcId(endpoint.getVpcId());ni.setAvailabilityZone(subnet.getAvailabilityZone());@@ -5435,9 +5437,9 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabreturn result;}- private static String endpointEniId(String endpointId, String subnetId) {- String hex = java.util.UUID.nameUUIDFromBytes(- (endpointId + "|" + subnetId).getBytes(StandardCharsets.UTF_8))+ /** A stable interface id derived from {@code seed}, for interfaces Floci projects rather than stores. */+ private static String eniIdFromSeed(String seed) {+ String hex = UUID.nameUUIDFromBytes(seed.getBytes(StandardCharsets.UTF_8)).toString().replace("-", "");return "eni-" + hex.substring(0, 17);}@@ -5453,7 +5455,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab* <p>Mapped over {@link #endpointNetworkInterfacesOf(VpcEndpoint)} rather than derived* separately, so the ids on the wire come BY CONSTRUCTION from the same derivation* flow-log attribution uses, and no endpoint can be described two ways. An earlier- * version of this method called {@link #endpointEniId} itself and looked equivalent;+ * version of this method called {@link #eniIdFromSeed} itself and looked equivalent;* it was not, because it lacked that method's skip of a subnet whose record has gone,* and the two were measured reporting different sets after a subnet was deleted out* from under a live endpoint.@@ -9365,7 +9367,36 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, ResettabnatGateway.setCreateTime(Instant.now());natGateway.setRegion(region);synchronized (privateIpAllocationLock) {- natGateway.getNatGatewayAddresses().add(natGatewayAddress(region, subnetId, allocationId));+ // Checked under the same lock that writes the association below, so two gateways+ // cannot both see the allocation free. As on AWS, an allocation already held by an+ // instance or another gateway does not fail the call: the gateway is created in state+ // failed, with no interface, and the allocation is left with its holder.+ if (isSet(allocationId)) {+ Address held = getRequiredAddress(region, allocationId);+ // The gateway scan covers gateways persisted before the Address record was marked.+ if (isSet(held.getAssociationId()) || isSet(held.getInstanceId())+ || isHeldByNatGateway(region, allocationId)) {+ natGateway.setState("failed");+ natGateway.setFailureCode("Resource.AlreadyAssociated");+ natGateway.setFailureMessage("Elastic IP address " + allocationId + " is already associated");+ }+ }+ if (!"failed".equals(natGateway.getState())) {+ NatGatewayAddress gatewayAddress =+ natGatewayAddress(region, natGateway.getNatGatewayId(), subnetId, allocationId);+ natGateway.getNatGatewayAddresses().add(gatewayAddress);+ // The Elastic IP is now held by the gateway's interface, so DescribeAddresses has to+ // say so: an allocation that looks free is one Terraform and the console would offer+ // to reuse. No instanceId, a NAT gateway is not an instance.+ if (isSet(allocationId)) {+ addresses.get(key(region, allocationId)).ifPresent(eip -> {+ eip.setAssociationId(gatewayAddress.getAssociationId());+ eip.setNetworkInterfaceId(gatewayAddress.getNetworkInterfaceId());+ eip.setPrivateIpAddress(gatewayAddress.getPrivateIp());+ addresses.put(key(region, allocationId), eip);+ });+ }+ }if (natGatewayTags != null && !natGatewayTags.isEmpty()) {natGateway.setTags(new ArrayList<>(natGatewayTags));tags.put(natGateway.getNatGatewayId(), new ArrayList<>(natGatewayTags));@@ -9382,9 +9413,10 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab* network_interface_id), and Gruntwork's VPC modules re-export nat_gateway_public_ips, so an* address carrying only an allocation id propagates empty values into dependent modules.*/- private NatGatewayAddress natGatewayAddress(String region, String subnetId, String allocationId) {+ private NatGatewayAddress natGatewayAddress(String region, String natGatewayId, String subnetId,+ String allocationId) {NatGatewayAddress address = new NatGatewayAddress();- address.setNetworkInterfaceId("eni-" + randomHex(17));+ address.setNetworkInterfaceId(eniIdFromSeed("nat|" + natGatewayId));address.setPrivateIp(assignPrivateIp(region, subnetId));if (isSet(allocationId)) {address.setAllocationId(allocationId);@@ -9397,6 +9429,51 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabreturn address;}+ /**+ * The interfaces a NAT gateway owns, one per stored address, built from that address so the id+ * DescribeNatGateways publishes is the id DescribeNetworkInterfaces resolves. Empty when the+ * gateway's subnet record is gone, as for an endpoint.+ */+ private List<NetworkInterface> natNetworkInterfacesOf(NatGateway natGateway, String ownerId) {+ String subnetKey = key(natGateway.getRegion(), natGateway.getSubnetId());+ Subnet subnet = (subnets instanceof AccountAwareStorageBackend<Subnet> aware+ ? aware.getForAccount(ownerId, subnetKey).or(() -> aware.getLegacyForAccount(ownerId, subnetKey))+ : subnets.get(subnetKey)).orElse(null);+ if (subnet == null) {+ return List.of();+ }+ List<NetworkInterface> result = new ArrayList<>();+ for (NatGatewayAddress address : natGateway.getNatGatewayAddresses()) {+ if (address.getNetworkInterfaceId() == null) {+ continue;+ }+ NetworkInterface ni = new NetworkInterface();+ ni.setNetworkInterfaceId(address.getNetworkInterfaceId());+ ni.setSubnetId(natGateway.getSubnetId());+ ni.setVpcId(natGateway.getVpcId());+ ni.setAvailabilityZone(subnet.getAvailabilityZone());+ ni.setDescription("Interface for NAT Gateway " + natGateway.getNatGatewayId());+ ni.setInterfaceType("nat_gateway");+ ni.setRequesterManaged(true);+ ni.setOwnerId(ownerId);+ ni.setPrivateIpAddress(address.getPrivateIp());+ NetworkInterfacePrivateIpAddress primaryIp = new NetworkInterfacePrivateIpAddress();+ primaryIp.setPrivateIpAddress(address.getPrivateIp());+ primaryIp.setPrimary(true);+ if (address.getPublicIp() != null) {+ NetworkInterfaceAssociation assoc = new NetworkInterfaceAssociation();+ assoc.setPublicIp(address.getPublicIp());+ assoc.setAllocationId(address.getAllocationId());+ assoc.setAssociationId(address.getAssociationId());+ assoc.setIpOwnerId(ownerId);+ primaryIp.setAssociation(assoc);+ }+ ni.getPrivateIpAddresses().add(primaryIp);+ result.add(ni);+ }+ return result;+ }+public List<NatGateway> describeNatGateways(String region, List<String> natGatewayIds,Map<String, List<String>> filters) {ensureDefaultResources(region);@@ -9416,9 +9493,28 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabpublic NatGateway deleteNatGateway(String region, String natGatewayId) {ensureDefaultResources(region);NatGateway natGateway = getRequiredNatGateway(region, natGatewayId);- natGateway.setState("deleted");- natGateways.delete(key(region, natGatewayId));- tags.delete(natGatewayId);+ // Hand the Elastic IP back, but only if the association is still the gateway's own. Under+ // the lock createNatGateway takes, so a concurrent create cannot have its association wiped.+ synchronized (privateIpAllocationLock) {+ natGateway.setState("deleted");+ for (NatGatewayAddress gatewayAddress : natGateway.getNatGatewayAddresses()) {+ if (!isSet(gatewayAddress.getAllocationId())) {+ continue;+ }+ addresses.get(key(region, gatewayAddress.getAllocationId()))+ .filter(eip -> gatewayAddress.getAssociationId() != null+ && gatewayAddress.getAssociationId().equals(eip.getAssociationId()))+ .ifPresent(eip -> {+ eip.setAssociationId(null);+ eip.setNetworkInterfaceId(null);+ eip.setPrivateIpAddress(null);+ addresses.put(key(region, eip.getAllocationId()), eip);+ });+ }+ natGateways.delete(key(region, natGatewayId));+ tags.delete(natGatewayId);+ natGateway.getNatGatewayAddresses().forEach(a -> tags.delete(a.getNetworkInterfaceId()));+ }return natGateway;}@@ -9447,16 +9543,26 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabpublic Address associateAddress(String region, String allocationId, String instanceId) {ensureDefaultResources(region);- Address addr = getRequiredAddress(region, allocationId);+ // Under the lock createNatGateway and deleteNatGateway take, so the gateway check and the+ // write cannot interleave with a gateway claiming or releasing the same allocation.+ synchronized (privateIpAllocationLock) {+ Address addr = getRequiredAddress(region, allocationId);+ // A NAT gateway holds its Elastic IP until DeleteNatGateway; reassociation would leave+ // the gateway claiming an address an instance now holds.+ if (isHeldByNatGateway(region, allocationId)) {+ throw new AwsException("Resource.AlreadyAssociated",+ "Elastic IP address " + allocationId + " is already associated with a NAT gateway.", 400);+ }- if (addr.getAssociationId() != null) {- disassociateAddress(region, addr.getAssociationId());+ if (addr.getAssociationId() != null) {+ disassociateAddress(region, addr.getAssociationId());+ }+ addr.setInstanceId(instanceId);+ addr.setAssociationId("eipassoc-" + randomHex(17));+ pointAddressAtInstance(addr, region, instanceId);+ addresses.put(key(region, allocationId), addr);+ return addr;}- addr.setInstanceId(instanceId);- addr.setAssociationId("eipassoc-" + randomHex(17));- pointAddressAtInstance(addr, region, instanceId);- addresses.put(key(region, allocationId), addr);- return addr;}/**@@ -9546,38 +9652,93 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabpublic void disassociateAddress(String region, String associationId) {ensureDefaultResources(region);- for (Address addr : addresses.scan(k -> true)) {- if (addr.getRegion().equals(region) && associationId.equals(addr.getAssociationId())) {- addr.setInstanceId(null);- addr.setAssociationId(null);- updateStoredAddressAssociation(addr);- addr.setNetworkInterfaceId(null);- addr.setPrivateIpAddress(null);- // Hand the allocation back its allocated address: with no instance behind it,- // there is nothing reachable left for it to stand for.- if (addr.getAllocatedPublicIp() != null) {- addr.setPublicIp(addr.getAllocatedPublicIp());+ // Under the lock NAT create and delete take, so the gateway check and the clear see the+ // same association.+ synchronized (privateIpAllocationLock) {+ for (Address addr : addresses.scan(k -> true)) {+ if (addr.getRegion().equals(region) && associationId.equals(addr.getAssociationId())) {+ // A NAT gateway holds its Elastic IP for its whole life and is released by+ // DeleteNatGateway; clearing only the allocation would leave the gateway and its+ // interface still claiming the address.+ if (isNatGatewayAssociation(region, associationId)) {+ throw new AwsException("InvalidParameterValue", "The association " + associationId+ + " belongs to a NAT gateway and cannot be disassociated; delete the NAT gateway.",+ 400);+ }+ addr.setInstanceId(null);+ addr.setAssociationId(null);+ updateStoredAddressAssociation(addr);+ addr.setNetworkInterfaceId(null);+ addr.setPrivateIpAddress(null);+ // Hand the allocation back its allocated address: with no instance behind it,+ // there is nothing reachable left for it to stand for.+ if (addr.getAllocatedPublicIp() != null) {+ addr.setPublicIp(addr.getAllocatedPublicIp());+ }+ addresses.put(key(region, addr.getAllocationId()), addr);+ return;}- addresses.put(key(region, addr.getAllocationId()), addr);- return;}}}+ /**+ * The caller's gateways, including unmigrated pre-account-isolation records when the caller is+ * the default account (they belong to it); never another account's.+ */+ private List<NatGateway> callerNatGateways() {+ return natGatewaysOf(callerAccountId());+ }++ private List<NatGateway> natGatewaysOf(String account) {+ if (natGateways instanceof AccountAwareStorageBackend<NatGateway> aware) {+ List<NatGateway> own = aware.scanForAccount(account, k -> true);+ if (!account.equals(defaultAccountId)) {+ return own;+ }+ List<NatGateway> all = new ArrayList<>(own);+ all.addAll(aware.scanUnscopedLegacy(g -> true));+ return all;+ }+ return natGateways.scan(k -> true);+ }++ private boolean isHeldByNatGateway(String region, String allocationId) {+ return callerNatGateways().stream()+ .filter(g -> region.equals(g.getRegion())+ && !"deleted".equals(g.getState()) && !"failed".equals(g.getState()))+ .anyMatch(g -> allocationId.equals(g.getAllocationId())+ || g.getNatGatewayAddresses().stream().anyMatch(a -> allocationId.equals(a.getAllocationId())));+ }++ private boolean isNatGatewayAssociation(String region, String associationId) {+ return callerNatGateways().stream()+ .filter(g -> region.equals(g.getRegion()))+ .flatMap(g -> g.getNatGatewayAddresses().stream())+ .anyMatch(a -> associationId.equals(a.getAssociationId()));+ }+public void releaseAddress(String region, String allocationId) {ensureDefaultResources(region);- Address address = getRequiredAddress(region, allocationId);- if (address.getAssociationId() != null) {- NetworkInterface ni = networkInterfaces.get(key(region, address.getNetworkInterfaceId())).orElse(null);- String vpcId = ni != null ? ni.getVpcId()- : getRequiredInstance(region, address.getInstanceId()).getVpcId();- if (!getRequiredVpc(region, vpcId).isDefault()) {+ synchronized (privateIpAllocationLock) {+ Address address = getRequiredAddress(region, allocationId);+ // A NAT gateway's Elastic IP is released by DeleteNatGateway, never out from under it.+ if (isHeldByNatGateway(region, allocationId)) {throw new AwsException("InvalidIPAddress.InUse","Address " + address.getPublicIp() + " is in use.", 400);}- disassociateAddress(region, address.getAssociationId());+ if (address.getAssociationId() != null) {+ NetworkInterface ni = networkInterfaces.get(key(region, address.getNetworkInterfaceId())).orElse(null);+ String vpcId = ni != null ? ni.getVpcId()+ : getRequiredInstance(region, address.getInstanceId()).getVpcId();+ if (!getRequiredVpc(region, vpcId).isDefault()) {+ throw new AwsException("InvalidIPAddress.InUse",+ "Address " + address.getPublicIp() + " is in use.", 400);+ }+ disassociateAddress(region, address.getAssociationId());+ }+ addresses.delete(key(region, allocationId));}- addresses.delete(key(region, allocationId));}private void releaseInterfaceAddresses(String region, String networkInterfaceId, boolean deleted) {@@ -10872,6 +11033,31 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabresult.add(endpointNi);}+ // The ENI a NAT gateway owns. DescribeNatGateways publishes its id (aws_nat_gateway's+ // network_interface_id), so it has to resolve here too. Unlike the endpoint arm above this+ // one honours the explicit account: gateways and their subnets are read for safeAccount.+ for (NatGateway natGateway : natGatewaysOf(safeAccount)) {+ if (!region.equals(natGateway.getRegion())) {+ continue;+ }+ for (NetworkInterface natNi : natNetworkInterfacesOf(natGateway, safeAccount)) {+ String natEniId = natNi.getNetworkInterfaceId();+ if (foundIds.contains(natEniId)) {+ continue;+ }+ if (!networkInterfaceIds.isEmpty() && !networkInterfaceIds.contains(natEniId)) {+ continue;+ }+ foundIds.add(natEniId);+ natNi.getTagSet().addAll((tags instanceof AccountAwareStorageBackend<List<Tag>> aware+ ? aware.getForAccount(safeAccount, natEniId) : tags.get(natEniId)).orElse(List.of()));+ if (!matchesFilters(natNi, filters, region)) {+ continue;+ }+ result.add(natNi);+ }+ }+// Phase 6: validate requested IDs existfor (String id : networkInterfaceIds) {if (!foundIds.contains(id)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.javaindex a3aa6388cc..a5b6922b5f 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.java@@ -17,6 +17,8 @@ public class NatGateway {private String allocationId;private String state = "available";private String connectivityType = "public";+ private String failureCode;+ private String failureMessage;private Instant createTime;private String region;private List<NatGatewayAddress> natGatewayAddresses = new ArrayList<>();@@ -39,6 +41,12 @@ public class NatGateway {public String getState() { return state; }public void setState(String state) { this.state = state; }+ public String getFailureCode() { return failureCode; }+ public void setFailureCode(String failureCode) { this.failureCode = failureCode; }++ public String getFailureMessage() { return failureMessage; }+ public void setFailureMessage(String failureMessage) { this.failureMessage = failureMessage; }+public String getConnectivityType() { return connectivityType; }public void setConnectivityType(String connectivityType) { this.connectivityType = connectivityType; }diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEc2NetworkingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEc2NetworkingIntegrationTest.javaindex 09d9e1d806..051ac841e0 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEc2NetworkingIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEc2NetworkingIntegrationTest.java@@ -86,6 +86,28 @@ class CloudFormationEc2NetworkingIntegrationTest {ec2("DeleteVpc", Map.of("VpcId", vpcId));}+ /**+ * CreateNatGateway with an Elastic IP another gateway holds succeeds on AWS and leaves the+ * gateway failed; CloudFormation must still fail the resource rather than report it created.+ */+ @Test+ void aNatGatewayGivenAnAlreadyHeldElasticIpFailsTheStack() {+ String vpcId = between(ec2("CreateVpc", Map.of("CidrBlock", "10.42.0.0/16")), "<vpcId>", "</vpcId>");+ String nat = "{\"Type\": \"AWS::EC2::NatGateway\", %s\"Properties\": {\"SubnetId\": {\"Ref\": \"Subnet\"},"+ + " \"AllocationId\": {\"Fn::GetAtt\": [\"Eip\", \"AllocationId\"]}}}";+ cloudFormation("ec2-nat-shared-eip-it", "CreateStack", """+ {"Resources": {+ "Subnet": {"Type": "AWS::EC2::Subnet", "Properties": {"VpcId": "%s", "CidrBlock": "10.42.0.0/24"}},+ "Eip": {"Type": "AWS::EC2::EIP", "Properties": {"Domain": "vpc"}},+ "NatA": %s,+ "NatB": %s+ }}+ """.formatted(vpcId, nat.formatted(""), nat.formatted("\"DependsOn\": \"NatA\", ")));++ describeStacks("ec2-nat-shared-eip-it", "ROLLBACK_COMPLETE");+ assertFalse(ec2("DescribeNatGateways").contains(vpcId), "no gateway, failed or not, is left behind");+ }+private static String subnetXml(String subnetId) {return ec2("DescribeSubnets", Map.of("SubnetId.1", subnetId));}@@ -187,14 +209,27 @@ class CloudFormationEc2NetworkingIntegrationTest {assertFalse(retagged.contains("<key>tier</key>"), "the dropped tag must be removed");// CidrBlock is createOnly: the public subnet is replaced, and with it the NAT gateway and the- // association that name it; the gateway, EIP and route tables stay.- cloudFormation("UpdateStack", template(vpcId, "10.40.2.0/24"));+ // association that name it; the gateway and route tables stay. The replacement gateway gets a+ // new EIP: CloudFormation creates it before deleting the old one, and on AWS a gateway given+ // an Elastic IP the displaced gateway still holds is created failed. The old EIP stays in+ // the template for a second reason: Floci's update cleanup deletes removed resources before+ // the old copies of replaced ones (AWS deletes in reverse dependency order), so dropping the+ // EIP while replacing its gateway would try to release it while the old gateway still holds+ // it. Keeping NatEip sidesteps that; the cleanup order is a separate issue. The old EIP is+ // free once the displaced gateway is gone. oldEip is NatEip: out is NatEipB's outputs below.+ cloudFormation("UpdateStack", template(vpcId, "10.40.2.0/24").replace("NatEip", "NatEipB")+ .replace("\"NatEipB\": {\"Type\"",+ "\"NatEip\": {\"Type\": \"AWS::EC2::EIP\", \"Properties\": {\"Domain\": \"vpc\"}},\n"+ + " \"NatEipB\": {\"Type\""));Map<String, String> replaced = XmlParser.extractPairs(describeStacks("UPDATE_COMPLETE"), "Outputs", "OutputKey", "OutputValue");assertFalse(out.get("SubnetId").equals(replaced.get("SubnetId")), "a changed CIDR must replace the subnet");assertFalse(out.get("NatId").equals(replaced.get("NatId")), "the NAT gateway follows its subnet");assertFalse(out.get("AssocId").equals(replaced.get("AssocId")), "the association follows its subnet");assertEquals(out.get("IgwId"), replaced.get("IgwId"));- assertEquals(out.get("EipAllocationId"), replaced.get("EipAllocationId"));+ assertFalse(out.get("EipAllocationId").equals(replaced.get("EipAllocationId")), "the gateway takes the new EIP");+ assertFalse(ec2("DescribeAddresses", Map.of("AllocationId.1", out.get("EipAllocationId"))).contains("<associationId>"),+ "the displaced gateway's EIP must be free");+ String oldEip = out.get("EipAllocationId");assertEquals(out.get("PublicRtId"), replaced.get("PublicRtId"));assertEquals(out.get("PrivateRtId"), replaced.get("PrivateRtId"));assertFalse(ec2("DescribeSubnets").contains(out.get("SubnetId")), "the displaced subnet must be gone");@@ -206,7 +241,7 @@ class CloudFormationEc2NetworkingIntegrationTest {CfnStackWaits.awaitStackDeleted(STACK);for (String id : List.of(out.get("SubnetId"), out.get("PublicRtId"), out.get("PrivateRtId"),- out.get("AssocId"), out.get("NatId"), out.get("EipAllocationId"), out.get("IgwId"))) {+ out.get("AssocId"), out.get("NatId"), out.get("EipAllocationId"), oldEip, out.get("IgwId"))) {String everything = ec2("DescribeSubnets") + ec2("DescribeRouteTables") + ec2("DescribeNatGateways")+ ec2("DescribeAddresses") + ec2("DescribeInternetGateways");assertFalse(everything.contains(id), "stack delete must remove " + id);diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2NatGatewayAddressIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2NatGatewayAddressIntegrationTest.javaindex 035057041b..c765e7f2a5 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2NatGatewayAddressIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2NatGatewayAddressIntegrationTest.java@@ -89,6 +89,105 @@ class Ec2NatGatewayAddressIntegrationTest {startsWith("eni-"));}+ /**+ * The interface id DescribeNatGateways publishes has to resolve through+ * DescribeNetworkInterfaces, and the Elastic IP the gateway holds has to read as associated+ * through DescribeAddresses. Deleting the gateway releases both.+ */+ @Test+ void aGatewaysInterfaceResolvesAndItsElasticIpReadsAsAssociated() {+ String subnetId = subnetId();+ String allocationId = given()+ .formParam("Action", "AllocateAddress")+ .formParam("Domain", "vpc")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .extract().path("AllocateAddressResponse.allocationId");++ String natGatewayId = given()+ .formParam("Action", "CreateNatGateway")+ .formParam("SubnetId", subnetId)+ .formParam("AllocationId", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .extract().path("CreateNatGatewayResponse.natGateway.natGatewayId");++ io.restassured.response.Response described = given()+ .formParam("Action", "DescribeNatGateways")+ .formParam("NatGatewayId.1", natGatewayId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200).extract().response();+ String prefix = "DescribeNatGatewaysResponse.natGatewaySet.item.";+ String eniId = described.path(prefix + "natGatewayAddressSet.item.networkInterfaceId");+ String privateIp = described.path(prefix + "natGatewayAddressSet.item.privateIp");+ String associationId = described.path(prefix + "natGatewayAddressSet.item.associationId");+ String vpcId = described.path(prefix + "vpcId");++ // Twice: the id must be stable, not re-minted per read.+ for (int i = 0; i < 2; i++) {+ given()+ .formParam("Action", "DescribeNetworkInterfaces")+ .formParam("NetworkInterfaceId.1", eniId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then()+ .statusCode(200)+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.networkInterfaceId",+ equalTo(eniId))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.interfaceType",+ equalTo("nat_gateway"))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.subnetId",+ equalTo(subnetId))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.vpcId",+ equalTo(vpcId))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.privateIpAddress",+ equalTo(privateIp))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item"+ + ".privateIpAddressesSet.item.association.allocationId", equalTo(allocationId));+ }++ given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then()+ .statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.associationId", equalTo(associationId))+ .body("DescribeAddressesResponse.addressesSet.item.networkInterfaceId", equalTo(eniId))+ .body("DescribeAddressesResponse.addressesSet.item.privateIpAddress", equalTo(privateIp));++ given()+ .formParam("Action", "DeleteNatGateway")+ .formParam("NatGatewayId", natGatewayId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);++ given()+ .formParam("Action", "DescribeNetworkInterfaces")+ .formParam("NetworkInterfaceId.1", eniId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidNetworkInterfaceID.NotFound"));++ given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then()+ .statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.allocationId", equalTo(allocationId))+ .body(not(containsString("<associationId>")))+ .body(not(containsString("<networkInterfaceId>")));+ }+@Testvoid aPrivateGatewayHasAPrivateAddressAndNoElasticIp() {given()@@ -134,4 +233,164 @@ class Ec2NatGatewayAddressIntegrationTest {.statusCode(400).body("Response.Errors.Error.Code", equalTo("InvalidParameterCombination"));}++ private String allocate() {+ return given()+ .formParam("Action", "AllocateAddress")+ .formParam("Domain", "vpc")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .extract().path("AllocateAddressResponse.allocationId");+ }++ private io.restassured.response.Response createNat(String allocationId) {+ return given()+ .formParam("Action", "CreateNatGateway")+ .formParam("SubnetId", subnetId())+ .formParam("AllocationId", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/");+ }++ /**+ * As on AWS, CreateNatGateway with an Elastic IP another gateway or an instance holds+ * succeeds, but the gateway is failed: no interface, and the holder keeps the address.+ */+ @Test+ void aGatewayGivenAnAssociatedElasticIpIsCreatedFailed() {+ String heldByGateway = allocate();+ createNat(heldByGateway).then().statusCode(200);+ String failedId = createNat(heldByGateway).then().statusCode(200)+ .body("CreateNatGatewayResponse.natGateway.state", equalTo("failed"))+ .extract().path("CreateNatGatewayResponse.natGateway.natGatewayId");+ given()+ .formParam("Action", "DescribeNatGateways")+ .formParam("NatGatewayId.1", failedId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DescribeNatGatewaysResponse.natGatewaySet.item.state", equalTo("failed"))+ .body("DescribeNatGatewaysResponse.natGatewaySet.item.failureCode",+ equalTo("Resource.AlreadyAssociated"))+ .body("DescribeNatGatewaysResponse.natGatewaySet.item.failureMessage",+ equalTo("Elastic IP address " + heldByGateway + " is already associated"))+ .body(not(containsString("<networkInterfaceId>")));++ String heldByInstance = allocate();+ given()+ .formParam("Action", "AssociateAddress")+ .formParam("AllocationId", heldByInstance)+ .formParam("InstanceId", "i-0123456789abcdef0")+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);+ createNat(heldByInstance).then().statusCode(200)+ .body("CreateNatGatewayResponse.natGateway.state", equalTo("failed"))+ .body("CreateNatGatewayResponse.natGateway.failureCode", equalTo("Resource.AlreadyAssociated"));+ String instanceAssociation = given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", heldByInstance)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.instanceId", equalTo("i-0123456789abcdef0"))+ .extract().path("DescribeAddressesResponse.addressesSet.item.associationId");+ // The failed gateway does not hold the address: once the instance lets go it can be released.+ given()+ .formParam("Action", "DisassociateAddress")+ .formParam("AssociationId", instanceAssociation)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);+ given()+ .formParam("Action", "ReleaseAddress")+ .formParam("AllocationId", heldByInstance)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);++ // The failed gateway claimed nothing, and deleting it leaves the first gateway's association alone.+ String held = given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", heldByGateway)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.associationId", startsWith("eipassoc-"))+ .extract().path("DescribeAddressesResponse.addressesSet.item.associationId");+ given()+ .formParam("Action", "DeleteNatGateway")+ .formParam("NatGatewayId", failedId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);+ given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", heldByGateway)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.associationId", equalTo(held));+ }++ /** The association a gateway publishes is released by deleting the gateway, not by disassociating. */+ @Test+ void aGatewaysElasticIpCannotBeDisassociated() {+ String allocationId = allocate();+ String natGatewayId = createNat(allocationId).then().statusCode(200)+ .extract().path("CreateNatGatewayResponse.natGateway.natGatewayId");+ String associationId = given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .extract().path("DescribeAddressesResponse.addressesSet.item.associationId");++ given()+ .formParam("Action", "DisassociateAddress")+ .formParam("AssociationId", associationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));++ given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.associationId", equalTo(associationId));++ // Nor released out from under the gateway: AWS answers InvalidIPAddress.InUse.+ given()+ .formParam("Action", "ReleaseAddress")+ .formParam("AllocationId", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidIPAddress.InUse"));+ given()+ .formParam("Action", "DescribeAddresses")+ .formParam("AllocationId.1", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200)+ .body("DescribeAddressesResponse.addressesSet.item.associationId", equalTo(associationId));++ given()+ .formParam("Action", "DeleteNatGateway")+ .formParam("NatGatewayId", natGatewayId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);+ given()+ .formParam("Action", "ReleaseAddress")+ .formParam("AllocationId", allocationId)+ .header("Authorization", AUTH_HEADER)+ .when().post("/")+ .then().statusCode(200);+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javaindex fed2017657..e80310edf3 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.ec2.model.Address;@@ -24,6 +25,7 @@ import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplateData;import io.github.hectorvent.floci.services.ec2.model.ManagedPrefixList;import io.github.hectorvent.floci.services.ec2.model.NatGateway;+import io.github.hectorvent.floci.services.ec2.model.NatGatewayAddress;import io.github.hectorvent.floci.services.ec2.model.NetworkInterface;import io.github.hectorvent.floci.services.ec2.model.NetworkInterfaceAssociation;import io.github.hectorvent.floci.services.ec2.model.NetworkInterfaceListResult;@@ -463,6 +465,54 @@ class Ec2ServiceTest {.noneMatch(subnet -> subnetId.equals(subnet.getSubnetId())));}+ /**+ * A failed NAT gateway was never created and holds no interface, so it does not pin its subnet.+ * The gateway fails because its Elastic IP is already held by a gateway in the default VPC.+ */+ @Test+ void deleteSubnetIgnoresAFailedNatGateway() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());+ String region = "us-east-1";+ String defaultSubnetId = service.describeSubnets(region, List.of(), Map.of()).getFirst().getSubnetId();+ String allocationId = service.allocateAddress(region).getAllocationId();+ service.createNatGateway(region, defaultSubnetId, allocationId, null, null);+ String vpcId = service.createVpc(region, "10.85.0.0/16", false).getVpcId();+ String subnetId = service.createSubnet(region, vpcId, "10.85.1.0/24", "us-east-1a").getSubnetId();+ NatGateway failed = service.createNatGateway(region, subnetId, allocationId, null, null);+ assertEquals("failed", failed.getState());++ service.deleteSubnet(region, subnetId);+ assertTrue(service.describeSubnets(region, List.of(), Map.of()).stream()+ .noneMatch(subnet -> subnetId.equals(subnet.getSubnetId())));+ }++ /** DeleteVpc checks the same subnet residents, so a failed NAT gateway does not pin the VPC either. */+ @Test+ void deleteVpcIgnoresAFailedNatGatewayInOneOfItsSubnets() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());+ String region = "us-east-1";+ String defaultSubnetId = service.describeSubnets(region, List.of(), Map.of()).getFirst().getSubnetId();+ String allocationId = service.allocateAddress(region).getAllocationId();+ service.createNatGateway(region, defaultSubnetId, allocationId, null, null);+ String vpcId = service.createVpc(region, "10.86.0.0/16", false).getVpcId();+ String subnetId = service.createSubnet(region, vpcId, "10.86.1.0/24", "us-east-1a").getSubnetId();+ NatGateway failed = service.createNatGateway(region, subnetId, allocationId, null, null);+ assertEquals("failed", failed.getState());++ // DeleteVpc refuses while any subnet remains, so the resident check runs in DeleteSubnet;+ // after that the failed gateway must not keep the VPC either.+ service.deleteSubnet(region, subnetId);+ service.deleteVpc(region, vpcId);+ assertTrue(service.describeVpcs(region, List.of(), Map.of()).stream()+ .noneMatch(vpc -> vpcId.equals(vpc.getVpcId())));+ }+@Testvoid deleteSubnetFailsUntilItsStandaloneNetworkInterfaceIsDeleted() {Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),@@ -1117,6 +1167,216 @@ class Ec2ServiceTest {.anyMatch(n -> eni.getNetworkInterfaceId().equals(n.getNetworkInterfaceId())));}+ /**+ * The NAT arm of DescribeNetworkInterfaces reads gateways for the account it was asked about.+ * A gateway made under the default account resolves for that account and is NotFound for+ * another one named explicitly.+ */+ @Test+ void natGatewayInterfaceResolvesOnlyForTheAccountThatOwnsTheGateway() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of())+ .getFirst().getSubnetId();+ String eniId = service.createNatGateway("us-east-1", subnetId, null, "private", null)+ .getNatGatewayAddresses().getFirst().getNetworkInterfaceId();++ String owner = service.callerAccountId();+ assertEquals(eniId, service.describeNetworkInterfaces(owner, "us-east-1", List.of(eniId), Map.of())+ .networkInterfaces().getFirst().getNetworkInterfaceId());+ AwsException e = assertThrows(AwsException.class, () -> service.describeNetworkInterfaces(+ "999999999999", "us-east-1", List.of(eniId), Map.of()));+ assertEquals("InvalidNetworkInterfaceID.NotFound", e.getErrorCode());+ }++ /**+ * A gateway persisted before Address records were marked has an allocation that looks free.+ * The gateway still holds it, so a second gateway is created failed and claims nothing.+ */+ @Test+ void natGatewayGivenAnElasticIpHeldByALegacyGatewayWithAnUnmarkedAddressIsFailed() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of()).getFirst().getSubnetId();+ String allocationId = service.allocateAddress("us-east-1").getAllocationId();+ service.createNatGateway("us-east-1", subnetId, allocationId, null, null);+ // Simulate the pre-change record: in-memory storage hands back the stored object.+ Address legacy = service.describeAddresses("us-east-1", List.of(allocationId), Map.of()).getFirst();+ legacy.setAssociationId(null);+ legacy.setNetworkInterfaceId(null);+ legacy.setPrivateIpAddress(null);++ NatGateway failed = service.createNatGateway("us-east-1", subnetId, allocationId, null, null);+ assertEquals("failed", failed.getState());+ assertEquals("Resource.AlreadyAssociated", failed.getFailureCode());+ assertTrue(failed.getNatGatewayAddresses().isEmpty());+ assertNull(service.describeAddresses("us-east-1", List.of(allocationId), Map.of())+ .getFirst().getAssociationId(), "a failed gateway must not claim the allocation");+ }++ /** AssociateAddress refuses an allocation a NAT gateway holds; the gateway keeps it. */+ @Test+ void associateAddressRefusesANatGatewaysElasticIp() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of()).getFirst().getSubnetId();+ String allocationId = service.allocateAddress("us-east-1").getAllocationId();+ NatGateway nat = service.createNatGateway("us-east-1", subnetId, allocationId, null, null);+ String gatewayAssociation = nat.getNatGatewayAddresses().getFirst().getAssociationId();++ AwsException e = assertThrows(AwsException.class,+ () -> service.associateAddress("us-east-1", allocationId, "i-0123456789abcdef0"));+ assertEquals("Resource.AlreadyAssociated", e.getErrorCode());++ Address after = service.describeAddresses("us-east-1", List.of(allocationId), Map.of()).getFirst();+ assertEquals(gatewayAssociation, after.getAssociationId());+ assertNull(after.getInstanceId());+ service.deleteNatGateway("us-east-1", nat.getNatGatewayId());+ assertNull(service.describeAddresses("us-east-1", List.of(allocationId), Map.of())+ .getFirst().getAssociationId(), "delete must still release the gateway's Elastic IP");+ }++ /**+ * A gateway persisted before account isolation (unprefixed key) still holds its Elastic IP:+ * a second gateway is created failed, and ReleaseAddress answers InvalidIPAddress.InUse.+ */+ @Test+ void aLegacyUnprefixedGatewaysElasticIpCannotBeTakenOrReleased() {+ InMemoryStorage<String, NatGateway> rawGateways = new InMemoryStorage<>();+ Map<String, AccountAwareStorageBackend<?>> stores = Map.of("ec2-nat-gateways.json",+ new AccountAwareStorageBackend<>(rawGateways, null, "000000000000"));+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory(stores));+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of()).getFirst().getSubnetId();+ String allocationId = service.allocateAddress("us-east-1").getAllocationId();+ NatGateway legacy = new NatGateway();+ legacy.setNatGatewayId("nat-0legacy000000000");+ legacy.setSubnetId(subnetId);+ legacy.setAllocationId(allocationId);+ legacy.setState("available");+ legacy.setRegion("us-east-1");+ rawGateways.put("us-east-1::nat-0legacy000000000", legacy);++ NatGateway failed = service.createNatGateway("us-east-1", subnetId, allocationId, null, null);+ assertEquals("failed", failed.getState());+ assertEquals("Resource.AlreadyAssociated", failed.getFailureCode());+ AwsException e = assertThrows(AwsException.class,+ () -> service.releaseAddress("us-east-1", allocationId));+ assertEquals("InvalidIPAddress.InUse", e.getErrorCode());+ assertEquals(1, service.describeAddresses("us-east-1", List.of(allocationId), Map.of()).size());+ }++ /** A legacy unprefixed gateway in a legacy unprefixed subnet resolves its interface for the default account. */+ @Test+ void aLegacyUnprefixedGatewaysInterfaceResolvesForTheDefaultAccount() {+ InMemoryStorage<String, NatGateway> rawGateways = new InMemoryStorage<>();+ InMemoryStorage<String, Subnet> rawSubnets = new InMemoryStorage<>();+ Map<String, AccountAwareStorageBackend<?>> stores = Map.of(+ "ec2-nat-gateways.json", new AccountAwareStorageBackend<>(rawGateways, null, "000000000000"),+ "ec2-subnets.json", new AccountAwareStorageBackend<>(rawSubnets, null, "000000000000"));+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory(stores));+ service.describeSubnets("us-east-1", List.of(), Map.of());+ Subnet subnet = new Subnet();+ subnet.setSubnetId("subnet-0legacy00000000");+ subnet.setVpcId("vpc-0legacy000000000");+ subnet.setAvailabilityZone("us-east-1a");+ subnet.setRegion("us-east-1");+ rawSubnets.put("us-east-1::subnet-0legacy00000000", subnet);+ NatGateway legacy = new NatGateway();+ legacy.setNatGatewayId("nat-0legacy000000000");+ legacy.setSubnetId("subnet-0legacy00000000");+ legacy.setVpcId("vpc-0legacy000000000");+ legacy.setRegion("us-east-1");+ NatGatewayAddress address = new NatGatewayAddress();+ address.setNetworkInterfaceId("eni-0legacy000000000");+ address.setPrivateIp("10.0.0.5");+ legacy.getNatGatewayAddresses().add(address);+ rawGateways.put("us-east-1::nat-0legacy000000000", legacy);++ NetworkInterface ni = service.describeNetworkInterfaces(service.callerAccountId(), "us-east-1",+ List.of("eni-0legacy000000000"), Map.of()).networkInterfaces().getFirst();+ assertEquals("nat_gateway", ni.getInterfaceType());+ assertEquals("us-east-1a", ni.getAvailabilityZone());+ AwsException e = assertThrows(AwsException.class, () -> service.describeNetworkInterfaces(+ "999999999999", "us-east-1", List.of("eni-0legacy000000000"), Map.of()));+ assertEquals("InvalidNetworkInterfaceID.NotFound", e.getErrorCode());+ }++ /** Tags on a NAT gateway's interface read back through DescribeNetworkInterfaces and go with the gateway. */+ @Test+ void aNatGatewayInterfacesTagsReadBackAndAreDeletedWithTheGateway() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of()).getFirst().getSubnetId();+ NatGateway nat = service.createNatGateway("us-east-1", subnetId, null, "private", null);+ String eniId = nat.getNatGatewayAddresses().getFirst().getNetworkInterfaceId();+ service.createTags("us-east-1", List.of(eniId), List.of(new Tag("Name", "nat-eni")));++ NetworkInterface ni = service.describeNetworkInterfaces(service.callerAccountId(), "us-east-1",+ List.of(eniId), Map.of()).networkInterfaces().getFirst();+ assertEquals("nat-eni", ni.getTagSet().getFirst().getValue());++ service.deleteNatGateway("us-east-1", nat.getNatGatewayId());+ assertTrue(service.describeTags("us-east-1", Map.of("resource-id", List.of(eniId))).isEmpty());+ }++ /** DisassociateAddress checks and clears under the lock NAT create and delete take. */+ @Test+ void disassociateAddressWaitsForTheAllocationLock() throws Exception {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String allocationId = service.allocateAddress("us-east-1").getAllocationId();+ String associationId = service.associateAddress("us-east-1", allocationId, "i-0123456789abcdef0")+ .getAssociationId();+ Field field = Ec2Service.class.getDeclaredField("privateIpAllocationLock");+ field.setAccessible(true);+ Object lock = field.get(service);++ Thread disassociator = new Thread(() -> service.disassociateAddress("us-east-1", associationId));+ synchronized (lock) {+ disassociator.start();+ disassociator.join(500);+ assertTrue(disassociator.isAlive(), "disassociate must wait for the allocation lock");+ }+ disassociator.join(5000);+ assertFalse(disassociator.isAlive());+ assertNull(service.describeAddresses("us-east-1", List.of(allocationId), Map.of())+ .getFirst().getAssociationId());+ }++ /** DeleteNatGateway releases the Elastic IP under the lock CreateNatGateway takes. */+ @Test+ void deleteNatGatewayReleasesTheElasticIpUnderTheAllocationLock() throws Exception {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of()).getFirst().getSubnetId();+ String allocationId = service.allocateAddress("us-east-1").getAllocationId();+ String natId = service.createNatGateway("us-east-1", subnetId, allocationId, null, null).getNatGatewayId();+ Field field = Ec2Service.class.getDeclaredField("privateIpAllocationLock");+ field.setAccessible(true);+ Object lock = field.get(service);++ Thread deleter = new Thread(() -> service.deleteNatGateway("us-east-1", natId));+ synchronized (lock) {+ deleter.start();+ deleter.join(500);+ assertTrue(deleter.isAlive(), "delete must wait for the allocation lock");+ }+ deleter.join(5000);+ assertFalse(deleter.isAlive());+ assertNull(service.describeAddresses("us-east-1", List.of(allocationId), Map.of())+ .getFirst().getAssociationId());+ }+@Testvoid runInstancesRequiresImageIdInsteadOfDefaulting() {Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),diff --git a/tools/docs/cfn_resource_types.yaml b/tools/docs/cfn_resource_types.yamlindex 9cd4c00316..53b0d21dc6 100644--- a/tools/docs/cfn_resource_types.yaml+++ b/tools/docs/cfn_resource_types.yaml@@ -177,7 +177,7 @@ notes:AWS::Lambda::EventSourceMapping: 'SQS, Kinesis, DynamoDB Streams; `ParallelizationFactor` and `TumblingWindowInSeconds` are ignored'AWS::Lambda::Alias: also what SAM's `AutoPublishAlias` expands intoAWS::Lambda::EventInvokeConfig: also what a SAM function's `EventInvokeConfig` expands into- AWS::EC2::VPC: 'deleted on stack teardown; a VPC with dependents outside the stack, including anything still holding a network interface in its subnets (an instance that is not terminated, a NAT gateway that is not deleted, a standalone interface, an interface endpoint), fails the delete with `DependencyViolation`, as on AWS'+ AWS::EC2::VPC: 'deleted on stack teardown; a VPC with dependents outside the stack, including anything still holding a network interface in its subnets (an instance that is not terminated, a NAT gateway that is not deleted or failed, a standalone interface, an interface endpoint), fails the delete with `DependencyViolation`, as on AWS'AWS::EC2::SecurityGroup: inline `SecurityGroupIngress`/`SecurityGroupEgress` supportedAWS::ApplicationAutoScaling::ScalableTarget: '`ScheduledActions` are accepted and not run; Floci has no scheduled scaling'AWS::RDS::DBInstance: starts a real container