Light, fluffy, and always free - The AWS Local Emulator alternative
fix(elbv2): preserve default listener certificates (#5692)
David Phillipsa55352bf9d61
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2DefaultCertificateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2DefaultCertificateTest.javanew file mode 100644index 0000000000..f8126eb60a--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2DefaultCertificateTest.java@@ -0,0 +1,93 @@+package com.floci.test;++import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.acm.AcmClient;+import software.amazon.awssdk.services.elasticloadbalancingv2.ElasticLoadBalancingV2Client;+import software.amazon.awssdk.services.elasticloadbalancingv2.model.Certificate;+import software.amazon.awssdk.services.elasticloadbalancingv2.model.OperationNotPermittedException;++import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("ELBv2 default listener certificates")+class ElbV2DefaultCertificateTest {++ @Test+ @DisplayName("default removal is refused and ModifyListener can replace it")+ void defaultRemovalIsRefusedAndModifyCanReplaceIt() {+ Assumptions.assumeFalse(TestFixtures.isRealAws(), "Floci-only: requested ACM certificates are issued immediately");+ try (AcmClient acm = TestFixtures.acmClient();+ ElasticLoadBalancingV2Client elb = TestFixtures.elbV2Client()) {+ String first = null;+ String additional = null;+ String loadBalancer = null;+ try {+ first = acm.requestCertificate(b -> b.domainName("default.example.test").validationMethod("DNS"))+ .certificateArn();+ additional = acm.requestCertificate(b -> b.domainName("additional.example.test").validationMethod("DNS"))+ .certificateArn();+ String firstArn = first;+ String additionalArn = additional;+ loadBalancer = elb.createLoadBalancer(b -> b.name(TestFixtures.uniqueName("sdk-default-cert"))+ .type("application")).loadBalancers().get(0).loadBalancerArn();+ String lbArn = loadBalancer;+ String listener = elb.createListener(b -> b.loadBalancerArn(lbArn).port(443).protocol("HTTPS")+ .certificates(Certificate.builder().certificateArn(firstArn).build())+ .defaultActions(a -> a.type("fixed-response").fixedResponseConfig(f ->+ f.statusCode("200").contentType("text/plain").messageBody("ok"))))+ .listeners().get(0).listenerArn();+ assertThat(certificates(elb, listener)).containsExactly(firstArn);+ assertThatThrownBy(() -> elb.removeListenerCertificates(b -> b.listenerArn(listener)+ .certificates(Certificate.builder().certificateArn(firstArn).build())))+ .isInstanceOfSatisfying(OperationNotPermittedException.class,+ error -> assertThat(error.statusCode()).isEqualTo(400));+ assertThat(certificates(elb, listener)).containsExactly(firstArn);+ elb.addListenerCertificates(b -> b.listenerArn(listener)+ .certificates(Certificate.builder().certificateArn(additionalArn).build()));+ assertThat(certificates(elb, listener)).containsExactly(firstArn, additionalArn);+ assertThatThrownBy(() -> elb.removeListenerCertificates(b -> b.listenerArn(listener)+ .certificates(Certificate.builder().certificateArn(firstArn).build())))+ .isInstanceOf(OperationNotPermittedException.class);+ assertThat(certificates(elb, listener)).containsExactly(firstArn, additionalArn);+ elb.removeListenerCertificates(b -> b.listenerArn(listener)+ .certificates(Certificate.builder().certificateArn(additionalArn).build()));+ assertThat(certificates(elb, listener)).containsExactly(firstArn);+ elb.modifyListener(b -> b.listenerArn(listener)+ .certificates(Certificate.builder().certificateArn(additionalArn).build()));+ assertThat(certificates(elb, listener)).containsExactly(additionalArn);+ assertThatThrownBy(() -> elb.removeListenerCertificates(b -> b.listenerArn(listener)+ .certificates(Certificate.builder().certificateArn(additionalArn).build())))+ .isInstanceOf(OperationNotPermittedException.class);+ assertThat(certificates(elb, listener)).containsExactly(additionalArn);+ } finally {+ try {+ if (loadBalancer != null) {+ String lbArn = loadBalancer;+ elb.deleteLoadBalancer(b -> b.loadBalancerArn(lbArn));+ }+ } finally {+ try {+ if (first != null) {+ String arn = first;+ acm.deleteCertificate(b -> b.certificateArn(arn));+ }+ } finally {+ if (additional != null) {+ String arn = additional;+ acm.deleteCertificate(b -> b.certificateArn(arn));+ }+ }+ }+ }+ }+ }++ private static List<String> certificates(ElasticLoadBalancingV2Client client, String listener) {+ return client.describeListenerCertificates(b -> b.listenerArn(listener)).certificates().stream()+ .map(Certificate::certificateArn).toList();+ }+}diff --git a/docs/services/elb.md b/docs/services/elb.mdindex 194c974204..e629d31e8d 100644--- a/docs/services/elb.md+++ b/docs/services/elb.md@@ -94,6 +94,7 @@ Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB)- Rule priorities are unique per listener: `CreateRule` and `SetRulePriorities` only reject a priority held by another rule on the same listener. `SetRulePriorities` is atomic: all priority assignments are validated before any change is committed.- `DeleteTargetGroup` is rejected with `ResourceInUse` while the target group is referenced by any listener or rule.- An HTTPS or TLS listener's certificates must name existing certificates: an IAM server certificate ARN or an ACM certificate ARN. `CreateListener`, `ModifyListener` and `AddListenerCertificates` reject a missing or empty one with `CertificateNotFound`, the three operations the API reference models it on, and a `ModifyListener` that turns a listener into an HTTPS or TLS one is held to the same check over the certificates it already carried. An IAM server certificate a listener references cannot be deleted: `DeleteServerCertificate` returns `DeleteConflict` until the certificate is removed from the listener. A write that records one runs while IAM holds its certificate lock, so a certificate cannot be deleted between the check and the write, and a `ModifyListener` refused by that check leaves the listener on the port, protocol, policy and certificates it already had.+- `RemoveListenerCertificates` refuses removal of an HTTPS or TLS listener's default certificate with `OperationNotPermitted` (400) and preserves the certificate list. Use `ModifyListener` to replace the default certificate. Additional certificates can still be removed.- `DeleteRule` is rejected with `OperationNotPermitted` for the default rule.- `DescribeSSLPolicies` returns a pre-seeded list of standard AWS SSL policies (`ELBSecurityPolicy-*`).- `DescribeAccountLimits` returns standard default limits (e.g., 50 load balancers per region, 100 target groups, etc.).diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.javaindex a2d8d2d270..72f25e7c96 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java@@ -978,7 +978,13 @@ public class ElbV2Service implements ResourceProvider, ServerCertificateReferencpublic void removeListenerCertificates(String region, String listenerArn, List<String> certArns) {Listener listener = requireListener(region, listenerArn);- listener.getCertificates().removeAll(certArns);+ List<String> certificates = listener.getCertificates();+ if (servesCertificates(listener.getProtocol()) && !certificates.isEmpty()+ && certArns.contains(certificates.getFirst())) {+ throw new AwsException("OperationNotPermitted",+ "The default listener certificate cannot be removed.", 400);+ }+ certificates.removeAll(certArns);persistRegion(listeners, region);}diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.javaindex 5894b74ac7..795e379fe9 100644--- a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ListenerCertificateIntegrationTest.java@@ -345,4 +345,51 @@ class ElbV2ListenerCertificateIntegrationTest {assertTrue(listenerCertificates(listenerArn).containsAll(List.of(first, second)),"both certificates should be on the listener");}+ @Test+ void removingTheOnlyDefaultCertificateReturnsOperationNotPermitted() {+ String certificate = uploadCertificate();+ String listener = listenerServing(certificate);+ assertEquals(List.of(certificate), listenerCertificates(listener));+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)+ .formParam("Certificates.member.1.CertificateArn", certificate)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));+ assertEquals(List.of(certificate), listenerCertificates(listener));+ }++ @Test+ void defaultRemovalKeepsAdditionalCertificatesAndModifyCanReplaceTheDefault() {+ String first = uploadCertificate();+ String additional = uploadCertificate();+ String listener = listenerServing(first);+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "AddListenerCertificates").formParam("ListenerArn", listener)+ .formParam("Certificates.member.1.CertificateArn", additional)+ .when().post("/").then().statusCode(200);+ assertEquals(List.of(first, additional), listenerCertificates(listener));+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)+ .formParam("Certificates.member.1.CertificateArn", first)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));+ assertEquals(List.of(first, additional), listenerCertificates(listener));+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)+ .formParam("Certificates.member.1.CertificateArn", additional)+ .when().post("/").then().statusCode(200);+ assertEquals(List.of(first), listenerCertificates(listener));+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "ModifyListener").formParam("ListenerArn", listener)+ .formParam("Certificates.member.1.CertificateArn", additional)+ .when().post("/").then().statusCode(200);+ assertEquals(List.of(additional), listenerCertificates(listener));+ given().header("Authorization", ELB_AUTH)+ .formParam("Action", "RemoveListenerCertificates").formParam("ListenerArn", listener)+ .formParam("Certificates.member.1.CertificateArn", additional)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));+ assertEquals(List.of(additional), listenerCertificates(listener));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.javaindex d89e6b6df6..fda821154e 100644--- a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java@@ -22,14 +22,22 @@ import io.github.hectorvent.floci.services.elbv2.model.TargetHealth;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;import org.mockito.ArgumentCaptor;import org.mockito.Mock;import org.mockito.junit.jupiter.MockitoExtension;+import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Optional;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;@@ -82,6 +90,86 @@ class ElbV2ServiceTest {stubAlbSubnets(ec2Service);}+ @ParameterizedTest+ @ValueSource(strings = {"HTTPS", "TLS"})+ void defaultCertificateRemovalIsRefusedBeforeChangingTheList(String protocol) {+ String lbArn = service.createLoadBalancer(REGION, "default-cert-lb", "internal",+ "TLS".equals(protocol) ? "network" : "application", "ipv4",+ ALB_SUBNETS, List.of("sg-a"), Map.of()).getLoadBalancerArn();+ String first = "arn:aws:iam::000000000000:server-certificate/first";+ String additional = "arn:aws:iam::000000000000:server-certificate/additional";+ String listenerArn = service.createListener(REGION, lbArn, protocol, 9443, null,+ List.of(first, additional), List.of(), List.of(), Map.of()).getListenerArn();+ clearInvocations(dataPlane);++ AwsException rejected = assertThrows(AwsException.class,+ () -> service.removeListenerCertificates(REGION, listenerArn, List.of(additional, first)));+ assertEquals("OperationNotPermitted", rejected.getErrorCode());+ assertEquals(List.of(first, additional), service.describeListenerCertificates(REGION, listenerArn));+ verifyNoInteractions(dataPlane);++ service.removeListenerCertificates(REGION, listenerArn, List.of(additional));+ assertEquals(List.of(first), service.describeListenerCertificates(REGION, listenerArn));+ assertThrows(AwsException.class,+ () -> service.removeListenerCertificates(REGION, listenerArn, List.of(first)));+ assertEquals(List.of(first), service.describeListenerCertificates(REGION, listenerArn));+ }++ @Test+ void removalCannotDeleteADefaultPublishedByConcurrentModification() throws Exception {+ String lbArn = service.createLoadBalancer(REGION, "default-replacement-lb", "internal", "application", "ipv4",+ ALB_SUBNETS, List.of("sg-a"), Map.of()).getLoadBalancerArn();+ String first = "arn:aws:iam::000000000000:server-certificate/first";+ String additional = "arn:aws:iam::000000000000:server-certificate/additional";+ String listener = service.createListener(REGION, lbArn, "HTTPS", 9443, null,+ List.of(first, additional), List.of(), List.of(), Map.of()).getListenerArn();+ CountDownLatch checkedOriginalDefault = new CountDownLatch(1);+ CountDownLatch releaseRemoval = new CountDownLatch(1);+ List<String> requested = new ArrayList<>(List.of(additional)) {+ @Override+ public boolean contains(Object value) {+ boolean contains = super.contains(value);+ checkedOriginalDefault.countDown();+ try {+ assertTrue(releaseRemoval.await(5, TimeUnit.SECONDS), "removal was not released");+ } catch (InterruptedException failure) {+ Thread.currentThread().interrupt();+ throw new AssertionError("removal interrupted", failure);+ }+ return contains;+ }+ };+ ExecutorService worker = Executors.newSingleThreadExecutor();+ try {+ Future<?> removal = worker.submit(() -> service.removeListenerCertificates(REGION, listener, requested));+ assertTrue(checkedOriginalDefault.await(5, TimeUnit.SECONDS), "removal did not check the original default");+ service.modifyListener(REGION, listener, null, null, null, List.of(additional), null, null);+ assertEquals(List.of(additional), service.describeListenerCertificates(REGION, listener));+ releaseRemoval.countDown();+ removal.get(5, TimeUnit.SECONDS);+ assertEquals(List.of(additional), service.describeListenerCertificates(REGION, listener));+ AwsException rejected = assertThrows(AwsException.class,+ () -> service.removeListenerCertificates(REGION, listener, List.of(additional)));+ assertEquals("OperationNotPermitted", rejected.getErrorCode());+ assertEquals(List.of(additional), service.describeListenerCertificates(REGION, listener));+ } finally {+ releaseRemoval.countDown();+ worker.shutdownNow();+ assertTrue(worker.awaitTermination(5, TimeUnit.SECONDS));+ }+ }++ @Test+ void certificateMetadataOnAnHttpListenerKeepsItsExistingRemovalBehavior() {+ String lbArn = service.createLoadBalancer(REGION, "http-cert-lb", "internal", "application", "ipv4",+ ALB_SUBNETS, List.of("sg-a"), Map.of()).getLoadBalancerArn();+ String certificate = "arn:aws:iam::000000000000:server-certificate/metadata";+ String listenerArn = service.createListener(REGION, lbArn, "HTTP", 8080, null,+ List.of(certificate), List.of(), List.of(), Map.of()).getListenerArn();+ service.removeListenerCertificates(REGION, listenerArn, List.of(certificate));+ assertEquals(List.of(), service.describeListenerCertificates(REGION, listenerArn));+ }+@Testvoid modifyListenerDefaultActionsRecompilesRulesWithoutRestartingListener() {String lbArn = service.createLoadBalancer(