Light, fluffy, and always free - The AWS Local Emulator alternative
refactor(cloudformation): move the EC2 networking types into Ec2NetworkCfnProvisioner (#3223)
Hector Ventura725577416d32
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex e84607432f..933d42c142 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -11,6 +11,7 @@ import io.github.hectorvent.floci.services.cloudfront.model.Distribution;import io.github.hectorvent.floci.services.cloudfront.model.DistributionConfig;import io.github.hectorvent.floci.services.cloudfront.model.Origin;import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.cloudformation.provisioners.ReplacementCleanup;import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnRollback;import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudFormationResourceRegistry;import io.github.hectorvent.floci.services.cloudformation.provisioners.ProvisionContext;@@ -205,15 +206,8 @@ public class CloudFormationResourceProvisioner {"AWS::CloudFront::Distribution","AWS::DynamoDB::GlobalTable","AWS::DynamoDB::Table",- "AWS::EC2::EIP","AWS::EC2::Instance",- "AWS::EC2::InternetGateway",- "AWS::EC2::NatGateway",- "AWS::EC2::Route",- "AWS::EC2::RouteTable","AWS::EC2::SecurityGroup",- "AWS::EC2::Subnet",- "AWS::EC2::SubnetRouteTableAssociation","AWS::EKS::Cluster","AWS::EKS::Nodegroup","AWS::Events::EventBus",@@ -420,15 +414,7 @@ public class CloudFormationResourceProvisioner {// EC2 networking. These delegate to Ec2Service so the resources actually exist// (describe-subnets, ELBv2, etc. can find them) instead of being stubbed with a// fake physical id. Topological ordering guarantees parents are provisioned first.- case "AWS::EC2::Subnet" -> provisionSubnet(resource, properties, engine, region);case "AWS::EC2::SecurityGroup" -> provisionSecurityGroup(resource, properties, engine, region, stackName);- case "AWS::EC2::InternetGateway" -> provisionInternetGateway(resource, region);- case "AWS::EC2::RouteTable" -> provisionRouteTable(resource, properties, engine, region);- case "AWS::EC2::SubnetRouteTableAssociation" ->- provisionSubnetRouteTableAssociation(resource, properties, engine, region);- case "AWS::EC2::Route" -> provisionRoute(resource, properties, engine, region);- case "AWS::EC2::NatGateway" -> provisionNatGateway(resource, properties, engine, region);- case "AWS::EC2::EIP" -> provisionEip(resource, region);case "AWS::EC2::Instance" -> provisionEc2Instance(resource, properties, engine, region);// RDS. DBInstance/DBCluster start real RDS containers (same as the direct API).case "AWS::RDS::DBSubnetGroup" -> provisionDbSubnetGroup(resource, properties, engine, stackName, region);@@ -730,21 +716,6 @@ public class CloudFormationResourceProvisioner {// Ref/exports resolve to a real vpc-/subnet-/... id rather than a stub.- private void provisionSubnet(StackResource r, JsonNode props, CloudFormationTemplateEngine engine, String region) {- String vpcId = resolveOptional(props, "VpcId", engine);- String cidr = resolveOptional(props, "CidrBlock", engine);- String az = resolveOptional(props, "AvailabilityZone", engine);- String mapPublicIpOnLaunch = resolveOptional(props, "MapPublicIpOnLaunch", engine);- var subnet = ec2Service.createSubnet(region, vpcId, cidr, az);- if (mapPublicIpOnLaunch != null) {- ec2Service.modifySubnetAttribute(region, subnet.getSubnetId(), "mapPublicIpOnLaunch", mapPublicIpOnLaunch);- }- r.setPhysicalId(subnet.getSubnetId());- r.getAttributes().put("SubnetId", subnet.getSubnetId());- r.getAttributes().put("VpcId", subnet.getVpcId());- r.getAttributes().put("AvailabilityZone", subnet.getAvailabilityZone());- }-private void provisionSecurityGroup(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,String region, String stackName) {String groupName = resolveOptional(props, "GroupName", engine);@@ -781,59 +752,6 @@ public class CloudFormationResourceProvisioner {}}- private void provisionInternetGateway(StackResource r, String region) {- var igw = ec2Service.createInternetGateway(region);- r.setPhysicalId(igw.getInternetGatewayId());- r.getAttributes().put("InternetGatewayId", igw.getInternetGatewayId());- }-- private void provisionRouteTable(StackResource r, JsonNode props, CloudFormationTemplateEngine engine, String region) {- String vpcId = resolveOptional(props, "VpcId", engine);- var rt = ec2Service.createRouteTable(region, vpcId);- r.setPhysicalId(rt.getRouteTableId());- r.getAttributes().put("RouteTableId", rt.getRouteTableId());- }-- private void provisionSubnetRouteTableAssociation(StackResource r, JsonNode props,- CloudFormationTemplateEngine engine, String region) {- String routeTableId = resolveOptional(props, "RouteTableId", engine);- String subnetId = resolveOptional(props, "SubnetId", engine);- var assoc = ec2Service.associateRouteTable(region, routeTableId, subnetId);- r.setPhysicalId(assoc.getRouteTableAssociationId());- r.getAttributes().put("Id", assoc.getRouteTableAssociationId());- }-- private void provisionRoute(StackResource r, JsonNode props, CloudFormationTemplateEngine engine, String region) {- String routeTableId = resolveOptional(props, "RouteTableId", engine);- String destinationCidr = resolveOptional(props, "DestinationCidrBlock", engine);- String destinationIpv6Cidr = resolveOptional(props, "DestinationIpv6CidrBlock", engine);- String destinationPrefixListId = resolveOptional(props, "DestinationPrefixListId", engine);- String gatewayId = resolveOptional(props, "GatewayId", engine);- String natGatewayId = resolveOptional(props, "NatGatewayId", engine);- String egressOnlyInternetGatewayId = resolveOptional(props, "EgressOnlyInternetGatewayId", engine);- String vpcPeeringConnectionId = resolveOptional(props, "VpcPeeringConnectionId", engine);- ec2Service.createRoute(region, routeTableId, destinationCidr, destinationIpv6Cidr,- destinationPrefixListId, gatewayId, natGatewayId, egressOnlyInternetGatewayId,- vpcPeeringConnectionId);- r.setPhysicalId(r.getLogicalId() + "-" + UUID.randomUUID().toString().substring(0, 8));- }-- private void provisionNatGateway(StackResource r, JsonNode props, CloudFormationTemplateEngine engine, String region) {- String subnetId = resolveOptional(props, "SubnetId", engine);- String allocationId = resolveOptional(props, "AllocationId", engine);- var nat = ec2Service.createNatGateway(region, subnetId, allocationId, "public", List.of());- r.setPhysicalId(nat.getNatGatewayId());- r.getAttributes().put("NatGatewayId", nat.getNatGatewayId());- }-- private void provisionEip(StackResource r, String region) {- var addr = ec2Service.allocateAddress(region);- // Ref on AWS::EC2::EIP returns the public IP; AllocationId is exposed via Fn::GetAtt.- r.setPhysicalId(addr.getPublicIp());- r.getAttributes().put("AllocationId", addr.getAllocationId());- r.getAttributes().put("PublicIp", addr.getPublicIp());- }-// ── CloudWatch Logs ─────────────────────────────────────────────────────────/**@@ -5456,6 +5374,9 @@ public class CloudFormationResourceProvisioner {* attributes must not overwrite the committed resource state.*/void mergeFailedUpdateResourceTracking(StackResource previous, StackResource attempted) {+ // Any provisioner using ReplacementCleanup: an entity the failed attempt created and could+ // not remove is owed to the next cleanup, which runs on the restored resource.+ ReplacementCleanup.mergeDisplaced(previous, attempted);if (!"AWS::ApiGatewayV2::Api".equals(previous.getResourceType())|| !Objects.equals(previous.getResourceType(), attempted.getResourceType())) {return;diff --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.javanew file mode 100644index 0000000000..70823677cf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisioner.java@@ -0,0 +1,630 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.CidrCanonicalizer;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Address;+import io.github.hectorvent.floci.services.ec2.model.InternetGateway;+import io.github.hectorvent.floci.services.ec2.model.NatGateway;+import io.github.hectorvent.floci.services.ec2.model.Route;+import io.github.hectorvent.floci.services.ec2.model.RouteTable;+import io.github.hectorvent.floci.services.ec2.model.RouteTableAssociation;+import io.github.hectorvent.floci.services.ec2.model.Subnet;+import io.github.hectorvent.floci.services.ec2.model.Tag;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Objects;+import java.util.Set;+import java.util.function.Supplier;++/**+ * CloudFormation provisioning for the EC2 networking types: {@code AWS::EC2::Subnet},+ * {@code InternetGateway}, {@code RouteTable}, {@code Route}, {@code NatGateway}, {@code EIP} and+ * {@code SubnetRouteTableAssociation}. Extracted from {@code CloudFormationResourceProvisioner} as+ * part of the per-service decomposition. The physical id is the EC2 id the service assigns, except+ * for a Route, whose id is the registry primary identifier {@code <RouteTableId>|<destination>} (what+ * Ref returns on AWS and what a delete needs), and an EIP, whose Ref is its public IP.+ *+ * <p>{@code provision} runs again on every {@code UpdateStack}. A resource whose create-only+ * properties (the schema's {@code createOnlyProperties} that Floci emulates) are unchanged is kept:+ * its prior entity is described and reused, and the mutable properties are applied in place. A+ * changed create-only property creates the replacement and the {@link ReplacementCleanup} record+ * deletes the displaced entity once the update commits or restores it on rollback, as CloudFormation+ * does. A prior entity that is gone out of band is created anew.+ *+ * <p>Deletes tolerate only the service's own not-found code for each type; a+ * {@code DependencyViolation} still fails the stack delete, as on AWS.+ */+@ApplicationScoped+public class Ec2NetworkCfnProvisioner implements CfnResourceProvisioner {++ private static final String SUBNET = "AWS::EC2::Subnet";+ private static final String INTERNET_GATEWAY = "AWS::EC2::InternetGateway";+ private static final String ROUTE_TABLE = "AWS::EC2::RouteTable";+ private static final String ROUTE = "AWS::EC2::Route";+ private static final String NAT_GATEWAY = "AWS::EC2::NatGateway";+ private static final String EIP = "AWS::EC2::EIP";+ private static final String SUBNET_ROUTE_TABLE_ASSOCIATION = "AWS::EC2::SubnetRouteTableAssociation";+ private static final String ROUTE_ID_SEPARATOR = "|";+ private static final Logger LOG = Logger.getLogger(Ec2NetworkCfnProvisioner.class);+ /**+ * What an in-place update changed on a reused entity, recorded before the change so a stack+ * rollback can put it back: the prior tags (and the keys the update wrote), a subnet's prior+ * MapPublicIpOnLaunch, a route's prior target. Internal, like the other {@code __Floci} attributes.+ */+ static final String IN_PLACE_PRIOR_ATTR = "__FlociEc2NetworkPrior";+ private static final ObjectMapper MAPPER = new ObjectMapper();++ private final Ec2Service ec2Service;++ @Inject+ public Ec2NetworkCfnProvisioner(Ec2Service ec2Service) {+ this.ec2Service = ec2Service;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of(SUBNET, INTERNET_GATEWAY, ROUTE_TABLE, ROUTE, NAT_GATEWAY, EIP, SUBNET_ROUTE_TABLE_ASSOCIATION);+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ Map<String, String> attributesBefore = Map.copyOf(r.getAttributes());+ switch (r.getResourceType()) {+ case SUBNET -> provisionSubnet(r, props, ctx);+ case INTERNET_GATEWAY -> provisionInternetGateway(r, props, ctx);+ case ROUTE_TABLE -> provisionRouteTable(r, props, ctx);+ case ROUTE -> provisionRoute(r, props, ctx);+ case NAT_GATEWAY -> provisionNatGateway(r, props, ctx);+ case EIP -> provisionEip(r, props, ctx);+ case SUBNET_ROUTE_TABLE_ASSOCIATION -> provisionSubnetRouteTableAssociation(r, props, ctx);+ default -> throw new IllegalStateException("Ec2NetworkCfnProvisioner cannot handle " + r.getResourceType());+ }+ // A provision that left the resource with a new physical id replaced the entity: the+ // displaced one is deleted once the update commits, or restored if the update rolls back.+ ReplacementCleanup.record(r, ctx, attributesBefore);+ }++ @Override+ public boolean hasReplacementUpdate(StackResource resource) {+ return ReplacementCleanup.hasReplacement(resource);+ }++ @Override+ public String updateCleanupPhysicalId(StackResource resource) {+ return ReplacementCleanup.cleanupPhysicalId(resource);+ }++ @Override+ public UpdateCleanupResult completeUpdate(StackResource resource) {+ resource.getAttributes().remove(IN_PLACE_PRIOR_ATTR);+ return ReplacementCleanup.complete(resource, this::delete);+ }++ @Override+ public void clearUpdate(StackResource resource) {+ resource.getAttributes().remove(IN_PLACE_PRIOR_ATTR);+ ReplacementCleanup.clear(resource);+ }++ /**+ * A replacement is undone through the cleanup record: the displaced entity was never touched.+ * A reused entity that an update changed in place (tags, a subnet's MapPublicIpOnLaunch, a+ * route's target) is put back from the snapshot taken before the change. Without either, the+ * update changed nothing about the entity. A provision that fails mid-way restores its own+ * snapshot before the failure propagates (see {@link #guarded}), so the previous metadata the+ * engine restores for that resource matches the entity again.+ */+ @Override+ public boolean rollbackUpdate(StackResource resource) {+ if (ReplacementCleanup.rollback(resource, this::delete)) {+ resource.getAttributes().remove(IN_PLACE_PRIOR_ATTR);+ return true;+ }+ String snapshot = resource.getAttributes().remove(IN_PLACE_PRIOR_ATTR);+ if (snapshot != null) {+ restoreInPlace(resource, snapshot);+ }+ return true;+ }++ private void restoreInPlace(StackResource resource, String snapshot) {+ ObjectNode prior;+ try {+ prior = (ObjectNode) MAPPER.readTree(snapshot);+ } catch (JsonProcessingException e) {+ throw new IllegalStateException("Unreadable in-place snapshot on " + resource.getLogicalId(), e);+ }+ String region = prior.path("region").asText();+ String entityId = prior.path("entityId").asText();+ if (prior.has("tags")) {+ Map<String, String> priorTags = new LinkedHashMap<>();+ prior.get("tags").fields().forEachRemaining(f -> priorTags.put(f.getKey(), f.getValue().asText()));+ List<Tag> added = new ArrayList<>();+ prior.path("appliedKeys").forEach(key -> {+ if (!priorTags.containsKey(key.asText())) {+ added.add(new Tag(key.asText(), null));+ }+ });+ if (!added.isEmpty()) {+ ec2Service.deleteTags(region, List.of(entityId), added);+ }+ if (!priorTags.isEmpty()) {+ ec2Service.createTags(region, List.of(entityId), toTagList(priorTags));+ }+ }+ if (prior.has("mapPublicIpOnLaunch")) {+ ec2Service.modifySubnetAttribute(region, entityId, "mapPublicIpOnLaunch", prior.get("mapPublicIpOnLaunch").asText());+ }+ if (prior.has("route")) {+ ObjectNode target = (ObjectNode) prior.get("route");+ String routeTableId = target.path("routeTableId").asText();+ String cidr = text(target, "destinationCidrBlock");+ String ipv6 = text(target, "destinationIpv6CidrBlock");+ String prefixList = text(target, "destinationPrefixListId");+ String egressOnly = text(target, "egressOnlyInternetGatewayId");+ if (egressOnly != null) {+ ec2Service.deleteRoute(region, routeTableId, cidr, ipv6, prefixList);+ ec2Service.createRoute(region, routeTableId, cidr, ipv6, prefixList, null, null, egressOnly, null);+ } else {+ ec2Service.replaceRoute(region, routeTableId, cidr, ipv6, prefixList,+ text(target, "gatewayId"), text(target, "natGatewayId"), text(target, "vpcPeeringConnectionId"));+ }+ }+ }++ private static String text(ObjectNode node, String field) {+ return node.hasNonNull(field) ? node.get(field).asText() : null;+ }++ /** The snapshot for this resource, created on first use so the fields of several changes accumulate. */+ private static ObjectNode inPlacePrior(StackResource r, String entityId, ProvisionContext ctx) {+ String existing = r.getAttributes().get(IN_PLACE_PRIOR_ATTR);+ try {+ ObjectNode node = existing == null ? MAPPER.createObjectNode() : (ObjectNode) MAPPER.readTree(existing);+ node.put("region", ctx.region());+ node.put("entityId", entityId);+ return node;+ } catch (JsonProcessingException e) {+ throw new IllegalStateException("Unreadable in-place snapshot on " + r.getLogicalId(), e);+ }+ }++ private static void writeInPlacePrior(StackResource r, ObjectNode node) {+ r.getAttributes().put(IN_PLACE_PRIOR_ATTR, node.toString());+ }++ /** An EIP's Ref is its public IP, so its release needs the AllocationId recorded at create time. */+ @Override+ public void delete(StackResource resource, String region) {+ if (EIP.equals(resource.getResourceType()) && resource.getAttributes() != null+ && resource.getAttributes().get("AllocationId") != null) {+ String allocationId = resource.getAttributes().get("AllocationId");+ CfnDeletes.safeDelete("elastic IP", allocationId,+ () -> ec2Service.releaseAddress(region, allocationId), "InvalidAllocationID.NotFound");+ return;+ }+ delete(resource.getResourceType(), resource.getPhysicalId(), region);+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ if (physicalId == null || physicalId.isBlank()) {+ return;+ }+ switch (resourceType) {+ case SUBNET -> CfnDeletes.safeDelete("subnet", physicalId,+ () -> ec2Service.deleteSubnet(region, physicalId), "InvalidSubnetID.NotFound");+ case INTERNET_GATEWAY -> CfnDeletes.safeDelete("internet gateway", physicalId,+ () -> ec2Service.deleteInternetGateway(region, physicalId), "InvalidInternetGatewayID.NotFound");+ case ROUTE_TABLE -> CfnDeletes.safeDelete("route table", physicalId,+ () -> ec2Service.deleteRouteTable(region, physicalId), "InvalidRouteTableID.NotFound");+ case ROUTE -> deleteRoute(physicalId, region);+ case NAT_GATEWAY -> CfnDeletes.safeDelete("NAT gateway", physicalId,+ () -> ec2Service.deleteNatGateway(region, physicalId), "NatGatewayNotFound");+ case EIP -> releaseByPublicIp(physicalId, region);+ case SUBNET_ROUTE_TABLE_ASSOCIATION -> CfnDeletes.safeDelete("route table association", physicalId,+ () -> ec2Service.disassociateRouteTable(region, physicalId), "InvalidAssociationID.NotFound");+ default -> { }+ }+ }++ /**+ * The route's id names its table and destination; a route created by the switch before this+ * provisioner existed carries a generated id with no separator and cannot be located, so it is+ * left alone rather than guessed at. A table that is already gone took its routes with it.+ */+ private void deleteRoute(String physicalId, String region) {+ int separator = physicalId.indexOf(ROUTE_ID_SEPARATOR);+ if (separator <= 0 || separator == physicalId.length() - 1) {+ return;+ }+ String routeTableId = physicalId.substring(0, separator);+ String destination = physicalId.substring(separator + 1);+ CfnDeletes.safeDelete("route", physicalId, () -> ec2Service.deleteRoute(region, routeTableId,+ isIpv4Cidr(destination) ? destination : null,+ isIpv6Cidr(destination) ? destination : null,+ isPrefixList(destination) ? destination : null),+ "InvalidRoute.NotFound", "InvalidRouteTableID.NotFound");+ }++ /** Without the recorded AllocationId (a rollback of a failed create, for instance), the address is looked up by IP. */+ private void releaseByPublicIp(String publicIp, String region) {+ ec2Service.describeAddresses(region, List.of(), Map.of("public-ip", List.of(publicIp))).stream()+ .findFirst()+ .ifPresent(address -> CfnDeletes.safeDelete("elastic IP", address.getAllocationId(),+ () -> ec2Service.releaseAddress(region, address.getAllocationId()), "InvalidAllocationID.NotFound"));+ }++ /**+ * Reconciles the template's {@code Tags} onto an entity: keys the template dropped are removed,+ * the rest written. A template without a Tags property leaves whatever the entity carries.+ */+ private void applyTags(StackResource r, boolean reused, String resourceId, List<Tag> current, JsonNode props, ProvisionContext ctx) {+ if (props == null || !props.has("Tags")) {+ return;+ }+ Map<String, String> desired = ctx.resolveTags(props, "Tags");+ Map<String, String> currentTags = new LinkedHashMap<>();+ for (Tag tag : current == null ? List.<Tag>of() : current) {+ currentTags.put(tag.getKey(), tag.getValue());+ }+ List<String> stale = ProvisionContext.staleTagKeys(currentTags, desired);+ if (reused && ctx.isUpdate() && (!stale.isEmpty() || !desired.equals(currentTags))) {+ ObjectNode prior = inPlacePrior(r, resourceId, ctx);+ ObjectNode tags = prior.putObject("tags");+ currentTags.forEach(tags::put);+ var applied = prior.putArray("appliedKeys");+ desired.keySet().forEach(applied::add);+ writeInPlacePrior(r, prior);+ }+ if (!stale.isEmpty()) {+ ec2Service.deleteTags(ctx.region(), List.of(resourceId),+ stale.stream().map(key -> new Tag(key, null)).toList());+ }+ if (!desired.isEmpty()) {+ ec2Service.createTags(ctx.region(), List.of(resourceId), toTagList(desired));+ }+ }++ private static List<Tag> tagList(JsonNode props, ProvisionContext ctx) {+ return toTagList(ctx.resolveTags(props, "Tags"));+ }++ private static List<Tag> toTagList(Map<String, String> tags) {+ List<Tag> out = new ArrayList<>();+ tags.forEach((key, value) -> out.add(new Tag(key, value)));+ return out;+ }++ private Subnet findSubnet(String subnetId, String region) {+ return tolerateNotFound(() -> ec2Service.describeSubnets(region, List.of(subnetId), Map.of()).stream()+ .findFirst().orElse(null), "InvalidSubnetID.NotFound", subnetId);+ }++ private InternetGateway findInternetGateway(String igwId, String region) {+ return tolerateNotFound(() -> ec2Service.describeInternetGateways(region, List.of(igwId), Map.of()).stream()+ .findFirst().orElse(null), "InvalidInternetGatewayID.NotFound", igwId);+ }++ private RouteTable findRouteTable(String routeTableId, String region) {+ return tolerateNotFound(() -> ec2Service.describeRouteTables(region, List.of(routeTableId), Map.of()).stream()+ .findFirst().orElse(null), "InvalidRouteTableID.NotFound", routeTableId);+ }++ private RouteTableAssociation findAssociation(String associationId, String region) {+ return ec2Service.describeRouteTables(region, List.of(),+ Map.of("association.route-table-association-id", List.of(associationId))).stream()+ .flatMap(rt -> rt.getAssociations().stream())+ .filter(a -> associationId.equals(a.getRouteTableAssociationId()))+ .findFirst().orElse(null);+ }++ private NatGateway findNatGateway(String natGatewayId, String region) {+ return tolerateNotFound(() -> ec2Service.describeNatGateways(region, List.of(natGatewayId), Map.of()).stream()+ .filter(nat -> !"deleted".equals(nat.getState()))+ .findFirst().orElse(null), "NatGatewayNotFound", natGatewayId);+ }++ private Address findAddress(String allocationId, String publicIp, String region) {+ List<Address> matches = allocationId != null+ ? ec2Service.describeAddresses(region, List.of(allocationId), Map.of())+ : ec2Service.describeAddresses(region, List.of(), Map.of("public-ip", List.of(publicIp)));+ return matches.stream().findFirst().orElse(null);+ }++ private Route findRoute(String routeTableId, String destination, String region) {+ RouteTable table = findRouteTable(routeTableId, region);+ return table == null ? null : table.getRoutes().stream()+ .filter(route -> destination.equals(routeDestination(route)))+ .findFirst().orElse(null);+ }++ private static String routeDestination(Route route) {+ if (route.getDestinationCidrBlock() != null) {+ return route.getDestinationCidrBlock();+ }+ if (route.getDestinationIpv6CidrBlock() != null) {+ return route.getDestinationIpv6CidrBlock();+ }+ return route.getDestinationPrefixListId();+ }++ private static <T> T tolerateNotFound(Supplier<T> lookup, String notFoundCode, String id) {+ try {+ return lookup.get();+ } catch (AwsException e) {+ if (!notFoundCode.equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("{0} is gone; creating it anew", id);+ return null;+ }+ }++ /** The schema's required properties fail the resource with the repo's ValidationError wording, not a null into the service. */+ private static void require(String type, String property, String value) {+ if (value == null || value.isBlank()) {+ throw new AwsException("ValidationError", type + " requires " + property, 400);+ }+ }++ private static boolean isPrefixList(String destination) {+ return destination.startsWith("pl-");+ }++ private static boolean isIpv6Cidr(String destination) {+ return destination.contains(":");+ }++ private static boolean isIpv4Cidr(String destination) {+ return !isPrefixList(destination) && !isIpv6Cidr(destination);+ }++ private void provisionSubnet(StackResource r, JsonNode props, ProvisionContext ctx) {+ String vpcId = ctx.resolveOptional(props, "VpcId");+ String cidr = ctx.resolveOptional(props, "CidrBlock");+ String az = ctx.resolveOptional(props, "AvailabilityZone");+ String mapPublicIpOnLaunch = ctx.resolveOptional(props, "MapPublicIpOnLaunch");+ require(SUBNET, "VpcId", vpcId);+ // VpcId, CidrBlock and AvailabilityZone are createOnly: unchanged, the subnet is kept and+ // only MapPublicIpOnLaunch is applied; changed, a new subnet replaces it.+ Subnet existing = ctx.isUpdate() ? findSubnet(ctx.priorPhysicalId(), ctx.region()) : null;+ boolean reuse = existing != null && Objects.equals(vpcId, existing.getVpcId())+ && Objects.equals(cidr, existing.getCidrBlock())+ && (az == null || az.equals(existing.getAvailabilityZone()));+ Subnet subnet = reuse ? existing : ec2Service.createSubnet(ctx.region(), vpcId, cidr, az);+ r.setPhysicalId(subnet.getSubnetId());+ r.getAttributes().put("SubnetId", subnet.getSubnetId());+ r.getAttributes().put("VpcId", subnet.getVpcId());+ r.getAttributes().put("AvailabilityZone", subnet.getAvailabilityZone());+ guarded(r, ctx, !reuse, () -> ec2Service.deleteSubnet(ctx.region(), subnet.getSubnetId()), () -> {+ applyTags(r, reuse, subnet.getSubnetId(), reuse ? existing.getTags() : List.of(), props, ctx);+ if (mapPublicIpOnLaunch != null) {+ if (reuse && ctx.isUpdate() && existing.isMapPublicIpOnLaunch() != Boolean.parseBoolean(mapPublicIpOnLaunch)) {+ ObjectNode prior = inPlacePrior(r, subnet.getSubnetId(), ctx);+ prior.put("mapPublicIpOnLaunch", String.valueOf(existing.isMapPublicIpOnLaunch()));+ writeInPlacePrior(r, prior);+ }+ ec2Service.modifySubnetAttribute(ctx.region(), subnet.getSubnetId(), "mapPublicIpOnLaunch", mapPublicIpOnLaunch);+ }+ });+ }++ /**+ * Runs the steps that follow an EC2 create or change a reused entity in place. If one of them+ * throws, what this provision did is undone before the failure propagates: a created entity is+ * deleted again, a reused one is put back from its snapshot. The engine only removes a failed+ * create it can see, and on a failed update it restores the previous resource metadata and+ * discards the attempted one, snapshot included, so the undo has to happen here.+ *+ * <p>A compensation that fails is reported, never hidden. A created entity carries+ * {@link CfnRollback#ROLLBACK_OWNED_ATTR} while the steps run, so the engine's create rollback+ * deletes it (and reports that failing) if the undo here could not, and during an update the+ * entity is also listed in the cleanup record, which the engine carries onto the restored+ * resource and runs before the next committed update or the stack delete; a reused entity keeps its+ * snapshot and the reason lands in {@link CfnRollback#UPDATE_ROLLBACK_FAILURE_ATTR}, which the+ * engine copies onto the committed resource so the rollback walker reports+ * UPDATE_ROLLBACK_FAILED instead of claiming the prior state is live.+ */+ private void guarded(StackResource r, ProvisionContext ctx, boolean created, Runnable undoCreate, Runnable steps) {+ if (created) {+ r.getAttributes().put(CfnRollback.ROLLBACK_OWNED_ATTR, "true");+ }+ try {+ steps.run();+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ } catch (RuntimeException e) {+ if (created) {+ try {+ undoCreate.run();+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ } catch (RuntimeException undo) {+ e.addSuppressed(undo);+ String reason = "Could not remove " + r.getPhysicalId() + ", created for " + r.getLogicalId()+ + " by a failed update: " + undo.getMessage();+ LOG.warn(reason);+ r.getAttributes().put(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR, reason);+ if (ctx.isUpdate()) {+ // The engine restores the previous resource and keeps only what the cleanup+ // record carries, so the replacement is listed there for the next cleanup.+ ReplacementCleanup.recordOrphan(r, r.getPhysicalId(), r.getResourceType(), ctx.region());+ }+ }+ } else {+ String snapshot = r.getAttributes().get(IN_PLACE_PRIOR_ATTR);+ if (snapshot != null) {+ try {+ restoreInPlace(r, snapshot);+ r.getAttributes().remove(IN_PLACE_PRIOR_ATTR);+ } catch (RuntimeException undo) {+ e.addSuppressed(undo);+ String reason = "Could not restore " + r.getPhysicalId() + " for " + r.getLogicalId()+ + " after a failed update: " + undo.getMessage();+ LOG.warn(reason);+ r.getAttributes().put(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR, reason);+ }+ }+ }+ throw e;+ }+ }++ private void provisionInternetGateway(StackResource r, JsonNode props, ProvisionContext ctx) {+ InternetGateway existing = ctx.isUpdate() ? findInternetGateway(ctx.priorPhysicalId(), ctx.region()) : null;+ InternetGateway igw = existing != null ? existing : ec2Service.createInternetGateway(ctx.region());+ r.setPhysicalId(igw.getInternetGatewayId());+ r.getAttributes().put("InternetGatewayId", igw.getInternetGatewayId());+ guarded(r, ctx, existing == null, () -> ec2Service.deleteInternetGateway(ctx.region(), igw.getInternetGatewayId()),+ () -> applyTags(r, existing != null, igw.getInternetGatewayId(), existing != null ? existing.getTags() : List.of(), props, ctx));+ }++ private void provisionRouteTable(StackResource r, JsonNode props, ProvisionContext ctx) {+ String vpcId = ctx.resolveOptional(props, "VpcId");+ require(ROUTE_TABLE, "VpcId", vpcId);+ // VpcId is createOnly: a table in the same VPC is kept, one in another VPC is replaced.+ RouteTable existing = ctx.isUpdate() ? findRouteTable(ctx.priorPhysicalId(), ctx.region()) : null;+ boolean reuse = existing != null && Objects.equals(vpcId, existing.getVpcId());+ RouteTable rt = reuse ? existing : ec2Service.createRouteTable(ctx.region(), vpcId);+ r.setPhysicalId(rt.getRouteTableId());+ r.getAttributes().put("RouteTableId", rt.getRouteTableId());+ guarded(r, ctx, !reuse, () -> ec2Service.deleteRouteTable(ctx.region(), rt.getRouteTableId()),+ () -> applyTags(r, reuse, rt.getRouteTableId(), reuse ? existing.getTags() : List.of(), props, ctx));+ }++ private void provisionSubnetRouteTableAssociation(StackResource r, JsonNode props, ProvisionContext ctx) {+ String routeTableId = ctx.resolveOptional(props, "RouteTableId");+ String subnetId = ctx.resolveOptional(props, "SubnetId");+ require(SUBNET_ROUTE_TABLE_ASSOCIATION, "RouteTableId", routeTableId);+ require(SUBNET_ROUTE_TABLE_ASSOCIATION, "SubnetId", subnetId);+ // Both properties are createOnly: the same pair keeps the association, anything else is a+ // new association and the prior one is removed once the update commits.+ RouteTableAssociation existing = ctx.isUpdate() ? findAssociation(ctx.priorPhysicalId(), ctx.region()) : null;+ RouteTableAssociation assoc = existing != null && Objects.equals(routeTableId, existing.getRouteTableId())+ && Objects.equals(subnetId, existing.getSubnetId())+ ? existing : ec2Service.associateRouteTable(ctx.region(), routeTableId, subnetId);+ r.setPhysicalId(assoc.getRouteTableAssociationId());+ r.getAttributes().put("Id", assoc.getRouteTableAssociationId());+ }++ private void provisionRoute(StackResource r, JsonNode props, ProvisionContext ctx) {+ String routeTableId = ctx.resolveOptional(props, "RouteTableId");+ String destinationCidr = ctx.resolveOptional(props, "DestinationCidrBlock");+ String destinationIpv6Cidr = ctx.resolveOptional(props, "DestinationIpv6CidrBlock");+ String destinationPrefixListId = ctx.resolveOptional(props, "DestinationPrefixListId");+ String gatewayId = ctx.resolveOptional(props, "GatewayId");+ String natGatewayId = ctx.resolveOptional(props, "NatGatewayId");+ String egressOnlyInternetGatewayId = ctx.resolveOptional(props, "EgressOnlyInternetGatewayId");+ String vpcPeeringConnectionId = ctx.resolveOptional(props, "VpcPeeringConnectionId");+ require(ROUTE, "RouteTableId", routeTableId);+ long destinations = java.util.stream.Stream.of(destinationCidr, destinationIpv6Cidr, destinationPrefixListId)+ .filter(value -> value != null && !value.isBlank()).count();+ if (destinations != 1) {+ throw new AwsException("ValidationError", ROUTE + " requires exactly one of DestinationCidrBlock,"+ + " DestinationIpv6CidrBlock or DestinationPrefixListId", 400);+ }+ // The registry primary identifier is RouteTableId|CidrBlock, which is also what Ref returns+ // on AWS, and the only id a later delete can act on. CidrBlock is the schema's read-only+ // attribute: the destination the route was created with, whichever property carried it.+ // Ec2Service stores an IPv4 destination in canonical form (10.0.0.18/24 is 10.0.0.0/24), so+ // the id, the attribute and the reuse check use that form too, or an unchanged update+ // would miss its own route and try to create it again.+ String canonicalCidr = destinationCidr == null ? null+ : CidrCanonicalizer.canonicalize(destinationCidr).orElse(destinationCidr);+ String destination = canonicalCidr != null ? canonicalCidr+ : destinationIpv6Cidr != null ? destinationIpv6Cidr : destinationPrefixListId;+ String physicalId = routeTableId + ROUTE_ID_SEPARATOR + destination;+ Supplier<Void> create = () -> {+ ec2Service.createRoute(ctx.region(), routeTableId, destinationCidr, destinationIpv6Cidr,+ destinationPrefixListId, gatewayId, natGatewayId, egressOnlyInternetGatewayId,+ vpcPeeringConnectionId);+ return null;+ };+ // The table and destination are createOnly: the same pair changes the target in place,+ // another pair is a new route and the prior one goes once the update commits.+ Route current = ctx.isUpdate() && physicalId.equals(ctx.priorPhysicalId())+ ? findRoute(routeTableId, destination, ctx.region()) : null;+ if (current != null) {+ ObjectNode prior = inPlacePrior(r, physicalId, ctx);+ ObjectNode target = prior.putObject("route");+ target.put("routeTableId", routeTableId);+ target.put("destinationCidrBlock", current.getDestinationCidrBlock());+ target.put("destinationIpv6CidrBlock", current.getDestinationIpv6CidrBlock());+ target.put("destinationPrefixListId", current.getDestinationPrefixListId());+ target.put("gatewayId", current.getGatewayId());+ target.put("natGatewayId", current.getNatGatewayId());+ target.put("egressOnlyInternetGatewayId", current.getEgressOnlyInternetGatewayId());+ target.put("vpcPeeringConnectionId", current.getVpcPeeringConnectionId());+ writeInPlacePrior(r, prior);+ guarded(r, ctx, false, () -> { }, () -> {+ if (egressOnlyInternetGatewayId != null) {+ // ReplaceRoute has no egress-only target; re-creating the route is the same outcome.+ ec2Service.deleteRoute(ctx.region(), routeTableId, destinationCidr, destinationIpv6Cidr, destinationPrefixListId);+ create.get();+ } else {+ ec2Service.replaceRoute(ctx.region(), routeTableId, destinationCidr, destinationIpv6Cidr,+ destinationPrefixListId, gatewayId, natGatewayId, vpcPeeringConnectionId);+ }+ });+ } else {+ create.get();+ }+ r.setPhysicalId(physicalId);+ if (destination != null) {+ r.getAttributes().put("CidrBlock", destination);+ }+ }++ private void provisionNatGateway(StackResource r, JsonNode props, ProvisionContext ctx) {+ String subnetId = ctx.resolveOptional(props, "SubnetId");+ String allocationId = ctx.resolveOptional(props, "AllocationId");+ require(NAT_GATEWAY, "SubnetId", subnetId);+ // ConnectivityType defaults to public in the schema; a public gateway needs an EIP, a+ // private one must not have one, as AWS validates.+ String connectivityType = ctx.resolveOptional(props, "ConnectivityType");+ connectivityType = connectivityType == null || connectivityType.isBlank() ? "public" : connectivityType.toLowerCase();+ if ("public".equals(connectivityType) && (allocationId == null || allocationId.isBlank())) {+ throw new AwsException("ValidationError", "AWS::EC2::NatGateway requires AllocationId for a public gateway", 400);+ }+ if ("private".equals(connectivityType) && allocationId != null && !allocationId.isBlank()) {+ throw new AwsException("ValidationError", "AWS::EC2::NatGateway with ConnectivityType private cannot have an AllocationId", 400);+ }+ // SubnetId, AllocationId and ConnectivityType are createOnly: the same triple keeps the+ // gateway, a change replaces it.+ NatGateway existing = ctx.isUpdate() ? findNatGateway(ctx.priorPhysicalId(), ctx.region()) : null;+ boolean reuse = existing != null && Objects.equals(subnetId, existing.getSubnetId())+ && Objects.equals(allocationId, existing.getAllocationId())+ && connectivityType.equalsIgnoreCase(existing.getConnectivityType() == null ? "public" : existing.getConnectivityType());+ NatGateway nat = reuse ? existing+ : ec2Service.createNatGateway(ctx.region(), subnetId, allocationId, connectivityType, tagList(props, ctx));+ if (reuse) {+ guarded(r, ctx, false, () -> { }, () -> applyTags(r, true, nat.getNatGatewayId(), existing.getTags(), props, ctx));+ }+ r.setPhysicalId(nat.getNatGatewayId());+ r.getAttributes().put("NatGatewayId", nat.getNatGatewayId());+ }++ private void provisionEip(StackResource r, JsonNode props, ProvisionContext ctx) {+ // Nothing about an EIP that Floci emulates is mutable or create-only in a way a template can+ // change, so an address that is still allocated is simply kept.+ Address existing = ctx.isUpdate() ? findAddress(r.getAttributes().get("AllocationId"), ctx.priorPhysicalId(), ctx.region()) : null;+ Address addr = existing != null ? existing : ec2Service.allocateAddress(ctx.region());+ // Ref on AWS::EC2::EIP returns the public IP; AllocationId is exposed via Fn::GetAtt.+ r.setPhysicalId(addr.getPublicIp());+ r.getAttributes().put("AllocationId", addr.getAllocationId());+ r.getAttributes().put("PublicIp", addr.getPublicIp());+ guarded(r, ctx, existing == null, () -> ec2Service.releaseAddress(ctx.region(), addr.getAllocationId()),+ () -> applyTags(r, existing != null, addr.getAllocationId(), existing != null ? existing.getTags() : List.of(), props, ctx));+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanup.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanup.javaindex 8b1258c529..9ab3340944 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanup.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanup.java@@ -30,7 +30,7 @@ import java.util.Map;* A provisioner calls {@link #record} at the end of a successful {@code provision} and delegates* the cleanup hooks and {@link #rollback} here.*/-final class ReplacementCleanup {+public final class ReplacementCleanup {private static final Logger LOG = Logger.getLogger(ReplacementCleanup.class);private static final ObjectMapper MAPPER = new ObjectMapper();@@ -239,6 +239,55 @@ final class ReplacementCleanup {return displaced.isEmpty() ? null : displaced.get(0).path("physicalId").asText(null);}+ /**+ * Lists an entity this provision created and could not remove after a later step failed, so+ * the next committed update or the stack delete removes it instead of nothing ever trying+ * again. Never retainable: a failed update created it.+ */+ static void recordOrphan(StackResource r, String physicalId, String resourceType, String region) {+ ObjectNode cleanup = readOrEmpty(r);+ if (region != null) {+ cleanup.put("region", region);+ }+ addDisplaced(cleanup, physicalId, resourceType, region, false);+ write(r, cleanup);+ }++ /**+ * Carries the entities {@code from} owes a delete onto {@code into}, keeping their attempt+ * counts and regions and skipping ids {@code into} already lists or owns. The engine calls this+ * through {@code mergeFailedUpdateResourceTracking} when it restores the previous resource+ * after a failed update, so an orphan the attempt recorded is not lost with the attempt.+ */+ public static void mergeDisplaced(StackResource into, StackResource from) {+ ObjectNode source = read(from);+ if (source == null || source.path("displaced").size() == 0) {+ return;+ }+ ObjectNode target = readOrEmpty(into);+ if (target.path("region").asText(null) == null && source.path("region").asText(null) != null) {+ target.put("region", source.path("region").asText());+ }+ ArrayNode displaced = target.withArray("displaced");+ for (JsonNode entry : source.path("displaced")) {+ String physicalId = entry.path("physicalId").asText(null);+ if (physicalId == null || physicalId.equals(into.getPhysicalId())) {+ continue;+ }+ boolean present = false;+ for (JsonNode existing : displaced) {+ if (physicalId.equals(existing.path("physicalId").asText(null))) {+ present = true;+ break;+ }+ }+ if (!present) {+ displaced.add(entry.deepCopy());+ }+ }+ write(into, target);+ }+private static void addDisplaced(ObjectNode cleanup, String physicalId, String resourceType, String region,boolean retainable) {ArrayNode displaced = cleanup.withArray("displaced");diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.javaindex 0d01ab1fe3..e4f427a107 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/ApiGatewayV2CfnProvisionerTest.java@@ -17,6 +17,7 @@ import java.util.concurrent.atomic.AtomicInteger;import java.util.function.Function;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.anyMap;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.argThat;@@ -169,6 +170,28 @@ class ApiGatewayV2CfnProvisionerTest {previous.getAttributes().get("__FlociApiGatewayV2BodyAuthorizerIds"));}+ @Test+ void carriesAReplacementCleanupRecordOntoTheRestoredResourceForAnyType() {+ StackResource previous = new StackResource();+ previous.setLogicalId("Subnet");+ previous.setResourceType("AWS::EC2::Subnet");+ previous.setPhysicalId("subnet-prior");+ previous.setAttributes(new java.util.HashMap<>());+ StackResource attempted = new StackResource();+ attempted.setLogicalId("Subnet");+ attempted.setResourceType("AWS::EC2::Subnet");+ attempted.setPhysicalId("subnet-replacement");+ attempted.setAttributes(new java.util.HashMap<>(Map.of(+ "__FlociReplacementCleanup",+ "{\"region\":\"us-east-1\",\"displaced\":[{\"physicalId\":\"subnet-replacement\",\"resourceType\":\"AWS::EC2::Subnet\",\"region\":\"us-east-1\",\"retainable\":false,\"cleanupAttempts\":1}]}")));++ provisioner.mergeFailedUpdateResourceTracking(previous, attempted);++ String record = previous.getAttributes().get("__FlociReplacementCleanup");+ assertTrue(record != null && record.contains("subnet-replacement") && record.contains("\"cleanupAttempts\":1"),+ "the orphan the attempt could not remove is owed on the restored resource: " + record);+ }+@Testvoid materializesInheritedJwtSecurityAndHonorsOperationOptOut() throws Exception {Authorizer authorizer = new Authorizer();diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.javaindex fdbc9c7001..7a20f61490 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java@@ -34,6 +34,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.CdkMetadaimport io.github.hectorvent.floci.services.cloudformation.provisioners.CloudWatchCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.CognitoCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2LaunchTemplateCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2NetworkCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2NetworkAclCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2SecurityGroupRuleCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2VpcCfnProvisioner;@@ -302,6 +303,7 @@ final class CfnProvisionerFixture {discovered.add(new Ec2NetworkAclCfnProvisioner(ec2Service));discovered.add(new Ec2SecurityGroupRuleCfnProvisioner(ec2Service));discovered.add(new Ec2LaunchTemplateCfnProvisioner(ec2Service));+ discovered.add(new Ec2NetworkCfnProvisioner(ec2Service));}if (route53Service != null) {discovered.add(new Route53CfnProvisioner(route53Service));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.javanew file mode 100644index 0000000000..96262fae6f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEc2NetworkingIntegrationTest.java@@ -0,0 +1,291 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.core.common.XmlParser;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assertions.fail;++/**+ * A public/private networking stack the way CDK lays one out: internet gateway and attachment,+ * a public subnet with a route table routing {@code 0.0.0.0/0} to the gateway and an association, an+ * EIP and a NAT gateway in that subnet, and a private route table routing to the NAT. Asserts the+ * {@code Ref} shapes ({@code Route} is {@code <RouteTableId>|<destination>}, {@code EIP} the public IP)+ * and the {@code Fn::GetAtt} attributes, that an {@code UpdateStack} with the same template keeps+ * every id (the legacy switch re-created all of them), that a changed subnet CIDR replaces the subnet+ * and the NAT gateway inside it and removes the displaced ones, and that {@code DeleteStack} removes+ * every one of the seven networking resources, which the legacy switch left behind. A second case+ * changes a route table's tag and a subnet's MapPublicIpOnLaunch in place next to a resource that+ * fails, and asserts the rollback puts both back. The VPC is+ * created through the EC2 API and passed in as a literal: {@code Ec2VpcCfnProvisioner} still+ * re-creates a VPC on every update (the #3033 fix), which would rightly replace everything in it.+ */+@QuarkusTest+class CloudFormationEc2NetworkingIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260907/us-east-1/cloudformation/aws4_request";+ private static final String EC2_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260907/us-east-1/ec2/aws4_request";+ private static final String STACK = "ec2-networking-it";++ private static String template(String vpcId, String publicSubnetCidr) {+ return template(vpcId, publicSubnetCidr, "{\"Key\": \"tier\", \"Value\": \"web\"}");+ }++ private static final String ROLLBACK_STACK = "ec2-networking-rollback-it";++ /** A subnet and a tagged route table; the second form flips the mutable properties and adds a resource that cannot be created. */+ private static String rollbackTemplate(String vpcId, boolean changed) {+ String failing = changed+ ? ",\n \"Boom\": {\"Type\": \"AWS::SecretsManager::Secret\","+ + " \"Properties\": {\"SecretString\": \"x\", \"GenerateSecretString\": {\"SecretStringTemplate\": \"{}\", \"GenerateStringKey\": \"p\"}}}"+ : "";+ return """+ {+ "Resources": {+ "Subnet": {"Type": "AWS::EC2::Subnet",+ "Properties": {"VpcId": "%1$s", "CidrBlock": "10.41.0.0/24", "MapPublicIpOnLaunch": %2$s}},+ "Rt": {"Type": "AWS::EC2::RouteTable",+ "Properties": {"VpcId": "%1$s", "Tags": [{"Key": "Name", "Value": "%3$s"}]}}%4$s+ },+ "Outputs": {"SubnetId": {"Value": {"Ref": "Subnet"}}, "RtId": {"Value": {"Ref": "Rt"}}}+ }+ """.formatted(vpcId, changed ? "false" : "true", changed ? "after" : "before", failing);+ }++ @Test+ void anInPlaceChangeNextToAFailingResourceIsRolledBack() throws Exception {+ String vpcId = between(ec2("CreateVpc", Map.of("CidrBlock", "10.41.0.0/16")), "<vpcId>", "</vpcId>");+ cloudFormation(ROLLBACK_STACK, "CreateStack", rollbackTemplate(vpcId, false));+ Map<String, String> out = XmlParser.extractPairs(describeStacks(ROLLBACK_STACK, "CREATE_COMPLETE"), "Outputs", "OutputKey", "OutputValue");+ assertTrue(ec2("DescribeRouteTables").contains("<value>before</value>"));+ assertTrue(subnetXml(out.get("SubnetId")).contains("<mapPublicIpOnLaunch>true</mapPublicIpOnLaunch>"));++ cloudFormation(ROLLBACK_STACK, "UpdateStack", rollbackTemplate(vpcId, true));++ describeStacks(ROLLBACK_STACK, "UPDATE_ROLLBACK_COMPLETE");+ String routeTables = ec2("DescribeRouteTables");+ assertTrue(routeTables.contains("<value>before</value>") && !routeTables.contains("<value>after</value>"),+ "the route table's prior tag must be back: " + routeTables);+ assertTrue(subnetXml(out.get("SubnetId")).contains("<mapPublicIpOnLaunch>true</mapPublicIpOnLaunch>"),+ "the subnet's prior MapPublicIpOnLaunch must be back");++ cloudFormation(ROLLBACK_STACK, "DeleteStack", null);+ awaitStackDeleted(ROLLBACK_STACK);+ ec2("DeleteVpc", Map.of("VpcId", vpcId));+ }++ private static String subnetXml(String subnetId) {+ return ec2("DescribeSubnets", Map.of("SubnetId.1", subnetId));+ }++ private static String template(String vpcId, String publicSubnetCidr, String extraSubnetTag) {+ return """+ {+ "Resources": {+ "Igw": {"Type": "AWS::EC2::InternetGateway"},+ "Attach": {"Type": "AWS::EC2::VPCGatewayAttachment",+ "Properties": {"VpcId": "%1$s", "InternetGatewayId": {"Ref": "Igw"}}},+ "PublicSubnet": {"Type": "AWS::EC2::Subnet",+ "Properties": {"VpcId": "%1$s", "CidrBlock": "%2$s",+ "AvailabilityZone": "us-east-1a", "MapPublicIpOnLaunch": true,+ "Tags": [{"Key": "Name", "Value": "public"}, %3$s]}},+ "PublicRt": {"Type": "AWS::EC2::RouteTable",+ "Properties": {"VpcId": "%1$s", "Tags": [{"Key": "Name", "Value": "public-rt"}]}},+ "PublicRoute": {"Type": "AWS::EC2::Route", "DependsOn": "Attach",+ "Properties": {"RouteTableId": {"Ref": "PublicRt"}, "DestinationCidrBlock": "0.0.0.0/0",+ "GatewayId": {"Ref": "Igw"}}},+ "PeerRoute": {"Type": "AWS::EC2::Route",+ "Properties": {"RouteTableId": {"Ref": "PublicRt"}, "DestinationCidrBlock": "10.99.0.18/24",+ "GatewayId": {"Ref": "Igw"}}},+ "PublicAssoc": {"Type": "AWS::EC2::SubnetRouteTableAssociation",+ "Properties": {"RouteTableId": {"Ref": "PublicRt"}, "SubnetId": {"Ref": "PublicSubnet"}}},+ "NatEip": {"Type": "AWS::EC2::EIP", "Properties": {"Domain": "vpc"}},+ "Nat": {"Type": "AWS::EC2::NatGateway",+ "Properties": {"SubnetId": {"Ref": "PublicSubnet"}, "AllocationId": {"Fn::GetAtt": ["NatEip", "AllocationId"]}}},+ "PrivateRt": {"Type": "AWS::EC2::RouteTable", "Properties": {"VpcId": "%1$s"}},+ "PrivateRoute": {"Type": "AWS::EC2::Route",+ "Properties": {"RouteTableId": {"Ref": "PrivateRt"}, "DestinationCidrBlock": "0.0.0.0/0",+ "NatGatewayId": {"Ref": "Nat"}}}+ },+ "Outputs": {+ "SubnetId": {"Value": {"Ref": "PublicSubnet"}},+ "SubnetAz": {"Value": {"Fn::GetAtt": ["PublicSubnet", "AvailabilityZone"]}},+ "IgwId": {"Value": {"Ref": "Igw"}},+ "PublicRtId": {"Value": {"Ref": "PublicRt"}},+ "PrivateRtId": {"Value": {"Ref": "PrivateRt"}},+ "PublicRouteRef": {"Value": {"Ref": "PublicRoute"}},+ "PublicRouteCidr": {"Value": {"Fn::GetAtt": ["PublicRoute", "CidrBlock"]}},+ "PeerRouteRef": {"Value": {"Ref": "PeerRoute"}},+ "AssocId": {"Value": {"Ref": "PublicAssoc"}},+ "EipRef": {"Value": {"Ref": "NatEip"}},+ "EipAllocationId": {"Value": {"Fn::GetAtt": ["NatEip", "AllocationId"]}},+ "NatId": {"Value": {"Ref": "Nat"}}+ }+ }+ """.formatted(vpcId, publicSubnetCidr, extraSubnetTag);+ }++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void networkingStackExposesTheAwsRefShapesAndDeletesEverythingItCreated() throws Exception {+ String vpcId = between(ec2("CreateVpc", Map.of("CidrBlock", "10.40.0.0/16")), "<vpcId>", "</vpcId>");+ cloudFormation("CreateStack", template(vpcId, "10.40.0.0/24"));++ String stacks = describeStacks("CREATE_COMPLETE");+ Map<String, String> out = XmlParser.extractPairs(stacks, "Outputs", "OutputKey", "OutputValue");+ assertTrue(out.get("SubnetId").startsWith("subnet-"), out.get("SubnetId"));+ assertEquals("us-east-1a", out.get("SubnetAz"));+ assertTrue(out.get("IgwId").startsWith("igw-"), out.get("IgwId"));+ assertTrue(out.get("PublicRtId").startsWith("rtb-"), out.get("PublicRtId"));+ assertEquals(out.get("PublicRtId") + "|0.0.0.0/0", out.get("PublicRouteRef"),+ "Ref of a Route is the registry primary identifier, table id and destination");+ assertEquals("0.0.0.0/0", out.get("PublicRouteCidr"));+ assertEquals(out.get("PublicRtId") + "|10.99.0.0/24", out.get("PeerRouteRef"),+ "a non-canonical destination is keyed by the canonical CIDR the service stores");+ assertTrue(out.get("AssocId").startsWith("rtbassoc-"), out.get("AssocId"));+ assertTrue(out.get("EipAllocationId").startsWith("eipalloc-"), out.get("EipAllocationId"));+ assertFalse(out.get("EipRef").startsWith("eipalloc-"), "Ref of an EIP is its public IP: " + out.get("EipRef"));+ assertTrue(out.get("NatId").startsWith("nat-"), out.get("NatId"));++ String subnets = ec2("DescribeSubnets");+ assertTrue(subnets.contains(out.get("SubnetId")));+ assertTrue(subnets.contains("<key>tier</key>") && subnets.contains("<value>web</value>"), "subnet tags must reach EC2: " + subnets);+ String routeTables = ec2("DescribeRouteTables");+ assertTrue(routeTables.contains("<value>public-rt</value>"), "route table tags must reach EC2");+ assertTrue(routeTables.contains(out.get("PublicRtId")) && routeTables.contains(out.get("AssocId")));+ assertTrue(routeTables.contains(out.get("NatId")), "the private route must point at the NAT gateway");+ assertTrue(ec2("DescribeNatGateways").contains(out.get("NatId")));+ assertTrue(ec2("DescribeAddresses").contains(out.get("EipAllocationId")));+ assertTrue(ec2("DescribeInternetGateways").contains(out.get("IgwId")));++ // The same template again: every id survives (the switch re-created all seven).+ cloudFormation("UpdateStack", template(vpcId, "10.40.0.0/24"));+ Map<String, String> again = XmlParser.extractPairs(describeStacks("UPDATE_COMPLETE"), "Outputs", "OutputKey", "OutputValue");+ assertEquals(out, again, "an unchanged update must keep every networking resource");++ // Tags are mutable: a dropped key goes, a changed value is written, the subnet stays.+ cloudFormation("UpdateStack", template(vpcId, "10.40.0.0/24", "{\"Key\": \"env\", \"Value\": \"test\"}"));+ assertEquals(out.get("SubnetId"), XmlParser.extractPairs(describeStacks("UPDATE_COMPLETE"), "Outputs", "OutputKey", "OutputValue").get("SubnetId"));+ String retagged = ec2("DescribeSubnets");+ assertTrue(retagged.contains("<key>env</key>"), "the new tag must be written");+ 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"));+ 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"));+ 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");+ assertFalse(ec2("DescribeNatGateways").contains(out.get("NatId")), "the displaced NAT gateway must be gone");+ assertTrue(ec2("DescribeSubnets").contains(replaced.get("SubnetId")));+ out = replaced;++ cloudFormation("DeleteStack", null);+ awaitStackDeleted();++ 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"))) {+ String everything = ec2("DescribeSubnets") + ec2("DescribeRouteTables") + ec2("DescribeNatGateways")+ + ec2("DescribeAddresses") + ec2("DescribeInternetGateways");+ assertFalse(everything.contains(id), "stack delete must remove " + id);+ }+ ec2("DeleteVpc", Map.of("VpcId", vpcId));+ }++ private static String between(String haystack, String open, String close) {+ int start = haystack.indexOf(open);+ int end = haystack.indexOf(close, start);+ assertTrue(start >= 0 && end > start, "missing " + open + " in " + haystack);+ return haystack.substring(start + open.length(), end);+ }++ private static void cloudFormation(String action, String templateBody) {+ cloudFormation(STACK, action, templateBody);+ }++ private static void cloudFormation(String stack, String action, String templateBody) {+ var request = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", action)+ .formParam("StackName", stack);+ if (templateBody != null) {+ request.formParam("TemplateBody", templateBody);+ }+ request.when().post("/").then().statusCode(200);+ }++ private static String describeStacks(String expectedStatus) {+ return describeStacks(STACK, expectedStatus);+ }++ private static String describeStacks(String stack, String expectedStatus) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stack)+ .when().post("/").then().statusCode(200)+ .body(containsString("<StackStatus>" + expectedStatus + "</StackStatus>"))+ .extract().asString();+ }++ private static void awaitStackDeleted() throws InterruptedException {+ awaitStackDeleted(STACK);+ }++ private static void awaitStackDeleted(String stack) throws InterruptedException {+ for (int i = 0; i < 200; i++) {+ String body = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stack)+ .when().post("/").then().extract().asString();+ if (body.contains("does not exist")) {+ return;+ }+ if (body.contains("<StackStatus>DELETE_FAILED</StackStatus>")) {+ fail("stack delete failed: " + body);+ }+ Thread.sleep(50);+ }+ fail("stack " + stack + " was not deleted within the timeout");+ }++ private static String ec2(String action) {+ return ec2(action, Map.of());+ }++ private static String ec2(String action, Map<String, String> params) {+ var request = given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", EC2_AUTH)+ .formParam("Action", action)+ .formParam("Version", "2016-11-15");+ params.forEach(request::formParam);+ return request.when().post("/").then().statusCode(200).extract().asString();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisionerTest.javanew file mode 100644index 0000000000..f2c60997c1--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2NetworkCfnProvisionerTest.java@@ -0,0 +1,935 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Address;+import io.github.hectorvent.floci.services.ec2.model.InternetGateway;+import io.github.hectorvent.floci.services.ec2.model.NatGateway;+import io.github.hectorvent.floci.services.ec2.model.Route;+import io.github.hectorvent.floci.services.ec2.model.RouteTable;+import io.github.hectorvent.floci.services.ec2.model.RouteTableAssociation;+import io.github.hectorvent.floci.services.ec2.model.Subnet;+import io.github.hectorvent.floci.services.ec2.model.Tag;+import org.mockito.ArgumentCaptor;+import org.junit.jupiter.api.Test;++import java.util.HashMap;+import java.util.List;+import java.util.Set;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.ArgumentMatchers.isNull;+import io.github.hectorvent.floci.core.common.AwsException;+import java.util.Map;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * The EC2 networking provisioner in isolation: one mocked service. Every case asserts the exact+ * physical id and the exact {@code Fn::GetAtt} attribute keys, since an unmapped type still reports+ * CREATE_COMPLETE through the dispatcher's stub arm.+ */+class Ec2NetworkCfnProvisionerTest {++ private static final String REGION = "us-east-1";+ private static final String VPC_ID = "vpc-0123456789abcdef0";+ private static final String SUBNET_ID = "subnet-0123456789abcdef0";+ private static final String RTB_ID = "rtb-0123456789abcdef0";+ private static final String IGW_ID = "igw-0123456789abcdef0";+ private static final String NAT_ID = "nat-0123456789abcdef0";+ private static final String ASSOC_ID = "rtbassoc-0123456789abcdef0";+ private static final String ALLOC_ID = "eipalloc-0123456789abcdef0";+ private static final String PUBLIC_IP = "54.0.0.1";++ private final Ec2Service ec2 = mock(Ec2Service.class);+ private final Ec2NetworkCfnProvisioner provisioner = new Ec2NetworkCfnProvisioner(ec2);+ private final ObjectMapper mapper = new ObjectMapper();++ private ProvisionContext ctx() {+ return ctx(null);+ }++ private ProvisionContext ctx(String priorPhysicalId) {+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);+ when(engine.resolve(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node == null || node.isMissingNode() || node.isNull() ? null : node.asText();+ });+ when(engine.resolveNode(any())).thenAnswer(inv -> inv.getArgument(0));+ when(engine.resolveStringList(any())).thenCallRealMethod();+ return new ProvisionContext(engine, REGION, "000000000000", "my-stack", priorPhysicalId);+ }++ private static StackResource resource(String type, String logicalId) {+ StackResource r = new StackResource();+ r.setLogicalId(logicalId);+ r.setResourceType(type);+ r.setAttributes(new HashMap<>());+ return r;+ }++ private static Subnet subnet() {+ Subnet s = new Subnet();+ s.setSubnetId(SUBNET_ID);+ s.setVpcId(VPC_ID);+ s.setCidrBlock("10.0.1.0/24");+ s.setAvailabilityZone("us-east-1a");+ return s;+ }++ @Test+ void subnetSetsItsIdAndTheThreeAttributesAndAppliesMapPublicIpOnLaunch() {+ when(ec2.createSubnet(REGION, VPC_ID, "10.0.1.0/24", "us-east-1a")).thenReturn(subnet());+ ObjectNode props = mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24")+ .put("AvailabilityZone", "us-east-1a").put("MapPublicIpOnLaunch", true);+ StackResource r = resource("AWS::EC2::Subnet", "Subnet");++ provisioner.provision(r, props, ctx());++ assertEquals(SUBNET_ID, r.getPhysicalId());+ assertEquals(Set.of("SubnetId", "VpcId", "AvailabilityZone"), r.getAttributes().keySet());+ assertEquals("us-east-1a", r.getAttributes().get("AvailabilityZone"));+ verify(ec2).modifySubnetAttribute(REGION, SUBNET_ID, "mapPublicIpOnLaunch", "true");+ }++ @Test+ void subnetWithoutMapPublicIpOnLaunchLeavesTheAttributeAlone() {+ when(ec2.createSubnet(eq(REGION), eq(VPC_ID), eq("10.0.1.0/24"), isNull())).thenReturn(subnet());++ provisioner.provision(resource("AWS::EC2::Subnet", "Subnet"),+ mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), ctx());++ verify(ec2, never()).modifySubnetAttribute(any(), any(), any(), any());+ }++ @Test+ void internetGatewaySetsItsIdAttribute() {+ InternetGateway igw = new InternetGateway();+ igw.setInternetGatewayId(IGW_ID);+ when(ec2.createInternetGateway(REGION)).thenReturn(igw);+ StackResource r = resource("AWS::EC2::InternetGateway", "Igw");++ provisioner.provision(r, mapper.createObjectNode(), ctx());++ assertEquals(IGW_ID, r.getPhysicalId());+ assertEquals(Set.of("InternetGatewayId"), r.getAttributes().keySet());+ }++ @Test+ void routeTableSetsItsIdAttribute() {+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ when(ec2.createRouteTable(REGION, VPC_ID)).thenReturn(rt);+ StackResource r = resource("AWS::EC2::RouteTable", "Rtb");++ provisioner.provision(r, mapper.createObjectNode().put("VpcId", VPC_ID), ctx());++ assertEquals(RTB_ID, r.getPhysicalId());+ assertEquals(Set.of("RouteTableId"), r.getAttributes().keySet());+ }++ @Test+ void associationSetsTheSchemasIdAttribute() {+ RouteTableAssociation assoc = new RouteTableAssociation();+ assoc.setRouteTableAssociationId(ASSOC_ID);+ when(ec2.associateRouteTable(REGION, RTB_ID, SUBNET_ID)).thenReturn(assoc);+ StackResource r = resource("AWS::EC2::SubnetRouteTableAssociation", "Assoc");++ provisioner.provision(r, mapper.createObjectNode().put("RouteTableId", RTB_ID).put("SubnetId", SUBNET_ID), ctx());++ assertEquals(ASSOC_ID, r.getPhysicalId());+ assertEquals(Set.of("Id"), r.getAttributes().keySet());+ }++ @Test+ void routePassesEveryTargetAndExposesTheDestinationAsCidrBlock() {+ StackResource r = resource("AWS::EC2::Route", "Default");+ ObjectNode props = mapper.createObjectNode().put("RouteTableId", RTB_ID)+ .put("DestinationCidrBlock", "0.0.0.0/0").put("GatewayId", IGW_ID);++ provisioner.provision(r, props, ctx());++ verify(ec2).createRoute(REGION, RTB_ID, "0.0.0.0/0", null, null, IGW_ID, null, null, null);+ assertEquals(RTB_ID + "|0.0.0.0/0", r.getPhysicalId(), "Ref is the registry primary identifier");+ assertEquals(Set.of("CidrBlock"), r.getAttributes().keySet());+ assertEquals("0.0.0.0/0", r.getAttributes().get("CidrBlock"));+ }++ @Test+ void routeToAPrefixListExposesThatAsCidrBlock() {+ StackResource r = resource("AWS::EC2::Route", "S3Route");+ ObjectNode props = mapper.createObjectNode().put("RouteTableId", RTB_ID)+ .put("DestinationPrefixListId", "pl-63a5400a").put("NatGatewayId", NAT_ID);++ provisioner.provision(r, props, ctx());++ verify(ec2).createRoute(REGION, RTB_ID, null, null, "pl-63a5400a", null, NAT_ID, null, null);+ assertEquals("pl-63a5400a", r.getAttributes().get("CidrBlock"));+ }++ @Test+ void natGatewayIsCreatedPublicWithNoTags() {+ NatGateway nat = new NatGateway();+ nat.setNatGatewayId(NAT_ID);+ when(ec2.createNatGateway(REGION, SUBNET_ID, ALLOC_ID, "public", List.of())).thenReturn(nat);+ StackResource r = resource("AWS::EC2::NatGateway", "Nat");++ provisioner.provision(r, mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("AllocationId", ALLOC_ID), ctx());++ assertEquals(NAT_ID, r.getPhysicalId());+ assertEquals(Set.of("NatGatewayId"), r.getAttributes().keySet());+ }++ @Test+ void eipRefIsThePublicIpAndAllocationIdIsAnAttribute() {+ Address addr = new Address();+ addr.setAllocationId(ALLOC_ID);+ addr.setPublicIp(PUBLIC_IP);+ when(ec2.allocateAddress(REGION)).thenReturn(addr);+ StackResource r = resource("AWS::EC2::EIP", "Eip");++ provisioner.provision(r, mapper.createObjectNode().put("Domain", "vpc"), ctx());++ assertEquals(PUBLIC_IP, r.getPhysicalId());+ assertEquals(Set.of("AllocationId", "PublicIp"), r.getAttributes().keySet());+ assertEquals(ALLOC_ID, r.getAttributes().get("AllocationId"));+ }++ @Test+ void deletesUseEachTypesOwnApiAndTolerateOnlyItsNotFoundCode() {+ provisioner.delete("AWS::EC2::Subnet", SUBNET_ID, REGION);+ provisioner.delete("AWS::EC2::InternetGateway", IGW_ID, REGION);+ provisioner.delete("AWS::EC2::RouteTable", RTB_ID, REGION);+ provisioner.delete("AWS::EC2::NatGateway", NAT_ID, REGION);+ provisioner.delete("AWS::EC2::SubnetRouteTableAssociation", ASSOC_ID, REGION);+ verify(ec2).deleteSubnet(REGION, SUBNET_ID);+ verify(ec2).deleteInternetGateway(REGION, IGW_ID);+ verify(ec2).deleteRouteTable(REGION, RTB_ID);+ verify(ec2).deleteNatGateway(REGION, NAT_ID);+ verify(ec2).disassociateRouteTable(REGION, ASSOC_ID);++ doThrow(new AwsException("InvalidSubnetID.NotFound", "gone", 400)).when(ec2).deleteSubnet(REGION, "subnet-gone");+ assertDoesNotThrow(() -> provisioner.delete("AWS::EC2::Subnet", "subnet-gone", REGION));+ doThrow(new AwsException("DependencyViolation", "has dependencies", 400)).when(ec2).deleteSubnet(REGION, "subnet-busy");+ AwsException e = assertThrows(AwsException.class, () -> provisioner.delete("AWS::EC2::Subnet", "subnet-busy", REGION));+ assertEquals("DependencyViolation", e.getErrorCode());+ }++ @Test+ void routeDeleteParsesTheTableAndDestinationFromItsId() {+ provisioner.delete("AWS::EC2::Route", RTB_ID + "|0.0.0.0/0", REGION);+ provisioner.delete("AWS::EC2::Route", RTB_ID + "|::/0", REGION);+ provisioner.delete("AWS::EC2::Route", RTB_ID + "|pl-63a5400a", REGION);++ verify(ec2).deleteRoute(REGION, RTB_ID, "0.0.0.0/0", null, null);+ verify(ec2).deleteRoute(REGION, RTB_ID, null, "::/0", null);+ verify(ec2).deleteRoute(REGION, RTB_ID, null, null, "pl-63a5400a");+ }++ @Test+ void routeDeleteToleratesAMissingRouteOrTableAndSkipsALegacyGeneratedId() {+ doThrow(new AwsException("InvalidRouteTableID.NotFound", "gone", 400))+ .when(ec2).deleteRoute(REGION, "rtb-gone", "10.0.0.0/8", null, null);++ assertDoesNotThrow(() -> provisioner.delete("AWS::EC2::Route", "rtb-gone|10.0.0.0/8", REGION));+ assertDoesNotThrow(() -> provisioner.delete("AWS::EC2::Route", "Default-1a2b3c4d", REGION));+ verify(ec2, never()).deleteRoute(eq(REGION), eq("Default-1a2b3c4d"), any(), any(), any());+ }++ @Test+ void eipReleaseUsesTheRecordedAllocationIdOrLooksTheAddressUpByIp() {+ StackResource r = resource("AWS::EC2::EIP", "Eip");+ r.setPhysicalId(PUBLIC_IP);+ r.getAttributes().put("AllocationId", ALLOC_ID);+ provisioner.delete(r, REGION);+ verify(ec2).releaseAddress(REGION, ALLOC_ID);+ verify(ec2, never()).describeAddresses(any(), any(), any());++ Address addr = new Address();+ addr.setAllocationId("eipalloc-byip");+ addr.setPublicIp("54.0.0.2");+ when(ec2.describeAddresses(REGION, List.of(), Map.of("public-ip", List.of("54.0.0.2")))).thenReturn(List.of(addr));+ provisioner.delete("AWS::EC2::EIP", "54.0.0.2", REGION);+ verify(ec2).releaseAddress(REGION, "eipalloc-byip");++ when(ec2.describeAddresses(REGION, List.of(), Map.of("public-ip", List.of("54.0.0.3")))).thenReturn(List.of());+ assertDoesNotThrow(() -> provisioner.delete("AWS::EC2::EIP", "54.0.0.3", REGION));+ }++ private static StackResource prior(String type, String logicalId, String physicalId, Map<String, String> attributes) {+ StackResource r = resource(type, logicalId);+ r.setPhysicalId(physicalId);+ r.getAttributes().putAll(attributes);+ return r;+ }++ @Test+ void anUnchangedSubnetIsKeptAndOnlyMapPublicIpOnLaunchIsApplied() {+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(subnet()));+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID, "VpcId", VPC_ID, "AvailabilityZone", "us-east-1a"));+ ObjectNode props = mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24")+ .put("AvailabilityZone", "us-east-1a").put("MapPublicIpOnLaunch", false);++ provisioner.provision(r, props, ctx(SUBNET_ID));++ verify(ec2, never()).createSubnet(any(), any(), any(), any());+ verify(ec2).modifySubnetAttribute(REGION, SUBNET_ID, "mapPublicIpOnLaunch", "false");+ assertEquals(SUBNET_ID, r.getPhysicalId());+ assertFalse(provisioner.hasReplacementUpdate(r));+ assertTrue(provisioner.rollbackUpdate(r), "the prior MapPublicIpOnLaunch is restored from the snapshot");+ verify(ec2).modifySubnetAttribute(REGION, SUBNET_ID, "mapPublicIpOnLaunch", "false");+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ }++ @Test+ void aSubnetWithAChangedCidrIsReplacedAndThePriorOneIsOwedToCleanup() {+ Subnet current = subnet();+ current.setCidrBlock("10.0.1.0/24");+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(current));+ Subnet replacement = subnet();+ replacement.setSubnetId("subnet-replacement");+ when(ec2.createSubnet(REGION, VPC_ID, "10.0.2.0/24", "us-east-1a")).thenReturn(replacement);+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));+ ObjectNode props = mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.2.0/24").put("AvailabilityZone", "us-east-1a");++ provisioner.provision(r, props, ctx(SUBNET_ID));++ assertEquals("subnet-replacement", r.getPhysicalId());+ assertTrue(provisioner.hasReplacementUpdate(r));+ assertEquals(SUBNET_ID, provisioner.updateCleanupPhysicalId(r));+ provisioner.completeUpdate(r);+ verify(ec2).deleteSubnet(REGION, SUBNET_ID);+ }++ @Test+ void aSubnetGoneOutOfBandIsCreatedAnew() {+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of()))+ .thenThrow(new AwsException("InvalidSubnetID.NotFound", "gone", 400));+ when(ec2.createSubnet(REGION, VPC_ID, "10.0.1.0/24", null)).thenReturn(subnet());+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of());++ provisioner.provision(r, mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), ctx(SUBNET_ID));++ assertEquals(SUBNET_ID, r.getPhysicalId());+ }++ @Test+ void anInternetGatewayAndARouteTableInTheSameVpcAreKeptAndRollBackAsComplete() {+ InternetGateway igw = new InternetGateway();+ igw.setInternetGatewayId(IGW_ID);+ when(ec2.describeInternetGateways(REGION, List.of(IGW_ID), Map.of())).thenReturn(List.of(igw));+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ StackResource igwResource = prior("AWS::EC2::InternetGateway", "Igw", IGW_ID, Map.of("InternetGatewayId", IGW_ID));+ StackResource rtResource = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of("RouteTableId", RTB_ID));++ provisioner.provision(igwResource, mapper.createObjectNode(), ctx(IGW_ID));+ provisioner.provision(rtResource, mapper.createObjectNode().put("VpcId", VPC_ID), ctx(RTB_ID));++ verify(ec2, never()).createInternetGateway(any());+ verify(ec2, never()).createRouteTable(any(), any());+ assertTrue(provisioner.rollbackUpdate(igwResource));+ assertTrue(provisioner.rollbackUpdate(rtResource));+ }++ @Test+ void aRouteTableMovedToAnotherVpcIsReplaced() {+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ RouteTable replacement = new RouteTable();+ replacement.setRouteTableId("rtb-replacement");+ when(ec2.createRouteTable(REGION, "vpc-other")).thenReturn(replacement);+ StackResource r = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of("RouteTableId", RTB_ID));++ provisioner.provision(r, mapper.createObjectNode().put("VpcId", "vpc-other"), ctx(RTB_ID));++ assertEquals("rtb-replacement", r.getPhysicalId());+ assertEquals(RTB_ID, provisioner.updateCleanupPhysicalId(r));+ assertTrue(provisioner.rollbackUpdate(r));+ verify(ec2).deleteRouteTable(REGION, "rtb-replacement");+ assertEquals(RTB_ID, r.getPhysicalId());+ }++ @Test+ void aNatGatewayWithTheSameSubnetAndAllocationIsKeptAndAChangedSubnetReplacesIt() {+ NatGateway nat = new NatGateway();+ nat.setNatGatewayId(NAT_ID);+ nat.setSubnetId(SUBNET_ID);+ nat.setAllocationId(ALLOC_ID);+ when(ec2.describeNatGateways(REGION, List.of(NAT_ID), Map.of())).thenReturn(List.of(nat));+ StackResource same = prior("AWS::EC2::NatGateway", "Nat", NAT_ID, Map.of("NatGatewayId", NAT_ID));+ provisioner.provision(same, mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("AllocationId", ALLOC_ID), ctx(NAT_ID));+ verify(ec2, never()).createNatGateway(any(), any(), any(), any(), any());+ assertEquals(NAT_ID, same.getPhysicalId());++ NatGateway replacement = new NatGateway();+ replacement.setNatGatewayId("nat-replacement");+ when(ec2.createNatGateway(REGION, "subnet-other", ALLOC_ID, "public", List.of())).thenReturn(replacement);+ StackResource moved = prior("AWS::EC2::NatGateway", "Nat", NAT_ID, Map.of("NatGatewayId", NAT_ID));+ provisioner.provision(moved, mapper.createObjectNode().put("SubnetId", "subnet-other").put("AllocationId", ALLOC_ID), ctx(NAT_ID));+ assertEquals("nat-replacement", moved.getPhysicalId());+ assertEquals(NAT_ID, provisioner.updateCleanupPhysicalId(moved));+ }++ @Test+ void anAllocatedEipIsKeptAcrossUpdates() {+ Address addr = new Address();+ addr.setAllocationId(ALLOC_ID);+ addr.setPublicIp(PUBLIC_IP);+ when(ec2.describeAddresses(REGION, List.of(ALLOC_ID), Map.of())).thenReturn(List.of(addr));+ StackResource r = prior("AWS::EC2::EIP", "Eip", PUBLIC_IP, Map.of("AllocationId", ALLOC_ID, "PublicIp", PUBLIC_IP));++ provisioner.provision(r, mapper.createObjectNode().put("Domain", "vpc"), ctx(PUBLIC_IP));++ verify(ec2, never()).allocateAddress(any());+ assertEquals(PUBLIC_IP, r.getPhysicalId());+ }++ @Test+ void anAssociationWithTheSamePairIsKeptAndAnotherSubnetReplacesIt() {+ RouteTableAssociation assoc = new RouteTableAssociation();+ assoc.setRouteTableAssociationId(ASSOC_ID);+ assoc.setRouteTableId(RTB_ID);+ assoc.setSubnetId(SUBNET_ID);+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setAssociations(List.of(assoc));+ when(ec2.describeRouteTables(REGION, List.of(), Map.of("association.route-table-association-id", List.of(ASSOC_ID))))+ .thenReturn(List.of(rt));+ StackResource same = prior("AWS::EC2::SubnetRouteTableAssociation", "Assoc", ASSOC_ID, Map.of("Id", ASSOC_ID));+ provisioner.provision(same, mapper.createObjectNode().put("RouteTableId", RTB_ID).put("SubnetId", SUBNET_ID), ctx(ASSOC_ID));+ verify(ec2, never()).associateRouteTable(any(), any(), any());++ RouteTableAssociation replacement = new RouteTableAssociation();+ replacement.setRouteTableAssociationId("rtbassoc-replacement");+ when(ec2.associateRouteTable(REGION, RTB_ID, "subnet-other")).thenReturn(replacement);+ StackResource moved = prior("AWS::EC2::SubnetRouteTableAssociation", "Assoc", ASSOC_ID, Map.of("Id", ASSOC_ID));+ provisioner.provision(moved, mapper.createObjectNode().put("RouteTableId", RTB_ID).put("SubnetId", "subnet-other"), ctx(ASSOC_ID));+ assertEquals("rtbassoc-replacement", moved.getPhysicalId());+ assertEquals(ASSOC_ID, provisioner.updateCleanupPhysicalId(moved));+ provisioner.completeUpdate(moved);+ verify(ec2).disassociateRouteTable(REGION, ASSOC_ID);+ }++ @Test+ void aRouteWithTheSameTableAndDestinationChangesItsTargetInPlace() {+ Route route = new Route();+ route.setDestinationCidrBlock("0.0.0.0/0");+ route.setGatewayId(IGW_ID);+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setRoutes(List.of(route));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ StackResource r = prior("AWS::EC2::Route", "Default", RTB_ID + "|0.0.0.0/0", Map.of("CidrBlock", "0.0.0.0/0"));+ ObjectNode props = mapper.createObjectNode().put("RouteTableId", RTB_ID).put("DestinationCidrBlock", "0.0.0.0/0").put("NatGatewayId", NAT_ID);++ provisioner.provision(r, props, ctx(RTB_ID + "|0.0.0.0/0"));++ verify(ec2).replaceRoute(REGION, RTB_ID, "0.0.0.0/0", null, null, null, NAT_ID, null);+ verify(ec2, never()).createRoute(any(), any(), any(), any(), any(), any(), any(), any(), any());+ assertEquals(RTB_ID + "|0.0.0.0/0", r.getPhysicalId());+ assertTrue(provisioner.rollbackUpdate(r), "the prior target is restored from the snapshot");+ verify(ec2).replaceRoute(REGION, RTB_ID, "0.0.0.0/0", null, null, IGW_ID, null, null);+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ }++ @Test+ void aRouteWithAChangedDestinationIsANewRouteAndThePriorOneIsOwedToCleanup() {+ StackResource r = prior("AWS::EC2::Route", "Default", RTB_ID + "|0.0.0.0/0", Map.of("CidrBlock", "0.0.0.0/0"));+ ObjectNode props = mapper.createObjectNode().put("RouteTableId", RTB_ID).put("DestinationCidrBlock", "10.1.0.0/16").put("GatewayId", IGW_ID);++ provisioner.provision(r, props, ctx(RTB_ID + "|0.0.0.0/0"));++ verify(ec2).createRoute(REGION, RTB_ID, "10.1.0.0/16", null, null, IGW_ID, null, null, null);+ assertEquals(RTB_ID + "|10.1.0.0/16", r.getPhysicalId());+ assertEquals(RTB_ID + "|0.0.0.0/0", provisioner.updateCleanupPhysicalId(r));+ provisioner.completeUpdate(r);+ verify(ec2).deleteRoute(REGION, RTB_ID, "0.0.0.0/0", null, null);+ }++ /** The EC2 Tag model has no equals, so tag lists are compared as key=value pairs. */+ private static List<String> pairs(List<Tag> tags) {+ return tags.stream().map(t -> t.getKey() + "=" + t.getValue()).toList();+ }++ @SuppressWarnings("unchecked")+ private List<String> tagsWritten(String resourceId) {+ ArgumentCaptor<List<Tag>> tags = ArgumentCaptor.forClass(List.class);+ verify(ec2).createTags(eq(REGION), eq(List.of(resourceId)), tags.capture());+ return pairs(tags.getValue());+ }++ private static ObjectNode withTags(ObjectNode props, String... keyValues) {+ var tags = props.putArray("Tags");+ for (int i = 0; i + 1 < keyValues.length; i += 2) {+ tags.addObject().put("Key", keyValues[i]).put("Value", keyValues[i + 1]);+ }+ return props;+ }++ @Test+ void tagsAreWrittenOnCreateForEveryTaggableType() {+ when(ec2.createSubnet(eq(REGION), eq(VPC_ID), eq("10.0.1.0/24"), isNull())).thenReturn(subnet());+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ when(ec2.createRouteTable(REGION, VPC_ID)).thenReturn(rt);+ InternetGateway igw = new InternetGateway();+ igw.setInternetGatewayId(IGW_ID);+ when(ec2.createInternetGateway(REGION)).thenReturn(igw);+ Address addr = new Address();+ addr.setAllocationId(ALLOC_ID);+ addr.setPublicIp(PUBLIC_IP);+ when(ec2.allocateAddress(REGION)).thenReturn(addr);++ provisioner.provision(resource("AWS::EC2::Subnet", "Subnet"),+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "Name", "public"), ctx());+ provisioner.provision(resource("AWS::EC2::RouteTable", "Rtb"),+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID), "Name", "public-rt"), ctx());+ provisioner.provision(resource("AWS::EC2::InternetGateway", "Igw"), withTags(mapper.createObjectNode(), "Name", "igw"), ctx());+ provisioner.provision(resource("AWS::EC2::EIP", "Eip"), withTags(mapper.createObjectNode(), "Name", "nat-ip"), ctx());++ assertEquals(List.of("Name=public"), tagsWritten(SUBNET_ID));+ assertEquals(List.of("Name=public-rt"), tagsWritten(RTB_ID));+ assertEquals(List.of("Name=igw"), tagsWritten(IGW_ID));+ assertEquals(List.of("Name=nat-ip"), tagsWritten(ALLOC_ID));+ verify(ec2, never()).deleteTags(any(), any(), any());+ }++ @Test+ void aPrivateNatGatewayNeedsNoAllocationAndAPublicOneRequiresIt() {+ NatGateway nat = new NatGateway();+ nat.setNatGatewayId(NAT_ID);+ when(ec2.createNatGateway(eq(REGION), eq(SUBNET_ID), isNull(), eq("private"), any())).thenReturn(nat);+ StackResource r = resource("AWS::EC2::NatGateway", "Nat");++ provisioner.provision(r, mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("ConnectivityType", "private"), ctx());+ assertEquals(NAT_ID, r.getPhysicalId());++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(resource("AWS::EC2::NatGateway", "Nat2"),+ mapper.createObjectNode().put("SubnetId", SUBNET_ID), ctx()));+ assertEquals("ValidationError", e.getErrorCode());+ AwsException e2 = assertThrows(AwsException.class, () -> provisioner.provision(resource("AWS::EC2::NatGateway", "Nat3"),+ mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("ConnectivityType", "private").put("AllocationId", ALLOC_ID), ctx()));+ assertEquals("ValidationError", e2.getErrorCode());+ }++ @Test+ void aNatGatewayWhoseConnectivityTypeChangedIsReplaced() {+ NatGateway nat = new NatGateway();+ nat.setNatGatewayId(NAT_ID);+ nat.setSubnetId(SUBNET_ID);+ nat.setAllocationId(ALLOC_ID);+ nat.setConnectivityType("public");+ when(ec2.describeNatGateways(REGION, List.of(NAT_ID), Map.of())).thenReturn(List.of(nat));+ NatGateway replacement = new NatGateway();+ replacement.setNatGatewayId("nat-private");+ when(ec2.createNatGateway(eq(REGION), eq(SUBNET_ID), isNull(), eq("private"), any())).thenReturn(replacement);+ StackResource r = prior("AWS::EC2::NatGateway", "Nat", NAT_ID, Map.of("NatGatewayId", NAT_ID));++ provisioner.provision(r, mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("ConnectivityType", "private"), ctx(NAT_ID));++ assertEquals("nat-private", r.getPhysicalId());+ assertEquals(NAT_ID, provisioner.updateCleanupPhysicalId(r));+ }++ @Test+ void natGatewayTagsGoThroughItsCreateCall() {+ NatGateway nat = new NatGateway();+ nat.setNatGatewayId(NAT_ID);+ when(ec2.createNatGateway(eq(REGION), eq(SUBNET_ID), eq(ALLOC_ID), eq("public"), any())).thenReturn(nat);++ provisioner.provision(resource("AWS::EC2::NatGateway", "Nat"),+ withTags(mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("AllocationId", ALLOC_ID), "Name", "nat"), ctx());++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> tags = ArgumentCaptor.forClass(List.class);+ verify(ec2).createNatGateway(eq(REGION), eq(SUBNET_ID), eq(ALLOC_ID), eq("public"), tags.capture());+ assertEquals(List.of("Name=nat"), pairs(tags.getValue()));+ verify(ec2, never()).createTags(any(), any(), any());+ }++ @Test+ void aReusedSubnetDropsTheTagKeysTheTemplateRemovedAndWritesTheRest() {+ Subnet current = subnet();+ current.setTags(List.of(new Tag("Name", "old"), new Tag("team", "net")));+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(current));+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));+ ObjectNode props = withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "Name", "new");++ provisioner.provision(r, props, ctx(SUBNET_ID));++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> removed = ArgumentCaptor.forClass(List.class);+ verify(ec2).deleteTags(eq(REGION), eq(List.of(SUBNET_ID)), removed.capture());+ assertEquals(List.of("team=null"), pairs(removed.getValue()));+ assertEquals(List.of("Name=new"), tagsWritten(SUBNET_ID));+ }++ @Test+ void aTagChangeOnAReusedEntityIsRolledBackToThePriorTags() {+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ rt.setTags(List.of(new Tag("Name", "old"), new Tag("team", "net")));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ StackResource r = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of("RouteTableId", RTB_ID));++ provisioner.provision(r, withTags(mapper.createObjectNode().put("VpcId", VPC_ID), "Name", "new", "env", "test"), ctx(RTB_ID));+ assertTrue(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR), "the prior tags are snapshotted");++ assertTrue(provisioner.rollbackUpdate(r));++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> removed = ArgumentCaptor.forClass(List.class);+ verify(ec2, org.mockito.Mockito.times(2)).deleteTags(eq(REGION), eq(List.of(RTB_ID)), removed.capture());+ assertEquals(List.of("env=null"), pairs(removed.getAllValues().get(1)), "the key the update added is removed");+ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> written = ArgumentCaptor.forClass(List.class);+ verify(ec2, org.mockito.Mockito.times(2)).createTags(eq(REGION), eq(List.of(RTB_ID)), written.capture());+ assertEquals(List.of("Name=old", "team=net"), pairs(written.getAllValues().get(1)), "the prior tags are written back");+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ }++ @Test+ void anUnchangedReuseLeavesNoSnapshotAndRollsBackAsComplete() {+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ rt.setTags(List.of(new Tag("Name", "same")));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ StackResource r = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of("RouteTableId", RTB_ID));++ provisioner.provision(r, withTags(mapper.createObjectNode().put("VpcId", VPC_ID), "Name", "same"), ctx(RTB_ID));++ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ assertTrue(provisioner.rollbackUpdate(r));+ verify(ec2, never()).deleteTags(any(), any(), any());+ }++ @Test+ void completingOrClearingAnUpdateDropsTheSnapshot() {+ StackResource r = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR, "{}"));+ provisioner.completeUpdate(r);+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ r.getAttributes().put(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR, "{}");+ provisioner.clearUpdate(r);+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ }++ @Test+ void aTemplateWithoutTagsLeavesExistingTagsAlone() {+ Subnet current = subnet();+ current.setTags(List.of(new Tag("Name", "kept")));+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(current));+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));++ provisioner.provision(r, mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), ctx(SUBNET_ID));++ verify(ec2, never()).deleteTags(any(), any(), any());+ verify(ec2, never()).createTags(any(), any(), any());+ }++ @Test+ void requiredPropertiesAreValidatedBeforeAnyServiceCall() {+ record Case(String type, ObjectNode props, String expected) { }+ List<Case> cases = List.of(+ new Case("AWS::EC2::Subnet", mapper.createObjectNode().put("CidrBlock", "10.0.1.0/24"), "AWS::EC2::Subnet requires VpcId"),+ new Case("AWS::EC2::RouteTable", mapper.createObjectNode(), "AWS::EC2::RouteTable requires VpcId"),+ new Case("AWS::EC2::SubnetRouteTableAssociation", mapper.createObjectNode().put("SubnetId", SUBNET_ID),+ "AWS::EC2::SubnetRouteTableAssociation requires RouteTableId"),+ new Case("AWS::EC2::SubnetRouteTableAssociation", mapper.createObjectNode().put("RouteTableId", RTB_ID),+ "AWS::EC2::SubnetRouteTableAssociation requires SubnetId"),+ new Case("AWS::EC2::NatGateway", mapper.createObjectNode().put("AllocationId", ALLOC_ID), "AWS::EC2::NatGateway requires SubnetId"),+ new Case("AWS::EC2::Route", mapper.createObjectNode().put("DestinationCidrBlock", "0.0.0.0/0"), "AWS::EC2::Route requires RouteTableId"),+ new Case("AWS::EC2::Route", mapper.createObjectNode().put("RouteTableId", RTB_ID),+ "AWS::EC2::Route requires exactly one of DestinationCidrBlock, DestinationIpv6CidrBlock or DestinationPrefixListId"),+ new Case("AWS::EC2::Route", mapper.createObjectNode().put("RouteTableId", RTB_ID).put("DestinationCidrBlock", "0.0.0.0/0").put("DestinationIpv6CidrBlock", "::/0"),+ "AWS::EC2::Route requires exactly one of DestinationCidrBlock, DestinationIpv6CidrBlock or DestinationPrefixListId"));+ for (Case c : cases) {+ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(resource(c.type(), "R"), c.props(), ctx()), c.expected());+ assertEquals("ValidationError", e.getErrorCode());+ assertEquals(c.expected(), e.getMessage());+ }+ verify(ec2, never()).createSubnet(any(), any(), any(), any());+ verify(ec2, never()).createRouteTable(any(), any());+ verify(ec2, never()).associateRouteTable(any(), any(), any());+ verify(ec2, never()).createRoute(any(), any(), any(), any(), any(), any(), any(), any(), any());+ verify(ec2, never()).createNatGateway(any(), any(), any(), any(), any());+ }++ @Test+ void aNonCanonicalIpv4DestinationIsKeyedByItsCanonicalFormAndReusedAsSuch() {+ StackResource created = resource("AWS::EC2::Route", "Default");+ provisioner.provision(created, mapper.createObjectNode().put("RouteTableId", RTB_ID)+ .put("DestinationCidrBlock", "10.40.0.18/24").put("GatewayId", IGW_ID), ctx());+ assertEquals(RTB_ID + "|10.40.0.0/24", created.getPhysicalId(), "the id carries the canonical CIDR the service stores");+ assertEquals("10.40.0.0/24", created.getAttributes().get("CidrBlock"));+ verify(ec2).createRoute(REGION, RTB_ID, "10.40.0.18/24", null, null, IGW_ID, null, null, null);++ Route stored = new Route();+ stored.setDestinationCidrBlock("10.40.0.0/24");+ stored.setGatewayId(IGW_ID);+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setRoutes(List.of(stored));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ StackResource updated = prior("AWS::EC2::Route", "Default", RTB_ID + "|10.40.0.0/24", Map.of("CidrBlock", "10.40.0.0/24"));+ provisioner.provision(updated, mapper.createObjectNode().put("RouteTableId", RTB_ID)+ .put("DestinationCidrBlock", "10.40.0.18/24").put("GatewayId", IGW_ID), ctx(RTB_ID + "|10.40.0.0/24"));+ verify(ec2).replaceRoute(REGION, RTB_ID, "10.40.0.18/24", null, null, IGW_ID, null, null);+ verify(ec2, org.mockito.Mockito.times(1)).createRoute(any(), any(), any(), any(), any(), any(), any(), any(), any());+ assertEquals(RTB_ID + "|10.40.0.0/24", updated.getPhysicalId());+ }++ @Test+ void aFailedStepAfterACreateDeletesWhatWasJustCreatedAndPropagates() {+ when(ec2.createSubnet(eq(REGION), eq(VPC_ID), eq("10.0.1.0/24"), isNull())).thenReturn(subnet());+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ when(ec2.createRouteTable(REGION, VPC_ID)).thenReturn(rt);+ InternetGateway igw = new InternetGateway();+ igw.setInternetGatewayId(IGW_ID);+ when(ec2.createInternetGateway(REGION)).thenReturn(igw);+ Address addr = new Address();+ addr.setAllocationId(ALLOC_ID);+ addr.setPublicIp(PUBLIC_IP);+ when(ec2.allocateAddress(REGION)).thenReturn(addr);+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).when(ec2).createTags(any(), any(), any());++ for (var attempt : List.of(+ Map.entry("AWS::EC2::Subnet", withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "k", "v")),+ Map.entry("AWS::EC2::RouteTable", withTags(mapper.createObjectNode().put("VpcId", VPC_ID), "k", "v")),+ Map.entry("AWS::EC2::InternetGateway", withTags(mapper.createObjectNode(), "k", "v")),+ Map.entry("AWS::EC2::EIP", withTags(mapper.createObjectNode(), "k", "v")))) {+ AwsException e = assertThrows(AwsException.class,+ () -> provisioner.provision(resource(attempt.getKey(), "R"), attempt.getValue(), ctx()), attempt.getKey());+ assertEquals("TagLimitExceeded", e.getErrorCode());+ }+ verify(ec2).deleteSubnet(REGION, SUBNET_ID);+ verify(ec2).deleteRouteTable(REGION, RTB_ID);+ verify(ec2).deleteInternetGateway(REGION, IGW_ID);+ verify(ec2).releaseAddress(REGION, ALLOC_ID);+ }++ @Test+ void aSuccessfulCreateLeavesNoRollbackOwnedMarker() {+ when(ec2.createSubnet(eq(REGION), eq(VPC_ID), eq("10.0.1.0/24"), isNull())).thenReturn(subnet());+ StackResource r = resource("AWS::EC2::Subnet", "Subnet");++ provisioner.provision(r, withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "k", "v"), ctx());++ assertFalse(r.getAttributes().containsKey(CfnRollback.ROLLBACK_OWNED_ATTR));+ assertFalse(r.getAttributes().containsKey(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR));+ }++ @Test+ void aFailedUndoOfACreateLeavesTheEntityRollbackOwnedAndReportsTheReason() {+ when(ec2.createSubnet(eq(REGION), eq(VPC_ID), eq("10.0.1.0/24"), isNull())).thenReturn(subnet());+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).when(ec2).createTags(any(), any(), any());+ doThrow(new AwsException("DependencyViolation", "in use", 400)).when(ec2).deleteSubnet(REGION, SUBNET_ID);+ StackResource r = resource("AWS::EC2::Subnet", "Subnet");++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r,+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "k", "v"), ctx()));++ assertEquals("TagLimitExceeded", e.getErrorCode());+ assertEquals(1, e.getSuppressed().length);+ assertEquals(SUBNET_ID, r.getPhysicalId(), "the id stays so the engine's rollback can delete it");+ assertEquals("true", r.getAttributes().get(CfnRollback.ROLLBACK_OWNED_ATTR));+ assertTrue(r.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR).contains("Could not remove " + SUBNET_ID));+ }++ @Test+ void aReplacementThatCouldNotBeRemovedAfterAFailedStepIsOwedToTheNextCleanup() {+ Subnet current = subnet();+ current.setCidrBlock("10.0.1.0/24");+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(current));+ Subnet replacement = subnet();+ replacement.setSubnetId("subnet-replacement");+ when(ec2.createSubnet(REGION, VPC_ID, "10.0.2.0/24", "us-east-1a")).thenReturn(replacement);+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).when(ec2).createTags(any(), any(), any());+ doThrow(new AwsException("DependencyViolation", "in use", 400)).when(ec2).deleteSubnet(REGION, "subnet-replacement");+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));+ ObjectNode props = withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.2.0/24").put("AvailabilityZone", "us-east-1a"), "k", "v");++ assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx(SUBNET_ID)));++ assertTrue(r.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR).contains("Could not remove subnet-replacement"));+ assertTrue(provisioner.hasReplacementUpdate(r), "the replacement is listed in the attempt's cleanup record");+ // The engine restores the previous resource and carries the record across (mergeFailedUpdateResourceTracking).+ StackResource previous = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));+ ReplacementCleanup.mergeDisplaced(previous, r);+ assertEquals("subnet-replacement", provisioner.updateCleanupPhysicalId(previous), "the replacement stays owed a delete");+ provisioner.completeUpdate(previous);+ verify(ec2, org.mockito.Mockito.times(2)).deleteSubnet(REGION, "subnet-replacement");+ }++ @Test+ void aFreshCreateThatCouldNotBeRemovedRecordsNoCleanupEntry() {+ when(ec2.createSubnet(eq(REGION), eq(VPC_ID), eq("10.0.1.0/24"), isNull())).thenReturn(subnet());+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).when(ec2).createTags(any(), any(), any());+ doThrow(new AwsException("DependencyViolation", "in use", 400)).when(ec2).deleteSubnet(REGION, SUBNET_ID);+ StackResource r = resource("AWS::EC2::Subnet", "Subnet");++ assertThrows(AwsException.class, () -> provisioner.provision(r,+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "k", "v"), ctx()));++ assertEquals("true", r.getAttributes().get(CfnRollback.ROLLBACK_OWNED_ATTR), "the engine's create rollback owns it");+ assertFalse(provisioner.hasReplacementUpdate(r));+ }++ @Test+ void aFailedRestoreOfAReusedEntityKeepsTheSnapshotAndReportsTheReason() {+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ rt.setTags(List.of(new Tag("Name", "old")));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ // Two distinct instances: the attempt's failure and the restore's, since a throwable cannot suppress itself.+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400))+ .doThrow(new AwsException("TagLimitExceeded", "still too many tags", 400))+ .when(ec2).createTags(eq(REGION), eq(List.of(RTB_ID)), any());+ StackResource r = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of("RouteTableId", RTB_ID));++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r,+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID), "Name", "new"), ctx(RTB_ID)));++ assertEquals("TagLimitExceeded", e.getErrorCode());+ assertEquals(1, e.getSuppressed().length);+ assertTrue(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR), "the snapshot is kept");+ assertTrue(r.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR).contains("Could not restore " + RTB_ID));+ verify(ec2, never()).deleteRouteTable(any(), any());+ }++ @Test+ void aFailureMidWayThroughAnInPlaceTagChangePutsThePriorTagsBack() {+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setVpcId(VPC_ID);+ rt.setTags(List.of(new Tag("Name", "old"), new Tag("team", "net")));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ // deleteTags (of "team") succeeds, then the createTags of the new set throws; the restore's createTags succeeds.+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).doNothing()+ .when(ec2).createTags(eq(REGION), eq(List.of(RTB_ID)), any());+ StackResource r = prior("AWS::EC2::RouteTable", "Rtb", RTB_ID, Map.of("RouteTableId", RTB_ID));++ AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(r,+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID), "Name", "new", "env", "test"), ctx(RTB_ID)));++ assertEquals("TagLimitExceeded", e.getErrorCode());+ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> written = ArgumentCaptor.forClass(List.class);+ verify(ec2, org.mockito.Mockito.times(2)).createTags(eq(REGION), eq(List.of(RTB_ID)), written.capture());+ assertEquals(List.of("Name=old", "team=net"), pairs(written.getAllValues().get(1)), "the prior tags are put back");+ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> removed = ArgumentCaptor.forClass(List.class);+ verify(ec2, org.mockito.Mockito.times(2)).deleteTags(eq(REGION), eq(List.of(RTB_ID)), removed.capture());+ assertEquals(List.of("env=null"), pairs(removed.getAllValues().get(1)), "the key the failed update added is removed again");+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ assertFalse(r.getAttributes().containsKey(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR), "a successful restore reports nothing");+ verify(ec2, never()).deleteRouteTable(any(), any());+ }++ @Test+ void aFailedSubnetAttributeChangeAfterTagsPutsTheTagsBack() {+ Subnet current = subnet();+ current.setTags(List.of(new Tag("Name", "old")));+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(current));+ doThrow(new AwsException("InvalidParameterValue", "nope", 400))+ .when(ec2).modifySubnetAttribute(REGION, SUBNET_ID, "mapPublicIpOnLaunch", "true");+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));+ ObjectNode props = withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24")+ .put("MapPublicIpOnLaunch", true), "Name", "new");++ assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx(SUBNET_ID)));++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> written = ArgumentCaptor.forClass(List.class);+ verify(ec2, org.mockito.Mockito.times(2)).createTags(eq(REGION), eq(List.of(SUBNET_ID)), written.capture());+ assertEquals(List.of("Name=old"), pairs(written.getAllValues().get(1)));+ // the snapshot recorded the prior value before the flip was attempted, so the restore writes it back+ verify(ec2).modifySubnetAttribute(REGION, SUBNET_ID, "mapPublicIpOnLaunch", "false");+ verify(ec2, org.mockito.Mockito.times(2)).modifySubnetAttribute(any(), any(), any(), any());+ verify(ec2, never()).deleteSubnet(any(), any());+ }++ @Test+ void aFailedRouteRetargetPutsThePriorTargetBack() {+ Route route = new Route();+ route.setDestinationCidrBlock("0.0.0.0/0");+ route.setGatewayId(IGW_ID);+ RouteTable rt = new RouteTable();+ rt.setRouteTableId(RTB_ID);+ rt.setRoutes(List.of(route));+ when(ec2.describeRouteTables(REGION, List.of(RTB_ID), Map.of())).thenReturn(List.of(rt));+ doThrow(new AwsException("InvalidNatGatewayID.NotFound", "gone", 400)).doNothing()+ .when(ec2).replaceRoute(eq(REGION), eq(RTB_ID), eq("0.0.0.0/0"), isNull(), isNull(), any(), any(), any());+ StackResource r = prior("AWS::EC2::Route", "Default", RTB_ID + "|0.0.0.0/0", Map.of("CidrBlock", "0.0.0.0/0"));++ assertThrows(AwsException.class, () -> provisioner.provision(r, mapper.createObjectNode().put("RouteTableId", RTB_ID)+ .put("DestinationCidrBlock", "0.0.0.0/0").put("NatGatewayId", NAT_ID), ctx(RTB_ID + "|0.0.0.0/0")));++ verify(ec2).replaceRoute(REGION, RTB_ID, "0.0.0.0/0", null, null, null, NAT_ID, null);+ verify(ec2).replaceRoute(REGION, RTB_ID, "0.0.0.0/0", null, null, IGW_ID, null, null);+ assertFalse(r.getAttributes().containsKey(Ec2NetworkCfnProvisioner.IN_PLACE_PRIOR_ATTR));+ }++ @Test+ void aFailedNatGatewayTagChangePutsThePriorTagsBack() {+ NatGateway nat = new NatGateway();+ nat.setNatGatewayId(NAT_ID);+ nat.setSubnetId(SUBNET_ID);+ nat.setAllocationId(ALLOC_ID);+ nat.setTags(List.of(new Tag("Name", "old")));+ when(ec2.describeNatGateways(REGION, List.of(NAT_ID), Map.of())).thenReturn(List.of(nat));+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).doNothing()+ .when(ec2).createTags(eq(REGION), eq(List.of(NAT_ID)), any());+ StackResource r = prior("AWS::EC2::NatGateway", "Nat", NAT_ID, Map.of("NatGatewayId", NAT_ID));++ assertThrows(AwsException.class, () -> provisioner.provision(r,+ withTags(mapper.createObjectNode().put("SubnetId", SUBNET_ID).put("AllocationId", ALLOC_ID), "Name", "new"), ctx(NAT_ID)));++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Tag>> written = ArgumentCaptor.forClass(List.class);+ verify(ec2, org.mockito.Mockito.times(2)).createTags(eq(REGION), eq(List.of(NAT_ID)), written.capture());+ assertEquals(List.of("Name=old"), pairs(written.getAllValues().get(1)));+ verify(ec2, never()).deleteNatGateway(any(), any());+ }++ @Test+ void aFailedStepOnAReusedEntityLeavesItAlone() {+ when(ec2.describeSubnets(REGION, List.of(SUBNET_ID), Map.of())).thenReturn(List.of(subnet()));+ doThrow(new AwsException("TagLimitExceeded", "too many tags", 400)).when(ec2).createTags(any(), any(), any());+ StackResource r = prior("AWS::EC2::Subnet", "Subnet", SUBNET_ID, Map.of("SubnetId", SUBNET_ID));++ assertThrows(AwsException.class, () -> provisioner.provision(r,+ withTags(mapper.createObjectNode().put("VpcId", VPC_ID).put("CidrBlock", "10.0.1.0/24"), "k", "v"), ctx(SUBNET_ID)));++ verify(ec2, never()).deleteSubnet(any(), any());+ }++ @Test+ void unknownTypeIsRejected() {+ StackResource r = resource("AWS::EC2::SecurityGroup", "Sg");++ assertThrows(IllegalStateException.class, () -> provisioner.provision(r, mapper.createObjectNode(), ctx()));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanupTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanupTest.javanew file mode 100644index 0000000000..7a2891621e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/ReplacementCleanupTest.java@@ -0,0 +1,84 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.HashMap;+import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertTrue;++/** The cleanup record's orphan handling in isolation: what a provisioner records and what the engine's merge carries. */+class ReplacementCleanupTest {++ private static StackResource resource(String physicalId) {+ StackResource r = new StackResource();+ r.setLogicalId("Subnet");+ r.setResourceType("AWS::EC2::Subnet");+ r.setPhysicalId(physicalId);+ r.setAttributes(new HashMap<>());+ return r;+ }++ @Test+ void anOrphanIsOwedADeleteAndLeavesTheRecordOnceDeleted() {+ StackResource r = resource("subnet-prior");+ List<String> deleted = new ArrayList<>();++ ReplacementCleanup.recordOrphan(r, "subnet-replacement", "AWS::EC2::Subnet", "us-east-1");++ assertTrue(ReplacementCleanup.hasReplacement(r));+ assertEquals("subnet-replacement", ReplacementCleanup.cleanupPhysicalId(r));+ UpdateCleanupResult result = ReplacementCleanup.complete(r, (type, id, region) -> deleted.add(type + ":" + id + ":" + region));+ assertEquals(List.of("AWS::EC2::Subnet:subnet-replacement:us-east-1"), deleted);+ assertTrue(result.complete());+ assertFalse(ReplacementCleanup.hasReplacement(r));+ }++ @Test+ void anOrphanIsNeverRetained() {+ StackResource r = resource("subnet-prior");+ r.setUpdateReplacePolicy("Retain");++ ReplacementCleanup.recordOrphan(r, "subnet-replacement", "AWS::EC2::Subnet", "us-east-1");++ assertEquals("subnet-replacement", ReplacementCleanup.cleanupPhysicalId(r), "Retain keeps what a committed replacement displaced, not a failed update's leftovers");+ }++ @Test+ void mergingCarriesUnknownOrphansWithTheirAttemptsAndSkipsKnownOrOwnIds() {+ // The attempt's own id is left out of the record on purpose (complete/cleanupPhysicalId skip+ // it), which is why the engine merges the record onto the restored previous resource.+ StackResource attempted = resource("subnet-attempt");+ ReplacementCleanup.recordOrphan(attempted, "subnet-replacement", "AWS::EC2::Subnet", "us-east-1");+ ReplacementCleanup.recordOrphan(attempted, "subnet-old-orphan", "AWS::EC2::Subnet", "us-east-1");+ // one failed attempt already counted on both+ ReplacementCleanup.complete(attempted, (type, id, region) -> { throw new IllegalStateException("still in use"); });+ StackResource previous = resource("subnet-prior");+ ReplacementCleanup.recordOrphan(previous, "subnet-old-orphan", "AWS::EC2::Subnet", "us-east-1");++ ReplacementCleanup.mergeDisplaced(previous, attempted);++ String record = previous.getAttributes().get(CfnRollback.REPLACEMENT_CLEANUP_ATTR);+ assertTrue(record.indexOf("subnet-old-orphan") == record.lastIndexOf("subnet-old-orphan"), "the known orphan is listed once: " + record);+ assertTrue(record.contains("\"physicalId\":\"subnet-replacement\",\"resourceType\":\"AWS::EC2::Subnet\",\"region\":\"us-east-1\",\"retainable\":false,\"cleanupAttempts\":1"),+ "the new orphan keeps its attempt count: " + record);+ List<String> owed = new ArrayList<>();+ ReplacementCleanup.complete(previous, (type, id, region) -> owed.add(id));+ assertEquals(List.of("subnet-old-orphan", "subnet-replacement"), owed);+ assertFalse(ReplacementCleanup.hasReplacement(previous));+ }++ @Test+ void mergingNothingLeavesTheTargetUntouched() {+ StackResource previous = resource("subnet-prior");++ ReplacementCleanup.mergeDisplaced(previous, resource("subnet-replacement"));++ assertNull(previous.getAttributes().get(CfnRollback.REPLACEMENT_CLEANUP_ATTR));+ }+}diff --git a/src/test/resources/cloudformation/getatt-attribute-gaps.tsv b/src/test/resources/cloudformation/getatt-attribute-gaps.tsvindex 4de066c11c..470712c55d 100644--- a/src/test/resources/cloudformation/getatt-attribute-gaps.tsv+++ b/src/test/resources/cloudformation/getatt-attribute-gaps.tsv@@ -1,6 +1,13 @@AWS::CodeBuild::Project Id schema gives no description; AWS's Id may differ from the project name Floci usesAWS::CodePipeline::CustomActionType Id schema gives no description; the custom action has no separate id in FlociAWS::CodePipeline::Webhook Id schema gives no description; Floci keys webhooks by name+AWS::EC2::NatGateway AutoProvisionZones availability-mode NAT gateways are not emulated+AWS::EC2::NatGateway AutoScalingIps availability-mode NAT gateways are not emulated+AWS::EC2::NatGateway EniId the NAT gateway's network interface is not created+AWS::EC2::NatGateway RouteTableId availability-mode NAT gateways are not emulated+AWS::EC2::Subnet BlockPublicAccessStates VPC block public access is not emulated+AWS::EC2::Subnet Ipv6CidrBlocks IPv6 CIDR association is not emulated+AWS::EC2::Subnet NetworkAclAssociationId the subnet's default network ACL association is not created with the subnetAWS::EC2::VPC CidrBlockAssociations needs association ids Floci's VPC model does not trackAWS::EC2::VPC DefaultNetworkAcl needs a default network ACL Floci does not create with the VPCAWS::EC2::VPC Ipv6CidrBlocks IPv6 CIDR association is not emulateddiff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex b404f437d1..a29e5e930e 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -39,22 +39,22 @@ AWS::Cognito::UserPoolDomain CognitoCfnProvisionerAWS::Config::ConfigRule ConfigCfnProvisionerAWS::DynamoDB::GlobalTable LEGACY_SWITCHAWS::DynamoDB::Table LEGACY_SWITCH-AWS::EC2::EIP LEGACY_SWITCH+AWS::EC2::EIP Ec2NetworkCfnProvisionerAWS::EC2::FlowLog Ec2FlowLogCfnProvisionerAWS::EC2::Instance LEGACY_SWITCH-AWS::EC2::InternetGateway LEGACY_SWITCH+AWS::EC2::InternetGateway Ec2NetworkCfnProvisionerAWS::EC2::LaunchTemplate Ec2LaunchTemplateCfnProvisioner-AWS::EC2::NatGateway LEGACY_SWITCH+AWS::EC2::NatGateway Ec2NetworkCfnProvisionerAWS::EC2::NetworkAcl Ec2NetworkAclCfnProvisionerAWS::EC2::NetworkAclEntry Ec2NetworkAclCfnProvisioner-AWS::EC2::Route LEGACY_SWITCH-AWS::EC2::RouteTable LEGACY_SWITCH+AWS::EC2::Route Ec2NetworkCfnProvisioner+AWS::EC2::RouteTable Ec2NetworkCfnProvisionerAWS::EC2::SecurityGroup LEGACY_SWITCHAWS::EC2::SecurityGroupEgress Ec2SecurityGroupRuleCfnProvisionerAWS::EC2::SecurityGroupIngress Ec2SecurityGroupRuleCfnProvisioner-AWS::EC2::Subnet LEGACY_SWITCH+AWS::EC2::Subnet Ec2NetworkCfnProvisionerAWS::EC2::SubnetNetworkAclAssociation Ec2NetworkAclCfnProvisioner-AWS::EC2::SubnetRouteTableAssociation LEGACY_SWITCH+AWS::EC2::SubnetRouteTableAssociation Ec2NetworkCfnProvisionerAWS::EC2::VPC Ec2VpcCfnProvisionerAWS::EC2::VPCEndpoint Ec2VpcEndpointCfnProvisionerAWS::EC2::VPCGatewayAttachment Ec2VpcGatewayAttachmentCfnProvisioner