Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cloudformation): provision AWS::EC2::VPCEndpoint (#1995)
lex00a985fa4640db
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcEndpointCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcEndpointCfnProvisioner.javanew file mode 100644index 0000000000..1f2d0f4095--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcEndpointCfnProvisioner.java@@ -0,0 +1,101 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.ArrayList;+import java.util.List;+import java.util.Set;++/**+ * CloudFormation provisioning for {@code AWS::EC2::VPCEndpoint}.+ *+ * <p>Updates are handled as replacement: a new endpoint is created and the previous one is+ * deleted, so re-deploys do not accumulate orphaned endpoints. {@code Ec2Service} has no+ * modify operation, so mutable-property updates also replace; this matches how the other+ * EC2 networking types behave here while still cleaning up the prior endpoint.+ */+@ApplicationScoped+public class Ec2VpcEndpointCfnProvisioner implements CfnResourceProvisioner {++ /** Same rendering DescribeVpcEndpoints uses, so the attribute reads as the API reports it. */+ private static final DateTimeFormatter ISO_FMT =+ DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC);++ private final Ec2Service ec2Service;++ @Inject+ public Ec2VpcEndpointCfnProvisioner(Ec2Service ec2Service) {+ this.ec2Service = ec2Service;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of("AWS::EC2::VPCEndpoint");+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ String vpcId = ctx.resolveOptional(props, "VpcId");+ String serviceName = ctx.resolveOptional(props, "ServiceName");+ String endpointType = ctx.resolveOptional(props, "VpcEndpointType");+ // Resolve through the engine so Refs/parameters work, not just literal booleans. When the+ // property is absent, pass null and let Ec2Service apply its own default (true for+ // Interface endpoints, false otherwise), matching the AWS default.+ String privateDns = ctx.resolveOptional(props, "PrivateDnsEnabled");+ Boolean privateDnsEnabled = privateDns != null && !privateDns.isBlank()+ ? Boolean.parseBoolean(privateDns)+ : null;+ String previousEndpointId = r.getPhysicalId();+ var endpoint = ec2Service.createVpcEndpoint(ctx.region(), vpcId, serviceName,+ endpointType != null ? endpointType : "Gateway",+ resolveIdList(props, "RouteTableIds", ctx),+ resolveIdList(props, "SubnetIds", ctx),+ resolveIdList(props, "SecurityGroupIds", ctx),+ privateDnsEnabled,+ List.of());+ r.setPhysicalId(endpoint.getVpcEndpointId());+ r.getAttributes().put("Id", endpoint.getVpcEndpointId());+ // An unset attribute resolves to the literal "LogicalId.CreationTimestamp" rather than+ // failing, so leaving it out hands the template a wrong value quietly.+ if (endpoint.getCreationTimestamp() != null) {+ r.getAttributes().put("CreationTimestamp", ISO_FMT.format(endpoint.getCreationTimestamp()));+ }+ if (previousEndpointId != null && !previousEndpointId.equals(endpoint.getVpcEndpointId())) {+ deleteReplacedEndpoint(previousEndpointId, ctx.region());+ }+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ ec2Service.deleteVpcEndpoints(region, List.of(physicalId));+ }++ /** Resolve an array property of Ref/GetAtt entries into plain id strings. */+ private List<String> resolveIdList(JsonNode props, String field, ProvisionContext ctx) {+ List<String> ids = new ArrayList<>();+ if (props != null && props.has(field) && props.get(field).isArray()) {+ for (JsonNode entry : props.get(field)) {+ String id = ctx.engine().resolve(entry);+ if (id != null && !id.isBlank()) ids.add(id);+ }+ }+ return ids;+ }++ private void deleteReplacedEndpoint(String endpointId, String region) {+ try {+ ec2Service.deleteVpcEndpoints(region, List.of(endpointId));+ } catch (AwsException e) {+ if (!"InvalidVpcEndpointId.NotFound".equals(e.getErrorCode()) && e.getHttpStatus() != 404) {+ throw e;+ }+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationVpcEndpointIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationVpcEndpointIntegrationTest.javanew file mode 100644index 0000000000..37b89345c5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationVpcEndpointIntegrationTest.java@@ -0,0 +1,100 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.not;++/**+ * End-to-end check that CloudFormation provisions AWS::EC2::VPCEndpoint for+ * real (issue #1994): the endpoint lands in Ec2Service with its route-table+ * association, and DeleteStack removes it. Metadata-only — Docker-free.+ */+@QuarkusTest+class CloudFormationVpcEndpointIntegrationTest {++ private static final String CFN_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/cloudformation/aws4_request";+ private static final String EC2_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/ec2/aws4_request";++ @Test+ void createStackProvisionsGatewayEndpointAndDeleteRemovesIt() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-vpce-stack-" + suffix;++ String template = """+ {+ "Resources": {+ "Vpc": {"Type": "AWS::EC2::VPC", "Properties": {"CidrBlock": "10.60.0.0/16"}},+ "Rt": {"Type": "AWS::EC2::RouteTable", "Properties": {"VpcId": {"Ref": "Vpc"}}},+ "S3Endpoint": {+ "Type": "AWS::EC2::VPCEndpoint",+ "Properties": {+ "VpcId": {"Ref": "Vpc"},+ "ServiceName": "com.amazonaws.us-east-1.s3",+ "VpcEndpointType": "Gateway",+ "RouteTableIds": [{"Ref": "Rt"}]+ }+ }+ },+ "Outputs": {+ "EndpointId": {"Value": {"Ref": "S3Endpoint"}}+ }+ }+ """;++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ 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>CREATE_COMPLETE</StackStatus>"))+ .body(containsString("<OutputValue>vpce-"));++ given()+ .formParam("Action", "DescribeVpcEndpoints")+ .header("Authorization", EC2_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("com.amazonaws.us-east-1.s3"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DeleteStack")+ .formParam("StackName", stackName)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "DescribeVpcEndpoints")+ .header("Authorization", EC2_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(not(containsString("com.amazonaws.us-east-1.s3")));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcEndpointCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcEndpointCfnProvisionerTest.javanew file mode 100644index 0000000000..50d1497a2f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Ec2VpcEndpointCfnProvisionerTest.java@@ -0,0 +1,129 @@+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.VpcEndpoint;+import org.junit.jupiter.api.Test;++import java.time.Instant;+import java.util.HashMap;+import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyList;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.ArgumentMatchers.isNull;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/** The VPC-endpoint CFN provisioner in isolation, mocking only Ec2Service. */+class Ec2VpcEndpointCfnProvisionerTest {++ private static final Instant CREATED_AT = Instant.parse("2026-08-13T10:15:30Z");++ private final Ec2Service ec2 = mock(Ec2Service.class);+ private final Ec2VpcEndpointCfnProvisioner provisioner = new Ec2VpcEndpointCfnProvisioner(ec2);+ private final ObjectMapper mapper = new ObjectMapper();++ private ProvisionContext ctx() {+ // Scalars resolve to their text; {"Ref": "X"} resolves to a fake physical id, which is+ // enough to prove properties go through the engine instead of being read raw.+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);+ when(engine.resolve(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ if (node == null) {+ return null;+ }+ if (node.isObject() && node.has("Ref")) {+ String ref = node.get("Ref").asText();+ // Models a template parameter carrying a boolean value.+ return "EnableDns".equals(ref) ? "true" : "resolved-" + ref;+ }+ return node.asText();+ });+ return new ProvisionContext(engine, "us-east-1", "000000000000", "my-stack");+ }++ private StackResource resource() {+ StackResource r = new StackResource();+ r.setLogicalId("S3Endpoint");+ r.setResourceType("AWS::EC2::VPCEndpoint");+ r.setAttributes(new HashMap<>());+ return r;+ }++ private VpcEndpoint endpoint(String id) {+ VpcEndpoint e = new VpcEndpoint();+ e.setVpcEndpointId(id);+ e.setCreationTimestamp(CREATED_AT);+ return e;+ }++ @Test+ void gatewayEndpointSetsPhysicalIdAndResolvesRefs() {+ when(ec2.createVpcEndpoint(eq("us-east-1"), eq("resolved-Vpc"), eq("com.amazonaws.us-east-1.s3"),+ eq("Gateway"), eq(List.of("resolved-Rt")), eq(List.of()), eq(List.of()), isNull(), anyList()))+ .thenReturn(endpoint("vpce-123"));+ StackResource r = resource();+ ObjectNode props = mapper.createObjectNode()+ .put("ServiceName", "com.amazonaws.us-east-1.s3");+ props.set("VpcId", mapper.createObjectNode().put("Ref", "Vpc"));+ props.putArray("RouteTableIds").add(mapper.createObjectNode().put("Ref", "Rt"));++ provisioner.provision(r, props, ctx());++ assertEquals("vpce-123", r.getPhysicalId());+ assertEquals("vpce-123", r.getAttributes().get("Id"));+ assertEquals("2026-08-13T10:15:30.000Z", r.getAttributes().get("CreationTimestamp"));+ }++ @Test+ void privateDnsEnabledResolvesThroughEngine() {+ when(ec2.createVpcEndpoint(anyString(), anyString(), anyString(), anyString(),+ anyList(), anyList(), anyList(), eq(Boolean.TRUE), anyList()))+ .thenReturn(endpoint("vpce-dns"));+ StackResource r = resource();+ ObjectNode props = mapper.createObjectNode()+ .put("VpcId", "vpc-1")+ .put("ServiceName", "com.amazonaws.us-east-1.ecr.api")+ .put("VpcEndpointType", "Interface");+ // A Ref, not a literal boolean: raw props.asBoolean(false) would silently yield false.+ props.set("PrivateDnsEnabled", mapper.createObjectNode().put("Ref", "EnableDns"));++ provisioner.provision(r, props, ctx());++ assertEquals("vpce-dns", r.getPhysicalId());+ verify(ec2).createVpcEndpoint(eq("us-east-1"), eq("vpc-1"), eq("com.amazonaws.us-east-1.ecr.api"),+ eq("Interface"), anyList(), anyList(), anyList(), eq(Boolean.TRUE), anyList());+ }++ @Test+ void updateReplacesAndDeletesPreviousEndpoint() {+ when(ec2.createVpcEndpoint(anyString(), anyString(), anyString(), anyString(),+ anyList(), anyList(), anyList(), any(), anyList()))+ .thenReturn(endpoint("vpce-new"));+ StackResource r = resource();+ r.setPhysicalId("vpce-old");+ ObjectNode props = mapper.createObjectNode()+ .put("VpcId", "vpc-1")+ .put("ServiceName", "com.amazonaws.us-east-1.s3");++ provisioner.provision(r, props, ctx());++ assertEquals("vpce-new", r.getPhysicalId());+ verify(ec2).deleteVpcEndpoints("us-east-1", List.of("vpce-old"));+ }++ @Test+ void deleteDelegatesToService() {+ provisioner.delete("AWS::EC2::VPCEndpoint", "vpce-123", "us-east-1");+ verify(ec2).deleteVpcEndpoints("us-east-1", List.of("vpce-123"));+ }+}