Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): identify Lambda microVM images and network connectors by ARN (#4971)
Hector Venturabe2998f2a22e
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.javaindex 2bce59988d..550c82aaaa 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java@@ -140,6 +140,13 @@ public final class CfnRollback {*/public static final String LAUNCH_TEMPLATE_UPDATE_SNAPSHOT_ATTR = "__FlociLaunchTemplateUpdateSnapshot";+ /**+ * Holds the settings a Lambda MicroVMs network connector had before an in-place update changed+ * them, so a failed stack update can put them back. Written by {@code LambdaMicrovmsCfnProvisioner}+ * before its update call and spent by its {@code rollbackUpdate}.+ */+ public static final String NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR = "__FlociNetworkConnectorUpdateSnapshot";+private CfnRollback() {}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisioner.javaindex 371d7eb668..9a9327fe24 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisioner.java@@ -1,14 +1,22 @@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.services.cloudformation.model.StackResource;import io.github.hectorvent.floci.services.lambdamicrovms.LambdaMicrovmsService;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import java.util.ArrayList;+import java.util.HashMap;import java.util.List;+import java.util.Map;import java.util.Set;+import java.util.UUID;+import java.util.regex.Matcher;+import java.util.regex.Pattern;/*** CloudFormation provisioning for AWS Lambda MicroVMs:@@ -20,10 +28,22 @@ import java.util.Set;* group's {@code GroupId} — each array element resolves through the engine* individually. An image's {@code EgressNetworkConnectors} likewise arrive as* references to connector ARNs.</p>+ *+ * <p>Both types are identified by their ARN, the registry schemas' primaryIdentifier, so {@code Ref}+ * returns it. {@code Name} is the only createOnly property of either: an update that keeps it+ * reconciles the existing entity in place, and one that changes it creates a replacement and the+ * displaced entity is deleted once the update commits, through {@link ReplacementCleanup}. Removing+ * an explicit {@code Name} is such a change: the resource is replaced under a generated name. An+ * in-place connector update is snapshotted first, so a failed stack update puts it back.</p>*/@ApplicationScopedpublic class LambdaMicrovmsCfnProvisioner implements CfnResourceProvisioner {+ private static final String NETWORK_CONNECTOR = "AWS::Lambda::NetworkConnector";+ private static final ObjectMapper MAPPER = new ObjectMapper();+ /** The shape {@link ProvisionContext#generatePhysicalName} gives a name: a stack-and-id prefix, a hex token. */+ private static final Pattern GENERATED_NAME = Pattern.compile("(?:(.*)-)?[0-9a-f]{12}");+private final LambdaMicrovmsService microvmsService;@Inject@@ -49,16 +69,71 @@ public class LambdaMicrovmsCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void delete(String resourceType, String physicalId, String region) {switch (resourceType) {- case "AWS::Lambda::MicrovmImage" -> microvmsService.deleteImage(region, physicalId);- case "AWS::Lambda::NetworkConnector" -> microvmsService.deleteConnector(region, physicalId);+ case "AWS::Lambda::MicrovmImage" -> CfnDeletes.safeDelete("MicroVM image", physicalId,+ () -> microvmsService.deleteImage(region, physicalId), "ResourceNotFoundException");+ case "AWS::Lambda::NetworkConnector" -> CfnDeletes.safeDelete("network connector", physicalId,+ () -> microvmsService.deleteConnector(region, physicalId), "ResourceNotFoundException");default -> { }}}+ @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) {+ return ReplacementCleanup.complete(resource, this::delete);+ }++ @Override+ public void clearUpdate(StackResource resource) {+ resource.getAttributes().remove(CfnRollback.NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR);+ ReplacementCleanup.clear(resource);+ }++ /**+ * A replacement is undone through the cleanup record, and an in-place connector update from the+ * snapshot taken before it; a connector with neither changed nothing. An image updated in place+ * keeps no snapshot and is still reported as not rolled back.+ */+ @Override+ public boolean rollbackUpdate(StackResource resource) {+ if (ReplacementCleanup.rollback(resource, this::delete)) {+ return true;+ }+ if (!NETWORK_CONNECTOR.equals(resource.getResourceType())) {+ return false;+ }+ // Spent only once the restore succeeded, so a restore that throws can be retried.+ String raw = resource.getAttributes().get(CfnRollback.NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR);+ if (raw == null) {+ return true;+ }+ JsonNode snapshot;+ try {+ snapshot = MAPPER.readTree(raw);+ } catch (JsonProcessingException e) {+ throw new IllegalStateException("Could not read the network connector update snapshot for "+ + resource.getLogicalId(), e);+ }+ microvmsService.updateConnector(snapshot.path("region").asText(), snapshot.path("arn").asText(),+ textList(snapshot.path("subnetIds")), textList(snapshot.path("securityGroupIds")),+ snapshot.path("operatorRole").asText(null), snapshot.path("networkProtocol").asText(null),+ textList(snapshot.path("associatedComputeResourceTypes")));+ resource.getAttributes().remove(CfnRollback.NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR);+ return true;+ }+private void provisionImage(StackResource r, JsonNode props, ProvisionContext ctx) {- // Name is a createOnlyProperty and the physical id, so an unnamed image keeps the name it- // already had across updates instead of a fresh one each time provision runs.- String name = ctx.stablePhysicalName(ctx.resolveOptional(props, "Name"), r.getLogicalId(), 64, false);+ String priorName = r.getAttributes().get("Name");+ String name = nameOrPrior(ctx.resolveOptional(props, "Name"), priorName, r, ctx);String codeArtifactUri = null;if (props != null && props.has("CodeArtifact") && props.get("CodeArtifact").has("Uri")) {codeArtifactUri = ctx.engine().resolve(props.get("CodeArtifact").get("Uri"));@@ -70,12 +145,14 @@ public class LambdaMicrovmsCfnProvisioner implements CfnResourceProvisioner {// the service with an image that exists; the registry schema's update handler is// UpdateMicrovmImage, so reconcile through updateImage rather than mint a version through// createImage. A replacing update derives a different name and still creates.- LambdaMicrovmsService.MicrovmImage image = ctx.reusesPriorEntity(name)+ boolean reused = ctx.isUpdate() && name.equals(priorName);+ Map<String, String> attributesBefore = new HashMap<>(r.getAttributes());+ LambdaMicrovmsService.MicrovmImage image = reused? microvmsService.updateImage(ctx.region(), name, baseImageArn, buildRoleArn,codeArtifactUri, description): microvmsService.createImage(ctx.region(), ctx.accountId(), name, baseImageArn,buildRoleArn, codeArtifactUri, description);- r.setPhysicalId(image.name);+ settle(r, ctx, attributesBefore, reused, image.imageArn);r.getAttributes().put("ImageArn", image.imageArn);r.getAttributes().put("Arn", image.imageArn);r.getAttributes().put("Name", image.name);@@ -83,10 +160,10 @@ public class LambdaMicrovmsCfnProvisioner implements CfnResourceProvisioner {}private void provisionConnector(StackResource r, JsonNode props, ProvisionContext ctx) {- String name = ctx.resolveOptional(props, "Name");- if (name == null || name.isBlank()) {- name = ctx.generatePhysicalName(r.getLogicalId(), 64, false);- }+ // A snapshot describes the update in flight; one an earlier update left behind is stale.+ r.getAttributes().remove(CfnRollback.NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR);+ String priorName = r.getAttributes().get("Name");+ String name = nameOrPrior(ctx.resolveOptional(props, "Name"), priorName, r, ctx);JsonNode vpc = props == null? null: props.path("Configuration").path("VpcEgressConfiguration");@@ -94,22 +171,96 @@ public class LambdaMicrovmsCfnProvisioner implements CfnResourceProvisioner {if (vpc != null && vpc.has("NetworkProtocol")) {networkProtocol = ctx.engine().resolve(vpc.get("NetworkProtocol"));}- LambdaMicrovmsService.NetworkConnector connector = microvmsService.createConnector(- ctx.region(),- ctx.accountId(),- name,- resolveList(vpc == null ? null : vpc.get("SubnetIds"), ctx),- resolveList(vpc == null ? null : vpc.get("SecurityGroupIds"), ctx),- ctx.resolveOptional(props, "OperatorRole"),- java.util.UUID.randomUUID().toString(),- resolveList(vpc == null ? null : vpc.get("AssociatedComputeResourceTypes"), ctx),- networkProtocol);- r.setPhysicalId(connector.id);+ List<String> subnetIds = resolveList(vpc == null ? null : vpc.get("SubnetIds"), ctx);+ List<String> securityGroupIds = resolveList(vpc == null ? null : vpc.get("SecurityGroupIds"), ctx);+ String operatorRole = ctx.resolveOptional(props, "OperatorRole");+ List<String> computeResourceTypes =+ resolveList(vpc == null ? null : vpc.get("AssociatedComputeResourceTypes"), ctx);+ // The schema's update handler is UpdateNetworkConnector, so an update that keeps the name+ // reconciles the connector it already has instead of creating a second one.+ boolean reused = ctx.isUpdate() && name.equals(priorName);+ Map<String, String> attributesBefore = new HashMap<>(r.getAttributes());+ LambdaMicrovmsService.NetworkConnector connector;+ if (reused) {+ snapshotConnector(r, ctx);+ connector = microvmsService.updateConnector(ctx.region(), ctx.priorPhysicalId(), subnetIds,+ securityGroupIds, operatorRole, networkProtocol, computeResourceTypes);+ } else {+ connector = microvmsService.createConnector(ctx.region(), ctx.accountId(), name, subnetIds,+ securityGroupIds, operatorRole, UUID.randomUUID().toString(), computeResourceTypes,+ networkProtocol);+ }+ settle(r, ctx, attributesBefore, reused, connector.arn);r.getAttributes().put("Arn", connector.arn);r.getAttributes().put("Id", connector.id);r.getAttributes().put("Name", connector.name);}+ /** Records the connector's settings before an in-place update, for {@link #rollbackUpdate}. */+ private void snapshotConnector(StackResource r, ProvisionContext ctx) {+ LambdaMicrovmsService.NetworkConnector current =+ microvmsService.getConnector(ctx.region(), ctx.priorPhysicalId());+ ObjectNode snapshot = MAPPER.createObjectNode();+ snapshot.put("region", ctx.region());+ snapshot.put("arn", current.arn);+ current.subnetIds.forEach(snapshot.putArray("subnetIds")::add);+ current.securityGroupIds.forEach(snapshot.putArray("securityGroupIds")::add);+ snapshot.put("operatorRole", current.operatorRole);+ snapshot.put("networkProtocol", current.networkProtocol);+ current.associatedComputeResourceTypes.forEach(snapshot.putArray("associatedComputeResourceTypes")::add);+ r.getAttributes().put(CfnRollback.NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR, snapshot.toString());+ }++ private static List<String> textList(JsonNode node) {+ List<String> out = new ArrayList<>();+ node.forEach(item -> out.add(item.asText()));+ return out;+ }++ /**+ * The template's name when it gives one, otherwise the generated name this resource already had,+ * and only failing both a fresh generated one. The physical id is the ARN, so the prior name comes+ * from the {@code Name} attribute recorded at create time. A prior name that was declared, not+ * generated, is not kept when the template drops it: {@code Name} is createOnly, so removing it+ * replaces the resource, as CloudFormation does.+ */+ private static String nameOrPrior(String declared, String prior, StackResource r, ProvisionContext ctx) {+ if (declared != null && !declared.isBlank()) {+ return declared;+ }+ if (ctx.isUpdate() && prior != null && wasGenerated(prior, ctx.stackName(), r.getLogicalId())) {+ return prior;+ }+ return ctx.generatePhysicalName(r.getLogicalId(), 64, false);+ }++ /** Whether {@code name} has the shape this resource's generated names have, truncation included. */+ static boolean wasGenerated(String name, String stackName, String logicalId) {+ Matcher matcher = GENERATED_NAME.matcher(name);+ if (!matcher.matches()) {+ return false;+ }+ String prefix = matcher.group(1);+ return prefix == null || (stackName + "-" + logicalId).startsWith(prefix);+ }++ /**+ * Sets the ARN as the physical id and records any replacement. A reuse records before the id+ * changes: a stack created when the physical id was still the image name or connector id names+ * the entity it reuses by that, and recording after the switch would mark it displaced and+ * delete it once the update commits.+ */+ private static void settle(StackResource r, ProvisionContext ctx, Map<String, String> attributesBefore,+ boolean reused, String arn) {+ if (reused) {+ ReplacementCleanup.record(r, ctx, attributesBefore);+ r.setPhysicalId(arn);+ return;+ }+ r.setPhysicalId(arn);+ ReplacementCleanup.record(r, ctx, attributesBefore);+ }+/** Resolves each array element through the engine so intrinsic refs work per entry. */private List<String> resolveList(JsonNode node, ProvisionContext ctx) {if (node == null || !node.isArray()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsService.java b/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsService.javaindex 5cd176d989..e3ff1e5b07 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsService.java@@ -486,8 +486,15 @@ public class LambdaMicrovmsService {.toList();}+ /**+ * UpdateNetworkConnector: every member is optional and a null one leaves the connector's value+ * as it is. The model lets an update change the operator role, the network protocol and the+ * associated compute resource types as well as the subnets and security groups.+ */public NetworkConnector updateConnector(String region, String id,- List<String> subnetIds, List<String> securityGroupIds) {+ List<String> subnetIds, List<String> securityGroupIds,+ String operatorRole, String networkProtocol,+ List<String> computeResourceTypes) {NetworkConnector connector = getConnector(region, id);if (subnetIds != null && !subnetIds.isEmpty()) {if (subnetIds.size() > MAX_CONNECTOR_SUBNETS) {@@ -502,6 +509,18 @@ public class LambdaMicrovmsService {if (securityGroupIds != null) {connector.securityGroupIds = List.copyOf(securityGroupIds);}+ if (operatorRole != null && !operatorRole.isBlank()) {+ connector.operatorRole = operatorRole;+ connector.lastModified = Instant.now();+ }+ if (networkProtocol != null && !networkProtocol.isBlank()) {+ connector.networkProtocol = networkProtocol;+ connector.lastModified = Instant.now();+ }+ if (computeResourceTypes != null && !computeResourceTypes.isEmpty()) {+ connector.associatedComputeResourceTypes = List.copyOf(computeResourceTypes);+ connector.lastModified = Instant.now();+ }persist(connectors, region, connector.id, connector);return connector;}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaNetworkConnectorsController.java b/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaNetworkConnectorsController.javaindex 626e86e9f3..1371b641e2 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaNetworkConnectorsController.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaNetworkConnectorsController.java@@ -99,7 +99,9 @@ public class LambdaNetworkConnectorsController {JsonNode request = parse(body);JsonNode vpc = request.path("Configuration").path("VpcEgressConfiguration");NetworkConnector connector = service.updateConnector(- region, identifier, stringList(vpc.path("SubnetIds")), stringList(vpc.path("SecurityGroupIds")));+ region, identifier, stringList(vpc.path("SubnetIds")), stringList(vpc.path("SecurityGroupIds")),+ text(request, "OperatorRole"), text(vpc, "NetworkProtocol"),+ stringList(vpc.path("AssociatedComputeResourceTypes")));return Response.status(202).entity(connectorNode(connector, ConnectorShape.UPDATE)).build();}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLambdaMicrovmsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLambdaMicrovmsIntegrationTest.javaindex 6131c351ca..e0037aa9e3 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLambdaMicrovmsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationLambdaMicrovmsIntegrationTest.java@@ -1,12 +1,17 @@package io.github.hectorvent.floci.services.cloudformation;+import io.github.hectorvent.floci.core.common.XmlParser;import io.quarkus.test.junit.QuarkusTest;import org.junit.jupiter.api.Test;+import java.util.Map;+import static io.restassured.RestAssured.given;import static org.awaitility.Awaitility.await;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;/*** End-to-end check that CloudFormation provisions {@code AWS::Lambda::MicrovmImage} and@@ -118,4 +123,110 @@ class CloudFormationLambdaMicrovmsIntegrationTest {.then().statusCode(404));}++ @Test+ void refReturnsTheArnsAndAnUpdateKeepsTheConnector() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-microvm-ref-" + suffix;+ String connectorName = "cfn-microvm-ref-connector-" + suffix;++ cloudFormation(stackName, "CreateStack", refTemplate(connectorName, "subnet-0cfn000000000001"));+ Map<String, String> created = outputs(describeStacks(stackName, "CREATE_COMPLETE"));+ String connectorArn = created.get("ConnectorArn");+ assertTrue(connectorArn.contains(":network-connector:nc-"), connectorArn);+ assertEquals(connectorArn, created.get("ConnectorRef"), "Ref is the connector ARN, its primaryIdentifier");+ assertEquals(created.get("ImageArn"), created.get("ImageRef"), "Ref is the image ARN, its primaryIdentifier");++ cloudFormation(stackName, "UpdateStack", refTemplate(connectorName, "subnet-0cfn000000000002"));+ Map<String, String> updated = outputs(describeStacks(stackName, "UPDATE_COMPLETE"));+ assertEquals(connectorArn, updated.get("ConnectorRef"), "a subnet change updates the connector in place");+ given()+ .when()+ .get("/2026-04-04/network-connectors/" + connectorArn)+ .then()+ .statusCode(200)+ .body("Name", equalTo(connectorName))+ .body("Configuration.VpcEgressConfiguration.SubnetIds[0]", equalTo("subnet-0cfn000000000002"));++ cloudFormation(stackName, "DeleteStack", null);+ await().untilAsserted(() ->+ given()+ .when()+ .get("/2026-04-04/network-connectors/" + connectorArn)+ .then()+ .statusCode(404));+ }++ private static String refTemplate(String connectorName, String subnetId) {+ return """+ {+ "Resources": {+ "Connector": {+ "Type": "AWS::Lambda::NetworkConnector",+ "Properties": {+ "Name": "%s",+ "OperatorRole": "arn:aws:iam::000000000000:role/cfn-microvm-connector-operator",+ "Configuration": {+ "VpcEgressConfiguration": {+ "AssociatedComputeResourceTypes": ["MicroVm"],+ "SubnetIds": ["%s"],+ "SecurityGroupIds": ["sg-0cfn000000000001"],+ "NetworkProtocol": "IPv4"+ }+ }+ }+ },+ "Image": {+ "Type": "AWS::Lambda::MicrovmImage",+ "Properties": {+ "BaseImageArn": "arn:aws:lambda:us-east-1:aws:microvm-image:al2023-1",+ "BuildRoleArn": "arn:aws:iam::000000000000:role/cfn-microvm-build",+ "CodeArtifact": { "Uri": "s3://cfn-bucket/context.zip" },+ "Description": "cfn ref image"+ }+ }+ },+ "Outputs": {+ "ImageRef": {"Value": {"Ref": "Image"}},+ "ImageArn": {"Value": {"Fn::GetAtt": ["Image", "ImageArn"]}},+ "ConnectorRef": {"Value": {"Ref": "Connector"}},+ "ConnectorArn": {"Value": {"Fn::GetAtt": ["Connector", "Arn"]}}+ }+ }+ """.formatted(connectorName, subnetId);+ }++ private static void cloudFormation(String stackName, String action, String templateBody) {+ if (templateBody == null) {+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", action)+ .formParam("StackName", stackName)+ .when().post("/").then().statusCode(200);+ return;+ }+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", action)+ .formParam("StackName", stackName)+ .formParam("TemplateBody", templateBody)+ .when().post("/").then().statusCode(200);+ }++ private static String describeStacks(String stackName, String expectedStatus) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stackName)+ .when().post("/").then().statusCode(200)+ .body(containsString("<StackStatus>" + expectedStatus + "</StackStatus>"))+ .extract().asString();+ }++ private static Map<String, String> outputs(String describeStacksXml) {+ return XmlParser.extractPairs(describeStacksXml, "Outputs", "OutputKey", "OutputValue");+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnStableNameUpdatePathTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnStableNameUpdatePathTest.javaindex 1ee4520ff6..b7becd13a4 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnStableNameUpdatePathTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnStableNameUpdatePathTest.java@@ -273,12 +273,17 @@ class CfnStableNameUpdatePathTest {StackResource created = resource("AWS::Lambda::MicrovmImage", "Image");provisioner.provision(created, props, ctx(null));- String generatedName = created.getPhysicalId();+ String generatedName = created.getAttributes().get("Name");+ // The physical id is the image ARN, so the update carries the prior attributes the way+ // CfnResourceDispatcher does, and the name comes back from the recorded Name attribute.StackResource updated = resource("AWS::Lambda::MicrovmImage", "Image");- provisioner.provision(updated, props, ctx(generatedName));+ updated.setPhysicalId(created.getPhysicalId());+ updated.setAttributes(new HashMap<>(created.getAttributes()));+ provisioner.provision(updated, props, ctx(created.getPhysicalId()));- assertEquals(generatedName, updated.getPhysicalId(), "the generated name must stay stable");+ assertEquals(created.getPhysicalId(), updated.getPhysicalId(), "the image ARN must stay stable");+ assertEquals(generatedName, updated.getAttributes().get("Name"), "the generated name must stay stable");// createImage on an existing image silently mints a new version rather than rejecting, so// here the assertion is that the update went to the schema's update handler instead.verify(microvms, times(1)).createImage(anyString(), anyString(), eq(generatedName), any(), any(), any(), any());diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisionerTest.javaindex 1927251b70..dea3ad3f54 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/LambdaMicrovmsCfnProvisionerTest.java@@ -3,16 +3,23 @@ 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.core.common.AwsException;import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;import io.github.hectorvent.floci.services.cloudformation.model.StackResource;import io.github.hectorvent.floci.services.lambdamicrovms.LambdaMicrovmsService;import org.junit.jupiter.api.Test;+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.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doThrow;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.never;import static org.mockito.Mockito.times;@@ -20,15 +27,19 @@ import static org.mockito.Mockito.verify;import static org.mockito.Mockito.when;/**- * {@code AWS::Lambda::MicrovmImage} in isolation. Name is a createOnlyProperty in the registry- * schema and the physical id, so an unnamed image must keep its generated name across updates and- * the update must go through UpdateMicrovmImage, the schema's update handler, rather than mint a- * fresh version through create.+ * {@code AWS::Lambda::MicrovmImage} and {@code AWS::Lambda::NetworkConnector} in isolation. Both are+ * identified by their ARN (the registry schemas' primaryIdentifier), and {@code Name} is the only+ * createOnly property of either: an update that keeps it goes through the schema's update handler,+ * one that changes it creates a replacement and deletes the displaced entity after the commit.*/class LambdaMicrovmsCfnProvisionerTest {+ private static final String REGION = "us-east-1";+ private static final String IMAGE_TYPE = "AWS::Lambda::MicrovmImage";+ private static final String CONNECTOR_TYPE = "AWS::Lambda::NetworkConnector";private static final String BASE_IMAGE = "arn:aws:lambda:us-east-1::base-image:nodejs";private static final String BUILD_ROLE = "arn:aws:iam::000000000000:role/build";+ private static final String OPERATOR_ROLE = "arn:aws:iam::000000000000:role/operator";private static final String CODE_URI = "s3://bucket/code.zip";private final LambdaMicrovmsService service = mock(LambdaMicrovmsService.class);@@ -41,17 +52,26 @@ class LambdaMicrovmsCfnProvisionerTest {JsonNode node = inv.getArgument(0);return node == null ? null : node.asText();});- return new ProvisionContext(engine, "us-east-1", "000000000000", "my-stack", priorPhysicalId);+ return new ProvisionContext(engine, REGION, "000000000000", "my-stack", priorPhysicalId);}- private StackResource resource() {+ private static StackResource resource(String type) {StackResource r = new StackResource();- r.setLogicalId("MyImage");- r.setResourceType("AWS::Lambda::MicrovmImage");+ r.setLogicalId("Res");+ r.setResourceType(type);+ r.setAttributes(new HashMap<>());return r;}- private ObjectNode props(String name) {+ /** What CfnResourceDispatcher hands provision on UpdateStack: the prior physical id and attributes. */+ private static StackResource updateOf(StackResource prior) {+ StackResource r = resource(prior.getResourceType());+ r.setPhysicalId(prior.getPhysicalId());+ r.setAttributes(new HashMap<>(prior.getAttributes()));+ return r;+ }++ private ObjectNode imageProps(String name) {ObjectNode props = mapper.createObjectNode().put("BaseImageArn", BASE_IMAGE).put("BuildRoleArn", BUILD_ROLE)@@ -63,59 +83,257 @@ class LambdaMicrovmsCfnProvisionerTest {return props;}+ private ObjectNode connectorProps(String name, String subnet) {+ ObjectNode props = mapper.createObjectNode().put("OperatorRole", OPERATOR_ROLE);+ if (name != null) {+ props.put("Name", name);+ }+ ObjectNode vpc = props.putObject("Configuration").putObject("VpcEgressConfiguration");+ vpc.put("NetworkProtocol", "IPv4");+ vpc.putArray("SubnetIds").add(subnet);+ vpc.putArray("SecurityGroupIds").add("sg-1");+ vpc.putArray("AssociatedComputeResourceTypes").add("MICROVM");+ return props;+ }++ private static String imageArn(String name) {+ return "arn:aws:lambda:us-east-1:000000000000:microvm-image:" + name;+ }+private static LambdaMicrovmsService.MicrovmImage image(String name, String version) {LambdaMicrovmsService.MicrovmImage image = new LambdaMicrovmsService.MicrovmImage();image.name = name;- image.imageArn = "arn:aws:lambda:us-east-1:000000000000:microvm-image:" + name;+ image.imageArn = imageArn(name);image.latestActiveImageVersion = version;return image;}+ private static LambdaMicrovmsService.NetworkConnector connector(String id, String name) {+ LambdaMicrovmsService.NetworkConnector connector = new LambdaMicrovmsService.NetworkConnector();+ connector.id = id;+ connector.name = name;+ connector.arn = "arn:aws:lambda:us-east-1:000000000000:network-connector:" + id;+ connector.subnetIds = List.of("subnet-1");+ connector.securityGroupIds = List.of("sg-1");+ connector.operatorRole = OPERATOR_ROLE;+ connector.networkProtocol = "IPv4";+ connector.associatedComputeResourceTypes = List.of("MICROVM");+ return connector;+ }++ private void stubImageCreateAndUpdate() {+ when(service.createImage(anyString(), anyString(), anyString(), any(), any(), any(), any()))+ .thenAnswer(inv -> image(inv.getArgument(2), "1.0"));+ when(service.updateImage(anyString(), anyString(), any(), any(), any(), any()))+ .thenAnswer(inv -> image(inv.getArgument(1), "2.0"));+ }+@Test- void createSetsThePhysicalIdAndTheGetAttAttributes() {- when(service.createImage(eq("us-east-1"), eq("000000000000"), eq("img"), eq(BASE_IMAGE),+ void imageRefIsTheImageArnAndTheGetAttAttributesAreSet() {+ when(service.createImage(eq(REGION), eq("000000000000"), eq("img"), eq(BASE_IMAGE),eq(BUILD_ROLE), eq(CODE_URI), eq("an image"))).thenReturn(image("img", "1.0"));- StackResource r = resource();+ StackResource r = resource(IMAGE_TYPE);- provisioner.provision(r, props("img"), ctx(null));+ provisioner.provision(r, imageProps("img"), ctx(null));- assertEquals("img", r.getPhysicalId());- assertEquals("arn:aws:lambda:us-east-1:000000000000:microvm-image:img", r.getAttributes().get("ImageArn"));- assertEquals("arn:aws:lambda:us-east-1:000000000000:microvm-image:img", r.getAttributes().get("Arn"));+ assertEquals(imageArn("img"), r.getPhysicalId());+ assertEquals(imageArn("img"), r.getAttributes().get("ImageArn"));+ assertEquals(imageArn("img"), r.getAttributes().get("Arn"));assertEquals("img", r.getAttributes().get("Name"));assertEquals("1.0", r.getAttributes().get("LatestActiveImageVersion"));}@Testvoid anUnnamedImageKeepsItsNameAndIsUpdatedRatherThanRecreated() {- when(service.createImage(anyString(), anyString(), anyString(), any(), any(), any(), any()))- .thenAnswer(inv -> image(inv.getArgument(2), "1.0"));- when(service.updateImage(anyString(), anyString(), any(), any(), any(), any()))- .thenAnswer(inv -> image(inv.getArgument(1), "2.0"));- StackResource created = resource();- provisioner.provision(created, props(null), ctx(null));- String generatedName = created.getPhysicalId();- assertTrue(generatedName.startsWith("my-stack-MyImage-"), generatedName);+ stubImageCreateAndUpdate();+ StackResource created = resource(IMAGE_TYPE);+ provisioner.provision(created, imageProps(null), ctx(null));+ String generatedName = created.getAttributes().get("Name");+ assertTrue(generatedName.startsWith("my-stack-Res-"), generatedName);- StackResource updated = resource();- provisioner.provision(updated, props(null), ctx(generatedName));+ StackResource updated = updateOf(created);+ provisioner.provision(updated, imageProps(null), ctx(created.getPhysicalId()));- assertEquals(generatedName, updated.getPhysicalId());+ assertEquals(imageArn(generatedName), updated.getPhysicalId());assertEquals("2.0", updated.getAttributes().get("LatestActiveImageVersion"));+ assertFalse(provisioner.hasReplacementUpdate(updated));verify(service, times(1)).createImage(anyString(), anyString(), anyString(), any(), any(), any(), any());- verify(service).updateImage("us-east-1", generatedName, BASE_IMAGE, BUILD_ROLE, CODE_URI, "an image");+ verify(service).updateImage(REGION, generatedName, BASE_IMAGE, BUILD_ROLE, CODE_URI, "an image");}@Test- void aRenamedImageIsAReplacingUpdateAndStillCreates() {- when(service.createImage(anyString(), anyString(), anyString(), any(), any(), any(), any()))- .thenAnswer(inv -> image(inv.getArgument(2), "1.0"));- StackResource r = resource();+ void aRenamedImageIsReplacedAndTheDisplacedOneDeletedAfterTheCommit() {+ stubImageCreateAndUpdate();+ StackResource created = resource(IMAGE_TYPE);+ provisioner.provision(created, imageProps("old-name"), ctx(null));- provisioner.provision(r, props("renamed"), ctx("old-name"));+ StackResource updated = updateOf(created);+ provisioner.provision(updated, imageProps("renamed"), ctx(created.getPhysicalId()));- assertEquals("renamed", r.getPhysicalId());- verify(service).createImage(eq("us-east-1"), eq("000000000000"), eq("renamed"), any(), any(), any(), any());+ assertEquals(imageArn("renamed"), updated.getPhysicalId());verify(service, never()).updateImage(anyString(), anyString(), any(), any(), any(), any());+ assertTrue(provisioner.hasReplacementUpdate(updated));+ assertEquals(imageArn("old-name"), provisioner.updateCleanupPhysicalId(updated));++ assertTrue(provisioner.completeUpdate(updated).complete());+ verify(service).deleteImage(REGION, imageArn("old-name"));+ }++ @Test+ void anImageFromAStackThatStoredItsNameIsReusedAndOnlyItsIdMovesToTheArn() {+ stubImageCreateAndUpdate();+ StackResource legacy = resource(IMAGE_TYPE);+ legacy.setPhysicalId("img");+ legacy.getAttributes().put("Name", "img");+ legacy.getAttributes().put("ImageArn", imageArn("img"));++ StackResource updated = updateOf(legacy);+ provisioner.provision(updated, imageProps("img"), ctx("img"));++ assertEquals(imageArn("img"), updated.getPhysicalId());+ assertFalse(provisioner.hasReplacementUpdate(updated), "the reused image must not be marked displaced");+ verify(service).updateImage(REGION, "img", BASE_IMAGE, BUILD_ROLE, CODE_URI, "an image");+ verify(service, never()).createImage(anyString(), anyString(), anyString(), any(), any(), any(), any());+ }++ @Test+ void connectorRefIsTheConnectorArnAndTheGetAttAttributesAreSet() {+ when(service.createConnector(eq(REGION), eq("000000000000"), eq("nc"), eq(List.of("subnet-1")),+ eq(List.of("sg-1")), eq(OPERATOR_ROLE), anyString(), eq(List.of("MICROVM")), eq("IPv4")))+ .thenReturn(connector("nc-1", "nc"));+ StackResource r = resource(CONNECTOR_TYPE);++ provisioner.provision(r, connectorProps("nc", "subnet-1"), ctx(null));++ String arn = connector("nc-1", "nc").arn;+ assertEquals(arn, r.getPhysicalId());+ assertEquals(arn, r.getAttributes().get("Arn"));+ assertEquals("nc-1", r.getAttributes().get("Id"));+ assertEquals("nc", r.getAttributes().get("Name"));+ }++ @Test+ void aConnectorUpdateThatKeepsTheNameUpdatesTheExistingConnector() {+ when(service.createConnector(anyString(), anyString(), anyString(), any(), any(), any(), anyString(), any(),+ any())).thenAnswer(inv -> connector("nc-1", inv.getArgument(2)));+ StackResource created = resource(CONNECTOR_TYPE);+ provisioner.provision(created, connectorProps(null, "subnet-1"), ctx(null));+ String name = created.getAttributes().get("Name");+ when(service.getConnector(REGION, created.getPhysicalId())).thenReturn(connector("nc-1", name));+ when(service.updateConnector(REGION, created.getPhysicalId(), List.of("subnet-2"), List.of("sg-1"),+ OPERATOR_ROLE, "IPv4", List.of("MICROVM"))).thenReturn(connector("nc-1", name));++ StackResource updated = updateOf(created);+ provisioner.provision(updated, connectorProps(null, "subnet-2"), ctx(created.getPhysicalId()));++ assertEquals(created.getPhysicalId(), updated.getPhysicalId());+ assertFalse(provisioner.hasReplacementUpdate(updated));+ verify(service, times(1)).createConnector(anyString(), anyString(), anyString(), any(), any(), any(),+ anyString(), any(), any());+ verify(service).updateConnector(REGION, created.getPhysicalId(), List.of("subnet-2"), List.of("sg-1"),+ OPERATOR_ROLE, "IPv4", List.of("MICROVM"));+ }++ @Test+ void anInPlaceConnectorUpdateAppliesEverySettingAndRollsBackFromItsSnapshot() {+ String arn = connector("nc-1", "nc").arn;+ StackResource prior = resource(CONNECTOR_TYPE);+ prior.setPhysicalId(arn);+ prior.getAttributes().put("Name", "nc");+ when(service.getConnector(REGION, arn)).thenReturn(connector("nc-1", "nc"));+ when(service.updateConnector(anyString(), anyString(), any(), any(), any(), any(), any()))+ .thenReturn(connector("nc-1", "nc"));+ ObjectNode props = connectorProps("nc", "subnet-2");+ props.put("OperatorRole", "arn:aws:iam::000000000000:role/operator-v2");+ ObjectNode vpc = (ObjectNode) props.path("Configuration").path("VpcEgressConfiguration");+ vpc.put("NetworkProtocol", "DUAL_STACK");++ StackResource updated = updateOf(prior);+ provisioner.provision(updated, props, ctx(arn));++ verify(service).updateConnector(REGION, arn, List.of("subnet-2"), List.of("sg-1"),+ "arn:aws:iam::000000000000:role/operator-v2", "DUAL_STACK", List.of("MICROVM"));+ assertTrue(provisioner.rollbackUpdate(updated));+ verify(service).updateConnector(REGION, arn, List.of("subnet-1"), List.of("sg-1"), OPERATOR_ROLE, "IPv4",+ List.of("MICROVM"));+ assertFalse(updated.getAttributes().containsKey(CfnRollback.NETWORK_CONNECTOR_UPDATE_SNAPSHOT_ATTR),+ "the snapshot is spent");+ }++ @Test+ void droppingAnExplicitConnectorNameReplacesTheConnector() {+ when(service.createConnector(anyString(), anyString(), anyString(), any(), any(), any(), anyString(), any(),+ any())).thenAnswer(inv -> connector("nc-2", inv.getArgument(2)));+ String arn = connector("nc-1", "explicit-name").arn;+ StackResource prior = resource(CONNECTOR_TYPE);+ prior.setPhysicalId(arn);+ prior.getAttributes().put("Name", "explicit-name");++ StackResource updated = updateOf(prior);+ provisioner.provision(updated, connectorProps(null, "subnet-1"), ctx(arn));++ String name = updated.getAttributes().get("Name");+ assertTrue(name.startsWith("my-stack-Res-"), name);+ assertEquals(arn, provisioner.updateCleanupPhysicalId(updated));+ verify(service, never()).updateConnector(anyString(), anyString(), any(), any(), any(), any(), any());+ }++ @Test+ void onlyANameWithTheGeneratedShapeCountsAsGenerated() {+ assertTrue(LambdaMicrovmsCfnProvisioner.wasGenerated("my-stack-Res-0123456789ab", "my-stack", "Res"));+ assertTrue(LambdaMicrovmsCfnProvisioner.wasGenerated("my-sta-0123456789ab", "my-stack", "Res"),+ "a truncated prefix still counts");+ assertFalse(LambdaMicrovmsCfnProvisioner.wasGenerated("explicit-name", "my-stack", "Res"));+ assertFalse(LambdaMicrovmsCfnProvisioner.wasGenerated("other-stack-Res-0123456789ab", "my-stack", "Res"));+ }++ @Test+ void aRenamedConnectorIsReplacedAndTheDisplacedOneDeletedAfterTheCommit() {+ when(service.createConnector(anyString(), anyString(), eq("first"), any(), any(), any(), anyString(), any(),+ any())).thenReturn(connector("nc-1", "first"));+ when(service.createConnector(anyString(), anyString(), eq("second"), any(), any(), any(), anyString(), any(),+ any())).thenReturn(connector("nc-2", "second"));+ StackResource created = resource(CONNECTOR_TYPE);+ provisioner.provision(created, connectorProps("first", "subnet-1"), ctx(null));++ StackResource updated = updateOf(created);+ provisioner.provision(updated, connectorProps("second", "subnet-1"), ctx(created.getPhysicalId()));++ assertEquals(connector("nc-2", "second").arn, updated.getPhysicalId());+ assertEquals(created.getPhysicalId(), provisioner.updateCleanupPhysicalId(updated));+ assertTrue(provisioner.completeUpdate(updated).complete());+ verify(service).deleteConnector(REGION, created.getPhysicalId());+ verify(service, never()).updateConnector(anyString(), anyString(), any(), any(), any(), any(), any());+ }++ @Test+ void aConnectorFromAStackThatStoredItsIdIsReusedAndOnlyItsIdMovesToTheArn() {+ when(service.getConnector(REGION, "nc-1")).thenReturn(connector("nc-1", "nc"));+ when(service.updateConnector(REGION, "nc-1", List.of("subnet-1"), List.of("sg-1"), OPERATOR_ROLE, "IPv4",+ List.of("MICROVM"))).thenReturn(connector("nc-1", "nc"));+ StackResource legacy = resource(CONNECTOR_TYPE);+ legacy.setPhysicalId("nc-1");+ legacy.getAttributes().put("Name", "nc");++ StackResource updated = updateOf(legacy);+ provisioner.provision(updated, connectorProps("nc", "subnet-1"), ctx("nc-1"));++ assertEquals(connector("nc-1", "nc").arn, updated.getPhysicalId());+ assertFalse(provisioner.hasReplacementUpdate(updated), "the reused connector must not be marked displaced");+ verify(service, never()).createConnector(anyString(), anyString(), anyString(), any(), any(), any(),+ anyString(), any(), any());+ }++ @Test+ void deleteToleratesAnAlreadyDeletedEntityButPropagatesARealFailure() {+ String arn = imageArn("img");+ doThrow(new AwsException("ResourceNotFoundException", "gone", 404))+ .when(service).deleteConnector(REGION, "nc-gone");+ doThrow(new AwsException("ValidationException", "Cannot delete microvm image with running microvms.", 400))+ .when(service).deleteImage(REGION, arn);++ provisioner.delete(CONNECTOR_TYPE, "nc-gone", REGION);+ AwsException e = assertThrows(AwsException.class, () -> provisioner.delete(IMAGE_TYPE, arn, REGION));+ assertEquals("ValidationException", e.getErrorCode());}}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsIntegrationTest.javaindex 94d0d2988b..da28ff55b5 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambdamicrovms/LambdaMicrovmsIntegrationTest.java@@ -248,6 +248,28 @@ class LambdaMicrovmsIntegrationTest {.body("State", equalTo("ACTIVE")).body("Name", equalTo("microvm-it-connector"));+ // UpdateNetworkConnector changes the operator role and protocol as well as the subnets.+ given()+ .contentType("application/json")+ .body("""+ {+ "OperatorRole": "arn:aws:iam::000000000000:role/microvm-connector-operator-v2",+ "Configuration": { "VpcEgressConfiguration": { "NetworkProtocol": "DUAL_STACK" } }+ }+ """)+ .when()+ .put(CORE + "/network-connectors/" + connectorId)+ .then()+ .statusCode(202);+ given()+ .when()+ .get(CORE + "/network-connectors/" + connectorId)+ .then()+ .statusCode(200)+ .body("OperatorRole", equalTo("arn:aws:iam::000000000000:role/microvm-connector-operator-v2"))+ .body("Configuration.VpcEgressConfiguration.NetworkProtocol", equalTo("DUAL_STACK"))+ .body("Configuration.VpcEgressConfiguration.SubnetIds[0]", equalTo("subnet-0000000000000it01"));+given().when().delete(CORE + "/network-connectors/" + connectorId)