Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(elbv2): Elastic Load Balancing v2 management API (Phase 1) (#617)

Hector Venturad39bdf1c22c8
diff --git a/README.md b/README.md
index d8ad702909..56dba5773f 100644
--- a/README.md
+++ b/README.md
@@ -211,12 +211,13 @@ All default images are configurable via environment variables, useful for pinnin
| **AppConfigData** | In-process | Configuration sessions, dynamic configuration retrieval |
| **Bedrock Runtime** | In-process (stub) | Dummy Converse and InvokeModel responses for local development; streaming returns 501 |
| **EKS** | **Real Docker containers** (mock mode available) | Clusters, tagging; real mode starts k3s per cluster with a live Kubernetes API server |
+| **ELB v2** | In-process | Application and Network Load Balancers, target groups, listeners, path/host-based routing rules, tags |
> **Lambda, ElastiCache, RDS, MSK, ECS, EKS, and OpenSearch** spin up real Docker containers and support IAM authentication and SigV4 request signing — the same auth flow as production AWS. **ECR** runs a shared `registry:2` container so the stock `docker` client can push and pull image bytes against repositories returned by the AWS-shaped control plane.
>
> For per-service operation counts and endpoint protocols, see the [Services Overview](https://floci.io/floci/services/) in the documentation site.
-**35 AWS services supported.**
+**36 AWS services supported.**
## Persistence & Storage Modes
diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xml
index a7c67e5ce6..8c840cbeb1 100644
--- a/compatibility-tests/sdk-test-java/pom.xml
+++ b/compatibility-tests/sdk-test-java/pom.xml
@@ -209,6 +209,11 @@
<groupId>software.amazon.awssdk</groupId>
<artifactId>eks</artifactId>
</dependency>
+ <!-- ELBv2 client -->
+ <dependency>
+ <groupId>software.amazon.awssdk</groupId>
+ <artifactId>elasticloadbalancingv2</artifactId>
+ </dependency>
<!-- EventBridge Scheduler client -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
index 40a056769a..05f7942195 100644
--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
@@ -46,6 +46,7 @@ import software.amazon.awssdk.services.eks.EksClient;
import software.amazon.awssdk.services.scheduler.SchedulerClient;
import software.amazon.awssdk.services.appconfig.AppConfigClient;
import software.amazon.awssdk.services.appconfigdata.AppConfigDataClient;
+import software.amazon.awssdk.services.elasticloadbalancingv2.ElasticLoadBalancingV2Client;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.services.lambda.model.CreateFunctionRequest;
@@ -525,4 +526,12 @@ public final class TestFixtures {
.credentialsProvider(CREDENTIALS)
.build();
}
+
+ public static ElasticLoadBalancingV2Client elbV2Client() {
+ return ElasticLoadBalancingV2Client.builder()
+ .endpointOverride(ENDPOINT)
+ .region(REGION)
+ .credentialsProvider(CREDENTIALS)
+ .build();
+ }
}
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2Test.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2Test.java
new file mode 100644
index 0000000000..5a270205c9
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ElbV2Test.java
@@ -0,0 +1,576 @@
+package com.floci.test;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import software.amazon.awssdk.services.elasticloadbalancingv2.ElasticLoadBalancingV2Client;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.Action;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.ActionTypeEnum;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.AddTagsRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateListenerRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateListenerResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateLoadBalancerRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateLoadBalancerResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateRuleRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateRuleResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateTargetGroupRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.CreateTargetGroupResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DeleteListenerRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DeleteLoadBalancerRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DeleteRuleRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DeleteTargetGroupRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeAccountLimitsRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeAccountLimitsResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeListenersRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeListenersResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeLoadBalancerAttributesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeLoadBalancerAttributesResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeLoadBalancersRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeLoadBalancersResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeRulesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeRulesResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeSslPoliciesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeSslPoliciesResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTagsRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTagsResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTargetGroupAttributesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTargetGroupAttributesResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTargetGroupsRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTargetGroupsResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTargetHealthRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DescribeTargetHealthResponse;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DuplicateListenerException;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DuplicateLoadBalancerNameException;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.DuplicateTargetGroupNameException;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.ElasticLoadBalancingV2Exception;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.IpAddressType;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.Listener;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.LoadBalancer;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.LoadBalancerAttribute;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.LoadBalancerSchemeEnum;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.LoadBalancerStateEnum;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.LoadBalancerTypeEnum;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.ModifyLoadBalancerAttributesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.ModifyTargetGroupAttributesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.OperationNotPermittedException;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.PriorityInUseException;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.ProtocolEnum;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.RegisterTargetsRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.RemoveTagsRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.Rule;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.RuleCondition;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.RulePriorityPair;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.SetRulePrioritiesRequest;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.Tag;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.TargetDescription;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.TargetGroup;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.TargetGroupAttribute;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.TargetHealthDescription;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.TargetHealthStateEnum;
+import software.amazon.awssdk.services.elasticloadbalancingv2.model.TargetTypeEnum;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.*;
+
+@DisplayName("ELB v2 (Application Load Balancer)")
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class ElbV2Test {
+
+ private static ElasticLoadBalancingV2Client elb;
+
+ private static String lbArn;
+ private static String tgArn;
+ private static String listenerArn;
+ private static String ruleArn;
+
+ private static final String LB_NAME = TestFixtures.uniqueName("sdk-lb");
+ private static final String TG_NAME = TestFixtures.uniqueName("sdk-tg");
+
+ @BeforeAll
+ static void setup() {
+ elb = TestFixtures.elbV2Client();
+ }
+
+ @AfterAll
+ static void cleanup() {
+ if (elb == null) {
+ return;
+ }
+ try {
+ if (ruleArn != null) {
+ elb.deleteRule(DeleteRuleRequest.builder().ruleArn(ruleArn).build());
+ }
+ } catch (Exception ignored) {}
+ try {
+ if (listenerArn != null) {
+ elb.deleteListener(DeleteListenerRequest.builder().listenerArn(listenerArn).build());
+ }
+ } catch (Exception ignored) {}
+ try {
+ if (lbArn != null) {
+ elb.deleteLoadBalancer(DeleteLoadBalancerRequest.builder().loadBalancerArn(lbArn).build());
+ }
+ } catch (Exception ignored) {}
+ try {
+ if (tgArn != null) {
+ elb.deleteTargetGroup(DeleteTargetGroupRequest.builder().targetGroupArn(tgArn).build());
+ }
+ } catch (Exception ignored) {}
+ elb.close();
+ }
+
+ // ─── Load Balancers ──────────────────────────────────────────────────────
+
+ @Test
+ @Order(1)
+ @DisplayName("CreateLoadBalancer - returns ARN and DNS name")
+ void createLoadBalancer() {
+ CreateLoadBalancerResponse resp = elb.createLoadBalancer(CreateLoadBalancerRequest.builder()
+ .name(LB_NAME)
+ .type(LoadBalancerTypeEnum.APPLICATION)
+ .scheme(LoadBalancerSchemeEnum.INTERNET_FACING)
+ .ipAddressType(IpAddressType.IPV4)
+ .build());
+
+ assertThat(resp.loadBalancers()).hasSize(1);
+ LoadBalancer lb = resp.loadBalancers().get(0);
+ assertThat(lb.loadBalancerName()).isEqualTo(LB_NAME);
+ assertThat(lb.loadBalancerArn()).contains("elasticloadbalancing");
+ assertThat(lb.dnsName()).isNotBlank();
+ assertThat(lb.type()).isEqualTo(LoadBalancerTypeEnum.APPLICATION);
+ assertThat(lb.scheme()).isEqualTo(LoadBalancerSchemeEnum.INTERNET_FACING);
+ assertThat(lb.state().code()).isEqualTo(LoadBalancerStateEnum.PROVISIONING);
+ lbArn = lb.loadBalancerArn();
+ }
+
+ @Test
+ @Order(2)
+ @DisplayName("DescribeLoadBalancers - by ARN finds the LB in active state")
+ void describeLoadBalancerByArn() {
+ DescribeLoadBalancersResponse resp = elb.describeLoadBalancers(
+ DescribeLoadBalancersRequest.builder().loadBalancerArns(lbArn).build());
+
+ assertThat(resp.loadBalancers()).hasSize(1);
+ LoadBalancer lb = resp.loadBalancers().get(0);
+ assertThat(lb.loadBalancerArn()).isEqualTo(lbArn);
+ assertThat(lb.loadBalancerName()).isEqualTo(LB_NAME);
+ assertThat(lb.state().code()).isEqualTo(LoadBalancerStateEnum.ACTIVE);
+ }
+
+ @Test
+ @Order(3)
+ @DisplayName("DescribeLoadBalancers - by name finds the LB")
+ void describeLoadBalancerByName() {
+ DescribeLoadBalancersResponse resp = elb.describeLoadBalancers(
+ DescribeLoadBalancersRequest.builder().names(LB_NAME).build());
+
+ assertThat(resp.loadBalancers()).hasSize(1);
+ assertThat(resp.loadBalancers().get(0).loadBalancerArn()).isEqualTo(lbArn);
+ }
+
+ @Test
+ @Order(4)
+ @DisplayName("CreateLoadBalancer - duplicate name throws DuplicateLoadBalancerNameException")
+ void createLoadBalancerDuplicateName() {
+ assertThatThrownBy(() -> elb.createLoadBalancer(CreateLoadBalancerRequest.builder()
+ .name(LB_NAME)
+ .type(LoadBalancerTypeEnum.APPLICATION)
+ .build()))
+ .isInstanceOf(DuplicateLoadBalancerNameException.class);
+ }
+
+ @Test
+ @Order(5)
+ @DisplayName("ModifyLoadBalancerAttributes - set deletion_protection.enabled")
+ void modifyLoadBalancerAttributes() {
+ elb.modifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest.builder()
+ .loadBalancerArn(lbArn)
+ .attributes(LoadBalancerAttribute.builder()
+ .key("deletion_protection.enabled")
+ .value("true")
+ .build())
+ .build());
+
+ DescribeLoadBalancerAttributesResponse resp = elb.describeLoadBalancerAttributes(
+ DescribeLoadBalancerAttributesRequest.builder().loadBalancerArn(lbArn).build());
+
+ boolean found = resp.attributes().stream()
+ .anyMatch(a -> "deletion_protection.enabled".equals(a.key()) && "true".equals(a.value()));
+ assertThat(found).isTrue();
+ }
+
+ // ─── Target Groups ───────────────────────────────────────────────────────
+
+ @Test
+ @Order(10)
+ @DisplayName("CreateTargetGroup - returns ARN with health-check defaults")
+ void createTargetGroup() {
+ CreateTargetGroupResponse resp = elb.createTargetGroup(CreateTargetGroupRequest.builder()
+ .name(TG_NAME)
+ .protocol(ProtocolEnum.HTTP)
+ .port(80)
+ .targetType(TargetTypeEnum.INSTANCE)
+ .build());
+
+ assertThat(resp.targetGroups()).hasSize(1);
+ TargetGroup tg = resp.targetGroups().get(0);
+ assertThat(tg.targetGroupName()).isEqualTo(TG_NAME);
+ assertThat(tg.targetGroupArn()).contains("targetgroup");
+ assertThat(tg.protocol()).isEqualTo(ProtocolEnum.HTTP);
+ assertThat(tg.port()).isEqualTo(80);
+ assertThat(tg.healthCheckEnabled()).isTrue();
+ assertThat(tg.healthCheckPath()).isEqualTo("/");
+ tgArn = tg.targetGroupArn();
+ }
+
+ @Test
+ @Order(11)
+ @DisplayName("DescribeTargetGroups - by ARN returns correct group")
+ void describeTargetGroupByArn() {
+ DescribeTargetGroupsResponse resp = elb.describeTargetGroups(
+ DescribeTargetGroupsRequest.builder().targetGroupArns(tgArn).build());
+
+ assertThat(resp.targetGroups()).hasSize(1);
+ assertThat(resp.targetGroups().get(0).targetGroupName()).isEqualTo(TG_NAME);
+ }
+
+ @Test
+ @Order(12)
+ @DisplayName("CreateTargetGroup - duplicate name throws DuplicateTargetGroupNameException")
+ void createTargetGroupDuplicateName() {
+ assertThatThrownBy(() -> elb.createTargetGroup(CreateTargetGroupRequest.builder()
+ .name(TG_NAME)
+ .protocol(ProtocolEnum.HTTP)
+ .port(80)
+ .build()))
+ .isInstanceOf(DuplicateTargetGroupNameException.class);
+ }
+
+ @Test
+ @Order(13)
+ @DisplayName("ModifyTargetGroupAttributes - set deregistration_delay")
+ void modifyTargetGroupAttributes() {
+ elb.modifyTargetGroupAttributes(ModifyTargetGroupAttributesRequest.builder()
+ .targetGroupArn(tgArn)
+ .attributes(TargetGroupAttribute.builder()
+ .key("deregistration_delay.timeout_seconds")
+ .value("60")
+ .build())
+ .build());
+
+ DescribeTargetGroupAttributesResponse resp = elb.describeTargetGroupAttributes(
+ DescribeTargetGroupAttributesRequest.builder().targetGroupArn(tgArn).build());
+
+ boolean found = resp.attributes().stream()
+ .anyMatch(a -> "deregistration_delay.timeout_seconds".equals(a.key()) && "60".equals(a.value()));
+ assertThat(found).isTrue();
+ }
+
+ // ─── Targets ─────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(14)
+ @DisplayName("RegisterTargets - registers two instance IDs")
+ void registerTargets() {
+ elb.registerTargets(RegisterTargetsRequest.builder()
+ .targetGroupArn(tgArn)
+ .targets(
+ TargetDescription.builder().id("i-00000000001").port(8080).build(),
+ TargetDescription.builder().id("i-00000000002").port(8080).build()
+ )
+ .build());
+ }
+
+ @Test
+ @Order(15)
+ @DisplayName("DescribeTargetHealth - returns initial state for registered targets")
+ void describeTargetHealth() {
+ DescribeTargetHealthResponse resp = elb.describeTargetHealth(
+ DescribeTargetHealthRequest.builder().targetGroupArn(tgArn).build());
+
+ assertThat(resp.targetHealthDescriptions()).hasSize(2);
+ for (TargetHealthDescription thd : resp.targetHealthDescriptions()) {
+ assertThat(thd.targetHealth().state()).isEqualTo(TargetHealthStateEnum.INITIAL);
+ }
+ }
+
+ // ─── Listeners ───────────────────────────────────────────────────────────
+
+ @Test
+ @Order(20)
+ @DisplayName("CreateListener - creates with default forward action and auto-creates default rule")
+ void createListener() {
+ CreateListenerResponse resp = elb.createListener(CreateListenerRequest.builder()
+ .loadBalancerArn(lbArn)
+ .protocol(ProtocolEnum.HTTP)
+ .port(80)
+ .defaultActions(Action.builder()
+ .type(ActionTypeEnum.FORWARD)
+ .targetGroupArn(tgArn)
+ .build())
+ .build());
+
+ assertThat(resp.listeners()).hasSize(1);
+ Listener listener = resp.listeners().get(0);
+ assertThat(listener.loadBalancerArn()).isEqualTo(lbArn);
+ assertThat(listener.port()).isEqualTo(80);
+ assertThat(listener.protocol()).isEqualTo(ProtocolEnum.HTTP);
+ assertThat(listener.defaultActions()).hasSize(1);
+ assertThat(listener.defaultActions().get(0).type()).isEqualTo(ActionTypeEnum.FORWARD);
+ listenerArn = listener.listenerArn();
+ }
+
+ @Test
+ @Order(21)
+ @DisplayName("DescribeListeners - by LB ARN returns the created listener")
+ void describeListeners() {
+ DescribeListenersResponse resp = elb.describeListeners(
+ DescribeListenersRequest.builder().loadBalancerArn(lbArn).build());
+
+ assertThat(resp.listeners()).hasSize(1);
+ assertThat(resp.listeners().get(0).listenerArn()).isEqualTo(listenerArn);
+ }
+
+ @Test
+ @Order(22)
+ @DisplayName("CreateListener - duplicate port throws DuplicateListenerException")
+ void createListenerDuplicatePort() {
+ assertThatThrownBy(() -> elb.createListener(CreateListenerRequest.builder()
+ .loadBalancerArn(lbArn)
+ .protocol(ProtocolEnum.HTTP)
+ .port(80)
+ .defaultActions(Action.builder()
+ .type(ActionTypeEnum.FORWARD)
+ .targetGroupArn(tgArn)
+ .build())
+ .build()))
+ .isInstanceOf(DuplicateListenerException.class);
+ }
+
+ // ─── Rules ───────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(30)
+ @DisplayName("DescribeRules - default rule auto-created and is default")
+ void describeRulesDefaultExists() {
+ DescribeRulesResponse resp = elb.describeRules(
+ DescribeRulesRequest.builder().listenerArn(listenerArn).build());
+
+ assertThat(resp.rules()).isNotEmpty();
+ boolean hasDefault = resp.rules().stream().anyMatch(Rule::isDefault);
+ assertThat(hasDefault).isTrue();
+
+ Rule defaultRule = resp.rules().stream()
+ .filter(Rule::isDefault)
+ .findFirst()
+ .orElseThrow();
+ assertThat(defaultRule.priority()).isEqualTo("default");
+ assertThat(defaultRule.actions()).isNotEmpty();
+ }
+
+ @Test
+ @Order(31)
+ @DisplayName("CreateRule - path-pattern condition at priority 10")
+ void createRulePathPattern() {
+ CreateRuleResponse resp = elb.createRule(CreateRuleRequest.builder()
+ .listenerArn(listenerArn)
+ .priority(10)
+ .conditions(RuleCondition.builder()
+ .field("path-pattern")
+ .values("/api/*")
+ .build())
+ .actions(Action.builder()
+ .type(ActionTypeEnum.FORWARD)
+ .targetGroupArn(tgArn)
+ .build())
+ .build());
+
+ assertThat(resp.rules()).hasSize(1);
+ Rule rule = resp.rules().get(0);
+ assertThat(rule.priority()).isEqualTo("10");
+ assertThat(rule.isDefault()).isFalse();
+ assertThat(rule.conditions()).hasSize(1);
+ assertThat(rule.conditions().get(0).field()).isEqualTo("path-pattern");
+ ruleArn = rule.ruleArn();
+ }
+
+ @Test
+ @Order(32)
+ @DisplayName("CreateRule - priority already in use throws PriorityInUseException")
+ void createRulePriorityInUse() {
+ assertThatThrownBy(() -> elb.createRule(CreateRuleRequest.builder()
+ .listenerArn(listenerArn)
+ .priority(10)
+ .conditions(RuleCondition.builder()
+ .field("path-pattern")
+ .values("/other/*")
+ .build())
+ .actions(Action.builder()
+ .type(ActionTypeEnum.FORWARD)
+ .targetGroupArn(tgArn)
+ .build())
+ .build()))
+ .isInstanceOf(PriorityInUseException.class);
+ }
+
+ @Test
+ @Order(33)
+ @DisplayName("DescribeRules - listener has default rule + 1 user rule")
+ void describeRulesCount() {
+ DescribeRulesResponse resp = elb.describeRules(
+ DescribeRulesRequest.builder().listenerArn(listenerArn).build());
+ assertThat(resp.rules()).hasSize(2);
+ }
+
+ @Test
+ @Order(34)
+ @DisplayName("SetRulePriorities - changes rule priority")
+ void setRulePriorities() {
+ elb.setRulePriorities(SetRulePrioritiesRequest.builder()
+ .rulePriorities(RulePriorityPair.builder()
+ .ruleArn(ruleArn)
+ .priority(20)
+ .build())
+ .build());
+
+ DescribeRulesResponse resp = elb.describeRules(
+ DescribeRulesRequest.builder().ruleArns(ruleArn).build());
+ assertThat(resp.rules()).hasSize(1);
+ assertThat(resp.rules().get(0).priority()).isEqualTo("20");
+ }
+
+ @Test
+ @Order(35)
+ @DisplayName("DeleteRule - cannot delete default rule")
+ void deleteDefaultRuleForbidden() {
+ DescribeRulesResponse resp = elb.describeRules(
+ DescribeRulesRequest.builder().listenerArn(listenerArn).build());
+
+ String defaultRuleArn = resp.rules().stream()
+ .filter(Rule::isDefault)
+ .findFirst()
+ .map(Rule::ruleArn)
+ .orElseThrow();
+
+ assertThatThrownBy(() -> elb.deleteRule(
+ DeleteRuleRequest.builder().ruleArn(defaultRuleArn).build()))
+ .isInstanceOf(OperationNotPermittedException.class);
+ }
+
+ // ─── Tags ────────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(40)
+ @DisplayName("AddTags / DescribeTags / RemoveTags roundtrip on LB")
+ void tagsRoundtrip() {
+ elb.addTags(AddTagsRequest.builder()
+ .resourceArns(lbArn)
+ .tags(
+ Tag.builder().key("env").value("test").build(),
+ Tag.builder().key("team").value("platform").build()
+ )
+ .build());
+
+ DescribeTagsResponse desc = elb.describeTags(
+ DescribeTagsRequest.builder().resourceArns(lbArn).build());
+ assertThat(desc.tagDescriptions()).hasSize(1);
+ List<Tag> tags = desc.tagDescriptions().get(0).tags();
+ assertThat(tags).extracting(Tag::key).contains("env", "team");
+ assertThat(tags).extracting(Tag::value).contains("test", "platform");
+
+ elb.removeTags(RemoveTagsRequest.builder()
+ .resourceArns(lbArn)
+ .tagKeys("env")
+ .build());
+
+ DescribeTagsResponse afterRemove = elb.describeTags(
+ DescribeTagsRequest.builder().resourceArns(lbArn).build());
+ List<Tag> remaining = afterRemove.tagDescriptions().get(0).tags();
+ assertThat(remaining).extracting(Tag::key).containsOnly("team");
+ }
+
+ // ─── SSL Policies / Account Limits ───────────────────────────────────────
+
+ @Test
+ @Order(50)
+ @DisplayName("DescribeSSLPolicies - returns pre-seeded policies")
+ void describeSSLPolicies() {
+ DescribeSslPoliciesResponse resp = elb.describeSSLPolicies(
+ DescribeSslPoliciesRequest.builder().build());
+
+ assertThat(resp.sslPolicies()).isNotEmpty();
+ boolean hasDefault = resp.sslPolicies().stream()
+ .anyMatch(p -> p.name().startsWith("ELBSecurityPolicy-"));
+ assertThat(hasDefault).isTrue();
+ }
+
+ @Test
+ @Order(51)
+ @DisplayName("DescribeAccountLimits - returns non-empty limits")
+ void describeAccountLimits() {
+ DescribeAccountLimitsResponse resp = elb.describeAccountLimits(
+ DescribeAccountLimitsRequest.builder().build());
+
+ assertThat(resp.limits()).isNotEmpty();
+ boolean hasLoadBalancers = resp.limits().stream()
+ .anyMatch(l -> "application-load-balancers".equals(l.name()));
+ assertThat(hasLoadBalancers).isTrue();
+ }
+
+ // ─── Delete cascade ──────────────────────────────────────────────────────
+
+ @Test
+ @Order(60)
+ @DisplayName("DeleteTargetGroup - in-use LB throws TargetGroupAssociationLimitException")
+ void deleteTargetGroupInUseFails() {
+ assertThatThrownBy(() -> elb.deleteTargetGroup(
+ DeleteTargetGroupRequest.builder().targetGroupArn(tgArn).build()))
+ .isInstanceOf(ElasticLoadBalancingV2Exception.class);
+ }
+
+ @Test
+ @Order(61)
+ @DisplayName("DeleteListener - removes listener and its rules")
+ void deleteListener() {
+ elb.deleteListener(DeleteListenerRequest.builder().listenerArn(listenerArn).build());
+ listenerArn = null;
+ ruleArn = null;
+
+ DescribeListenersResponse resp = elb.describeListeners(
+ DescribeListenersRequest.builder().loadBalancerArn(lbArn).build());
+ assertThat(resp.listeners()).isEmpty();
+ }
+
+ @Test
+ @Order(62)
+ @DisplayName("DeleteLoadBalancer - removes the load balancer")
+ void deleteLoadBalancer() {
+ elb.deleteLoadBalancer(DeleteLoadBalancerRequest.builder().loadBalancerArn(lbArn).build());
+ lbArn = null;
+
+ DescribeLoadBalancersResponse resp = elb.describeLoadBalancers(
+ DescribeLoadBalancersRequest.builder().build());
+ boolean found = resp.loadBalancers().stream()
+ .anyMatch(lb -> LB_NAME.equals(lb.loadBalancerName()));
+ assertThat(found).isFalse();
+ }
+
+ @Test
+ @Order(63)
+ @DisplayName("DeleteTargetGroup - succeeds after LB deleted")
+ void deleteTargetGroupAfterLb() {
+ elb.deleteTargetGroup(DeleteTargetGroupRequest.builder().targetGroupArn(tgArn).build());
+ tgArn = null;
+
+ DescribeTargetGroupsResponse resp = elb.describeTargetGroups(
+ DescribeTargetGroupsRequest.builder().build());
+ boolean found = resp.targetGroups().stream()
+ .anyMatch(tg -> TG_NAME.equals(tg.targetGroupName()));
+ assertThat(found).isFalse();
+ }
+}
diff --git a/docs/services/elb.md b/docs/services/elb.md
new file mode 100644
index 0000000000..1e644f57fc
--- /dev/null
+++ b/docs/services/elb.md
@@ -0,0 +1,123 @@
+# Elastic Load Balancing v2
+
+**Protocol:** Query (XML) — `POST http://localhost:4566/` with `Action=` parameter
+
+Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB) through the ELBv2 management API. This is a Phase 1 implementation: the full CRUD control plane is available and AWS SDK / CLI / Terraform compatible. Data-plane traffic forwarding (actual TCP listener ports) is planned for Phase 2.
+
+## Supported Actions
+
+### Load Balancers
+`CreateLoadBalancer` · `DescribeLoadBalancers` · `DeleteLoadBalancer` · `ModifyLoadBalancerAttributes` · `DescribeLoadBalancerAttributes` · `SetSecurityGroups` · `SetSubnets` · `SetIpAddressType`
+
+### Target Groups
+`CreateTargetGroup` · `DescribeTargetGroups` · `ModifyTargetGroup` · `DeleteTargetGroup` · `ModifyTargetGroupAttributes` · `DescribeTargetGroupAttributes`
+
+### Targets
+`RegisterTargets` · `DeregisterTargets` · `DescribeTargetHealth`
+
+### Listeners
+`CreateListener` · `DescribeListeners` · `ModifyListener` · `DeleteListener` · `AddListenerCertificates` · `RemoveListenerCertificates` · `DescribeListenerCertificates`
+
+### Rules
+`CreateRule` · `DescribeRules` · `ModifyRule` · `DeleteRule` · `SetRulePriorities`
+
+### Tags
+`AddTags` · `RemoveTags` · `DescribeTags`
+
+### Metadata
+`DescribeSSLPolicies` · `DescribeAccountLimits`
+
+## Behavior Notes
+
+- Load balancers are created in `provisioning` state and transition to `active` immediately on subsequent describes.
+- Target health always returns `initial` state with reason `Elb.RegistrationInProgress` — data-plane health checks are not performed in Phase 1.
+- Each `CreateListener` automatically creates an immutable default rule (`priority=default`, `isDefault=true`). This rule cannot be deleted; use `ModifyListener` to change its action.
+- Rule priorities are validated for uniqueness. `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.
+- `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.).
+
+## ARN Format
+
+```
+arn:aws:elasticloadbalancing:{region}:{account-id}:loadbalancer/app/{name}/{hex16}
+arn:aws:elasticloadbalancing:{region}:{account-id}:targetgroup/{name}/{hex16}
+arn:aws:elasticloadbalancing:{region}:{account-id}:listener/app/{lb-name}/{lb-id}/{hex16}
+arn:aws:elasticloadbalancing:{region}:{account-id}:listener-rule/app/{lb-name}/{lb-id}/{listener-id}/{hex16}
+```
+
+## Examples
+
+```bash
+export AWS_ENDPOINT_URL=http://localhost:4566
+
+# Create a load balancer
+aws elbv2 create-load-balancer \
+ --name my-alb \
+ --type application \
+ --scheme internet-facing
+
+# Create a target group
+aws elbv2 create-target-group \
+ --name my-targets \
+ --protocol HTTP \
+ --port 80 \
+ --target-type instance
+
+# Register targets
+aws elbv2 register-targets \
+ --target-group-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/my-targets/abc123 \
+ --targets Id=i-00000000001,Port=8080
+
+# Create a listener with a default forward action
+aws elbv2 create-listener \
+ --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:loadbalancer/app/my-alb/abc123 \
+ --protocol HTTP \
+ --port 80 \
+ --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/my-targets/abc123
+
+# Add a path-based routing rule
+aws elbv2 create-rule \
+ --listener-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:listener/app/my-alb/abc123/def456 \
+ --priority 10 \
+ --conditions Field=path-pattern,Values='/api/*' \
+ --actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/my-targets/abc123
+
+# Describe load balancers
+aws elbv2 describe-load-balancers
+
+# Describe target health
+aws elbv2 describe-target-health \
+ --target-group-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/my-targets/abc123
+
+# Tag a resource
+aws elbv2 add-tags \
+ --resource-arns arn:aws:elasticloadbalancing:us-east-1:000000000000:loadbalancer/app/my-alb/abc123 \
+ --tags Key=env,Value=dev
+
+# Clean up
+aws elbv2 delete-listener \
+ --listener-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:listener/app/my-alb/abc123/def456
+aws elbv2 delete-load-balancer \
+ --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:loadbalancer/app/my-alb/abc123
+aws elbv2 delete-target-group \
+ --target-group-arn arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/my-targets/abc123
+```
+
+## Configuration
+
+```yaml
+floci:
+ services:
+ elbv2:
+ enabled: true # default: true
+```
+
+| Environment variable | Default | Description |
+|---|---|---|
+| `FLOCI_SERVICES_ELBV2_ENABLED` | `true` | Enable or disable the ELBv2 service |
+
+## Phase 2 (Planned)
+
+Phase 2 will bind real TCP listener ports on the host so traffic sent to a listener port is forwarded to registered targets. This requires exposing a port range (e.g., `8300-8399`) in the Docker Compose configuration, similar to how ElastiCache and RDS proxy ports work today.
diff --git a/docs/services/index.md b/docs/services/index.md
index 59c9e2d211..87681c305e 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -1,6 +1,6 @@
# Services Overview
-Floci emulates 34 AWS services on a single port (`4566`). All services use the real AWS wire protocol, your existing AWS CLI commands and SDK clients work without modification.
+Floci emulates 35 AWS services on a single port (`4566`). All services use the real AWS wire protocol, your existing AWS CLI commands and SDK clients work without modification.
This page is the canonical reference for supported service counts and operation counts. Other docs (and the README) should link here rather than duplicating the table.
@@ -44,6 +44,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [AppConfigData](appconfig.md#data-plane) | `/configurationsessions`, `/configuration` | REST JSON | 2 |
| [Bedrock Runtime](bedrock-runtime.md) | `/model/{modelId}/converse`, `/model/{modelId}/invoke` | REST JSON | 2 (stub; streaming returns 501) |
| [EKS](eks.md) | `/clusters`, `/clusters/{name}`, `/tags/{resourceArn}` | REST JSON | 7 |
+| [ELB v2](elb.md) | `POST /` with `Action=` param | Query | 34 |
**Lambda, ElastiCache, RDS, MSK, ECS, EKS, and OpenSearch** spin up real Docker containers and support IAM authentication and SigV4 request signing, the same auth flow as production AWS.
diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
index d89cd1b14a..a6601b1512 100644
--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
@@ -269,6 +269,7 @@ public interface EmulatorConfig {
BedrockRuntimeServiceConfig bedrockRuntime();
EksServiceConfig eks();
PipesServiceConfig pipes();
+ ElbV2ServiceConfig elbv2();
}
interface SsmServiceConfig {
@@ -684,6 +685,11 @@ public interface EmulatorConfig {
boolean enabled();
}
+ interface ElbV2ServiceConfig {
+ @WithDefault("true")
+ boolean enabled();
+ }
+
interface EksServiceConfig {
@WithDefault("true")
boolean enabled();
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java
index c358fb34e9..569531afc2 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsNamespaces.java
@@ -16,7 +16,8 @@ public final class AwsNamespaces {
public static final String S3 = "http://s3.amazonaws.com/doc/2006-03-01/";
public static final String S3_CONTROL = "http://awss3control.amazonaws.com/doc/2018-08-20/";
public static final String SES = "http://ses.amazonaws.com/doc/2010-12-01/";
- public static final String EC2 = "http://ec2.amazonaws.com/doc/2016-11-15/";
+ public static final String EC2 = "http://ec2.amazonaws.com/doc/2016-11-15/";
+ public static final String ELB_V2 = "https://elasticloadbalancing.amazonaws.com/doc/2015-12-01/";
private AwsNamespaces() {}
}
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
index 16d69c912b..8e02cb19d8 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.core.common;
import io.github.hectorvent.floci.services.cloudformation.CloudFormationQueryHandler;
import io.github.hectorvent.floci.services.ec2.Ec2QueryHandler;
+import io.github.hectorvent.floci.services.elbv2.ElbV2QueryHandler;
import io.github.hectorvent.floci.services.cloudwatch.metrics.CloudWatchMetricsQueryHandler;
import io.github.hectorvent.floci.services.cognito.CognitoJsonHandler;
import io.github.hectorvent.floci.services.elasticache.ElastiCacheQueryHandler;
@@ -102,6 +103,20 @@ public class AwsQueryController {
"GetAccountSummary", "GetAccountAuthorizationDetails"
);
+ private static final Set<String> ELB_V2_ACTIONS = Set.of(
+ "CreateLoadBalancer", "DescribeLoadBalancers", "DeleteLoadBalancer",
+ "ModifyLoadBalancerAttributes", "DescribeLoadBalancerAttributes",
+ "SetSecurityGroups", "SetSubnets", "SetIpAddressType",
+ "CreateTargetGroup", "DescribeTargetGroups", "ModifyTargetGroup", "DeleteTargetGroup",
+ "ModifyTargetGroupAttributes", "DescribeTargetGroupAttributes",
+ "RegisterTargets", "DeregisterTargets", "DescribeTargetHealth",
+ "CreateListener", "DescribeListeners", "ModifyListener", "DeleteListener",
+ "AddListenerCertificates", "RemoveListenerCertificates", "DescribeListenerCertificates",
+ "CreateRule", "DescribeRules", "ModifyRule", "DeleteRule", "SetRulePriorities",
+ "AddTags", "RemoveTags", "DescribeTags",
+ "DescribeSSLPolicies", "DescribeAccountLimits"
+ );
+
private static final Set<String> EC2_ACTIONS = Set.of(
"RunInstances", "DescribeInstances", "TerminateInstances", "StartInstances", "StopInstances",
"RebootInstances", "DescribeInstanceStatus", "DescribeInstanceAttribute", "ModifyInstanceAttribute",
@@ -136,6 +151,7 @@ public class AwsQueryController {
private final CloudWatchMetricsQueryHandler cloudWatchMetricsQueryHandler;
private final CognitoJsonHandler cognitoJsonHandler;
private final Ec2QueryHandler ec2QueryHandler;
+ private final ElbV2QueryHandler elbV2QueryHandler;
private final ResolvedServiceCatalog catalog;
private final RegionResolver regionResolver;
@@ -149,6 +165,7 @@ public class AwsQueryController {
CloudWatchMetricsQueryHandler cloudWatchMetricsQueryHandler,
CognitoJsonHandler cognitoJsonHandler,
Ec2QueryHandler ec2QueryHandler,
+ ElbV2QueryHandler elbV2QueryHandler,
ResolvedServiceCatalog catalog,
RegionResolver regionResolver) {
this.cloudFormationQueryHandler = cloudFormationQueryHandler;
@@ -162,6 +179,7 @@ public class AwsQueryController {
this.cloudWatchMetricsQueryHandler = cloudWatchMetricsQueryHandler;
this.cognitoJsonHandler = cognitoJsonHandler;
this.ec2QueryHandler = ec2QueryHandler;
+ this.elbV2QueryHandler = elbV2QueryHandler;
this.catalog = catalog;
this.regionResolver = regionResolver;
}
@@ -196,6 +214,7 @@ public class AwsQueryController {
case "cloudformation" -> cloudFormationQueryHandler.handle(action, formParams, region);
case "cognito-idp" -> handleCognitoQuery(action, formParams, region);
case "ec2" -> ec2QueryHandler.handle(action, formParams, region);
+ case "elasticloadbalancing" -> elbV2QueryHandler.handle(action, formParams, region);
default -> xmlErrorResponse("UnknownService",
"Unknown or unsupported service: " + service, 400);
};
@@ -320,6 +339,9 @@ public class AwsQueryController {
if (EC2_ACTIONS.contains(action)) {
return "ec2";
}
+ if (ELB_V2_ACTIONS.contains(action)) {
+ return "elasticloadbalancing";
+ }
// SQS actions are numerous and not enumerated — fall back to sqs only for
// requests that arrived without an Authorization header (raw/test clients)
return "sqs";
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
index f3e1ae7e6f..11b99dcacc 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
@@ -204,7 +204,11 @@ public class ResolvedServiceCatalog {
descriptor("pipes", "pipes", config.services().pipes().enabled(), true,
"pipes", config.storage().mode(), 5000L, null, ServiceProtocol.REST_JSON,
protocols(ServiceProtocol.REST_JSON),
- Set.of(), Set.of("pipes"), Set.of(), Set.of(PipesController.class))
+ Set.of(), Set.of("pipes"), Set.of(), Set.of(PipesController.class)),
+ descriptor("elasticloadbalancing", "elbv2", config.services().elbv2().enabled(), true,
+ "elbv2", config.storage().mode(), 5000L, AwsNamespaces.ELB_V2, ServiceProtocol.QUERY,
+ protocols(ServiceProtocol.QUERY),
+ Set.of(), Set.of("elasticloadbalancing"), Set.of(), Set.of())
));
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java
new file mode 100644
index 0000000000..3cf464078e
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java
@@ -0,0 +1,1219 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.AwsNamespaces;
+import io.github.hectorvent.floci.core.common.AwsQueryResponse;
+import io.github.hectorvent.floci.core.common.XmlBuilder;
+import io.github.hectorvent.floci.services.elbv2.model.*;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import org.jboss.logging.Logger;
+
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+@ApplicationScoped
+public class ElbV2QueryHandler {
+
+ private static final Logger LOG = Logger.getLogger(ElbV2QueryHandler.class);
+ private static final DateTimeFormatter ISO_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
+ .withZone(ZoneOffset.UTC);
+
+ // Pre-seeded SSL policies
+ private static final List<String> SSL_POLICIES = List.of(
+ "ELBSecurityPolicy-TLS13-1-2-2021-06",
+ "ELBSecurityPolicy-TLS13-1-2-Res-2021-06",
+ "ELBSecurityPolicy-TLS13-1-2-Ext1-2021-06",
+ "ELBSecurityPolicy-TLS13-1-2-Ext2-2021-06",
+ "ELBSecurityPolicy-TLS13-1-1-2021-06",
+ "ELBSecurityPolicy-TLS13-1-0-2021-06",
+ "ELBSecurityPolicy-2016-08",
+ "ELBSecurityPolicy-FS-1-2-Res-2020-10",
+ "ELBSecurityPolicy-FS-1-2-2019-08"
+ );
+
+ private static final Map<String, String> ACCOUNT_LIMITS = new LinkedHashMap<>();
+
+ static {
+ ACCOUNT_LIMITS.put("application-load-balancers", "50");
+ ACCOUNT_LIMITS.put("network-load-balancers", "50");
+ ACCOUNT_LIMITS.put("gateway-load-balancers", "100");
+ ACCOUNT_LIMITS.put("target-groups", "3000");
+ ACCOUNT_LIMITS.put("listeners-per-application-load-balancer", "50");
+ ACCOUNT_LIMITS.put("rules-per-application-load-balancer", "100");
+ ACCOUNT_LIMITS.put("target-groups-per-application-load-balancer", "100");
+ ACCOUNT_LIMITS.put("targets-per-application-load-balancer", "1000");
+ ACCOUNT_LIMITS.put("certificates-per-application-load-balancer", "25");
+ ACCOUNT_LIMITS.put("condition-values-per-alb-rule", "5");
+ ACCOUNT_LIMITS.put("condition-wildcards-per-alb-rule", "5");
+ }
+
+ private final ElbV2Service service;
+
+ @Inject
+ public ElbV2QueryHandler(ElbV2Service service) {
+ this.service = service;
+ }
+
+ public Response handle(String action, MultivaluedMap<String, String> params, String region) {
+ LOG.debugv("ELBv2 action: {0}", action);
+ try {
+ return switch (action) {
+ // Load Balancers
+ case "CreateLoadBalancer" -> handleCreateLoadBalancer(params, region);
+ case "DescribeLoadBalancers" -> handleDescribeLoadBalancers(params, region);
+ case "DeleteLoadBalancer" -> handleDeleteLoadBalancer(params, region);
+ case "ModifyLoadBalancerAttributes" -> handleModifyLoadBalancerAttributes(params, region);
+ case "DescribeLoadBalancerAttributes"-> handleDescribeLoadBalancerAttributes(params, region);
+ case "SetSecurityGroups" -> handleSetSecurityGroups(params, region);
+ case "SetSubnets" -> handleSetSubnets(params, region);
+ case "SetIpAddressType" -> handleSetIpAddressType(params, region);
+ // Target Groups
+ case "CreateTargetGroup" -> handleCreateTargetGroup(params, region);
+ case "DescribeTargetGroups" -> handleDescribeTargetGroups(params, region);
+ case "DeleteTargetGroup" -> handleDeleteTargetGroup(params, region);
+ case "ModifyTargetGroup" -> handleModifyTargetGroup(params, region);
+ case "ModifyTargetGroupAttributes" -> handleModifyTargetGroupAttributes(params, region);
+ case "DescribeTargetGroupAttributes" -> handleDescribeTargetGroupAttributes(params, region);
+ // Listeners
+ case "CreateListener" -> handleCreateListener(params, region);
+ case "DescribeListeners" -> handleDescribeListeners(params, region);
+ case "DeleteListener" -> handleDeleteListener(params, region);
+ case "ModifyListener" -> handleModifyListener(params, region);
+ // Rules
+ case "CreateRule" -> handleCreateRule(params, region);
+ case "DescribeRules" -> handleDescribeRules(params, region);
+ case "DeleteRule" -> handleDeleteRule(params, region);
+ case "ModifyRule" -> handleModifyRule(params, region);
+ case "SetRulePriorities" -> handleSetRulePriorities(params, region);
+ // Targets
+ case "RegisterTargets" -> handleRegisterTargets(params, region);
+ case "DeregisterTargets" -> handleDeregisterTargets(params, region);
+ case "DescribeTargetHealth" -> handleDescribeTargetHealth(params, region);
+ // Tags
+ case "AddTags" -> handleAddTags(params);
+ case "RemoveTags" -> handleRemoveTags(params);
+ case "DescribeTags" -> handleDescribeTags(params);
+ // Meta
+ case "DescribeAccountLimits" -> handleDescribeAccountLimits();
+ case "DescribeSSLPolicies" -> handleDescribeSSLPolicies(params);
+ // Listener certs
+ case "AddListenerCertificates" -> handleAddListenerCertificates(params, region);
+ case "RemoveListenerCertificates" -> handleRemoveListenerCertificates(params, region);
+ case "DescribeListenerCertificates" -> handleDescribeListenerCertificates(params, region);
+ default -> xmlError("UnsupportedOperation",
+ "Action " + action + " is not supported.", 400);
+ };
+ } catch (AwsException e) {
+ return xmlError(e.getErrorCode(), e.getMessage(), e.getHttpStatus());
+ }
+ }
+
+ // ── Load Balancers ────────────────────────────────────────────────────────
+
+ private Response handleCreateLoadBalancer(MultivaluedMap<String, String> p, String region) {
+ String name = p.getFirst("Name");
+ String scheme = p.getFirst("Scheme");
+ String type = p.getFirst("Type");
+ String ipAddressType = p.getFirst("IpAddressType");
+ List<String> subnets = memberList(p, "Subnets");
+ List<String> securityGroups = memberList(p, "SecurityGroups");
+ Map<String, String> tags = parseTags(p);
+
+ LoadBalancer lb = service.createLoadBalancer(region, name, scheme, type, ipAddressType,
+ subnets, securityGroups, tags);
+
+ // return provisioning state in create response only
+ LoadBalancer provisioning = shallowCopy(lb);
+ provisioning.setState("provisioning");
+
+ String xml = new XmlBuilder()
+ .start("CreateLoadBalancerResponse", AwsNamespaces.ELB_V2)
+ .start("CreateLoadBalancerResult")
+ .start("LoadBalancers")
+ .start("member").raw(loadBalancerXml(provisioning)).end("member")
+ .end("LoadBalancers")
+ .end("CreateLoadBalancerResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("CreateLoadBalancerResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeLoadBalancers(MultivaluedMap<String, String> p, String region) {
+ List<String> arns = memberList(p, "LoadBalancerArns");
+ List<String> names = memberList(p, "Names");
+
+ List<LoadBalancer> lbs = service.describeLoadBalancers(region, arns, names, null, null);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeLoadBalancersResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeLoadBalancersResult")
+ .start("LoadBalancers");
+ for (LoadBalancer lb : lbs) {
+ xml.start("member").raw(loadBalancerXml(lb)).end("member");
+ }
+ xml.end("LoadBalancers")
+ .elem("NextMarker", "")
+ .end("DescribeLoadBalancersResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeLoadBalancersResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDeleteLoadBalancer(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("LoadBalancerArn");
+ service.deleteLoadBalancer(region, arn);
+ return voidResponse("DeleteLoadBalancerResponse");
+ }
+
+ private Response handleModifyLoadBalancerAttributes(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("LoadBalancerArn");
+ Map<String, String> attrs = parseAttributes(p, "Attributes");
+ service.modifyLoadBalancerAttributes(region, arn, attrs);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("ModifyLoadBalancerAttributesResponse", AwsNamespaces.ELB_V2)
+ .start("ModifyLoadBalancerAttributesResult")
+ .start("Attributes");
+ for (Map.Entry<String, String> e : attrs.entrySet()) {
+ xml.start("member").elem("Key", e.getKey()).elem("Value", e.getValue()).end("member");
+ }
+ xml.end("Attributes")
+ .end("ModifyLoadBalancerAttributesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("ModifyLoadBalancerAttributesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeLoadBalancerAttributes(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("LoadBalancerArn");
+ Map<String, String> attrs = service.describeLoadBalancerAttributes(region, arn);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeLoadBalancerAttributesResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeLoadBalancerAttributesResult")
+ .start("Attributes");
+ for (Map.Entry<String, String> e : attrs.entrySet()) {
+ xml.start("member").elem("Key", e.getKey()).elem("Value", e.getValue()).end("member");
+ }
+ xml.end("Attributes")
+ .end("DescribeLoadBalancerAttributesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeLoadBalancerAttributesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleSetSecurityGroups(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("LoadBalancerArn");
+ List<String> sgs = memberList(p, "SecurityGroups");
+ service.setSecurityGroups(region, arn, sgs);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("SetSecurityGroupsResponse", AwsNamespaces.ELB_V2)
+ .start("SetSecurityGroupsResult")
+ .start("SecurityGroupIds");
+ for (String sg : sgs) xml.start("member").elem("member", sg).end("member");
+ xml.end("SecurityGroupIds")
+ .end("SetSecurityGroupsResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("SetSecurityGroupsResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleSetSubnets(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("LoadBalancerArn");
+ List<String> subnets = memberList(p, "Subnets");
+ service.setSubnets(region, arn, subnets);
+ return voidResponse("SetSubnetsResponse");
+ }
+
+ private Response handleSetIpAddressType(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("LoadBalancerArn");
+ String ipAddressType = p.getFirst("IpAddressType");
+ service.setIpAddressType(region, arn, ipAddressType);
+
+ String xml = new XmlBuilder()
+ .start("SetIpAddressTypeResponse", AwsNamespaces.ELB_V2)
+ .start("SetIpAddressTypeResult")
+ .elem("IpAddressType", ipAddressType)
+ .end("SetIpAddressTypeResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("SetIpAddressTypeResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Target Groups ─────────────────────────────────────────────────────────
+
+ private Response handleCreateTargetGroup(MultivaluedMap<String, String> p, String region) {
+ String name = p.getFirst("Name");
+ String protocol = p.getFirst("Protocol");
+ String protocolVersion = p.getFirst("ProtocolVersion");
+ Integer port = parseIntOrNull(p.getFirst("Port"));
+ String vpcId = p.getFirst("VpcId");
+ String targetType = p.getFirst("TargetType");
+ String hcProtocol = p.getFirst("HealthCheckProtocol");
+ String hcPort = p.getFirst("HealthCheckPort");
+ Boolean hcEnabled = parseBoolOrNull(p.getFirst("HealthCheckEnabled"));
+ String hcPath = p.getFirst("HealthCheckPath");
+ Integer hcInterval = parseIntOrNull(p.getFirst("HealthCheckIntervalSeconds"));
+ Integer hcTimeout = parseIntOrNull(p.getFirst("HealthCheckTimeoutSeconds"));
+ Integer healthyThreshold = parseIntOrNull(p.getFirst("HealthyThresholdCount"));
+ Integer unhealthyThreshold = parseIntOrNull(p.getFirst("UnhealthyThresholdCount"));
+ String matcher = p.getFirst("Matcher.HttpCode");
+ String ipAddressType = p.getFirst("IpAddressType");
+ Map<String, String> tags = parseTags(p);
+
+ TargetGroup tg = service.createTargetGroup(region, name, protocol, protocolVersion, port, vpcId,
+ targetType, hcProtocol, hcPort, hcEnabled, hcPath, hcInterval, hcTimeout,
+ healthyThreshold, unhealthyThreshold, matcher, ipAddressType, tags);
+
+ String xml = new XmlBuilder()
+ .start("CreateTargetGroupResponse", AwsNamespaces.ELB_V2)
+ .start("CreateTargetGroupResult")
+ .start("TargetGroups")
+ .start("member").raw(targetGroupXml(tg)).end("member")
+ .end("TargetGroups")
+ .end("CreateTargetGroupResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("CreateTargetGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeTargetGroups(MultivaluedMap<String, String> p, String region) {
+ String lbArn = p.getFirst("LoadBalancerArn");
+ List<String> tgArns = memberList(p, "TargetGroupArns");
+ List<String> names = memberList(p, "Names");
+
+ List<TargetGroup> tgs = service.describeTargetGroups(region, lbArn, tgArns, names);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeTargetGroupsResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeTargetGroupsResult")
+ .start("TargetGroups");
+ for (TargetGroup tg : tgs) {
+ xml.start("member").raw(targetGroupXml(tg)).end("member");
+ }
+ xml.end("TargetGroups")
+ .elem("NextMarker", "")
+ .end("DescribeTargetGroupsResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeTargetGroupsResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDeleteTargetGroup(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("TargetGroupArn");
+ service.deleteTargetGroup(region, arn);
+ return voidResponse("DeleteTargetGroupResponse");
+ }
+
+ private Response handleModifyTargetGroup(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("TargetGroupArn");
+ String hcProtocol = p.getFirst("HealthCheckProtocol");
+ String hcPort = p.getFirst("HealthCheckPort");
+ Boolean hcEnabled = parseBoolOrNull(p.getFirst("HealthCheckEnabled"));
+ String hcPath = p.getFirst("HealthCheckPath");
+ Integer hcInterval = parseIntOrNull(p.getFirst("HealthCheckIntervalSeconds"));
+ Integer hcTimeout = parseIntOrNull(p.getFirst("HealthCheckTimeoutSeconds"));
+ Integer healthyThreshold = parseIntOrNull(p.getFirst("HealthyThresholdCount"));
+ Integer unhealthyThreshold = parseIntOrNull(p.getFirst("UnhealthyThresholdCount"));
+ String matcher = p.getFirst("Matcher.HttpCode");
+
+ service.modifyTargetGroup(region, arn, hcProtocol, hcPort, hcEnabled, hcPath,
+ hcInterval, hcTimeout, healthyThreshold, unhealthyThreshold, matcher);
+
+ TargetGroup tg = service.describeTargetGroups(region, null, List.of(arn), null).get(0);
+ String xml = new XmlBuilder()
+ .start("ModifyTargetGroupResponse", AwsNamespaces.ELB_V2)
+ .start("ModifyTargetGroupResult")
+ .start("TargetGroups")
+ .start("member").raw(targetGroupXml(tg)).end("member")
+ .end("TargetGroups")
+ .end("ModifyTargetGroupResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("ModifyTargetGroupResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleModifyTargetGroupAttributes(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("TargetGroupArn");
+ Map<String, String> attrs = parseAttributes(p, "Attributes");
+ service.modifyTargetGroupAttributes(region, arn, attrs);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("ModifyTargetGroupAttributesResponse", AwsNamespaces.ELB_V2)
+ .start("ModifyTargetGroupAttributesResult")
+ .start("Attributes");
+ for (Map.Entry<String, String> e : attrs.entrySet()) {
+ xml.start("member").elem("Key", e.getKey()).elem("Value", e.getValue()).end("member");
+ }
+ xml.end("Attributes")
+ .end("ModifyTargetGroupAttributesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("ModifyTargetGroupAttributesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeTargetGroupAttributes(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("TargetGroupArn");
+ Map<String, String> attrs = service.describeTargetGroupAttributes(region, arn);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeTargetGroupAttributesResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeTargetGroupAttributesResult")
+ .start("Attributes");
+ for (Map.Entry<String, String> e : attrs.entrySet()) {
+ xml.start("member").elem("Key", e.getKey()).elem("Value", e.getValue()).end("member");
+ }
+ xml.end("Attributes")
+ .end("DescribeTargetGroupAttributesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeTargetGroupAttributesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Listeners ─────────────────────────────────────────────────────────────
+
+ private Response handleCreateListener(MultivaluedMap<String, String> p, String region) {
+ String lbArn = p.getFirst("LoadBalancerArn");
+ String protocol = p.getFirst("Protocol");
+ Integer port = parseIntOrNull(p.getFirst("Port"));
+ String sslPolicy = p.getFirst("SslPolicy");
+ List<String> certs = parseCertificateList(p, "Certificates");
+ List<Action> defaultActions = parseActions(p, "DefaultActions");
+ List<String> alpnPolicy = memberList(p, "AlpnPolicy");
+ Map<String, String> tags = parseTags(p);
+
+ Listener listener = service.createListener(region, lbArn, protocol, port, sslPolicy,
+ certs, defaultActions, alpnPolicy, tags);
+
+ String xml = new XmlBuilder()
+ .start("CreateListenerResponse", AwsNamespaces.ELB_V2)
+ .start("CreateListenerResult")
+ .start("Listeners")
+ .start("member").raw(listenerXml(listener)).end("member")
+ .end("Listeners")
+ .end("CreateListenerResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("CreateListenerResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeListeners(MultivaluedMap<String, String> p, String region) {
+ String lbArn = p.getFirst("LoadBalancerArn");
+ List<String> listenerArns = memberList(p, "ListenerArns");
+
+ List<Listener> result = service.describeListeners(region, lbArn, listenerArns);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeListenersResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeListenersResult")
+ .start("Listeners");
+ for (Listener l : result) {
+ xml.start("member").raw(listenerXml(l)).end("member");
+ }
+ xml.end("Listeners")
+ .elem("NextMarker", "")
+ .end("DescribeListenersResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeListenersResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDeleteListener(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("ListenerArn");
+ service.deleteListener(region, arn);
+ return voidResponse("DeleteListenerResponse");
+ }
+
+ private Response handleModifyListener(MultivaluedMap<String, String> p, String region) {
+ String listenerArn = p.getFirst("ListenerArn");
+ String protocol = p.getFirst("Protocol");
+ Integer port = parseIntOrNull(p.getFirst("Port"));
+ String sslPolicy = p.getFirst("SslPolicy");
+ List<String> certs = parseCertificateList(p, "Certificates");
+ List<Action> defaultActions = parseActions(p, "DefaultActions");
+ List<String> alpnPolicy = memberList(p, "AlpnPolicy");
+
+ Listener listener = service.modifyListener(region, listenerArn, protocol, port, sslPolicy,
+ certs.isEmpty() ? null : certs,
+ defaultActions.isEmpty() ? null : defaultActions,
+ alpnPolicy.isEmpty() ? null : alpnPolicy);
+
+ String xml = new XmlBuilder()
+ .start("ModifyListenerResponse", AwsNamespaces.ELB_V2)
+ .start("ModifyListenerResult")
+ .start("Listeners")
+ .start("member").raw(listenerXml(listener)).end("member")
+ .end("Listeners")
+ .end("ModifyListenerResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("ModifyListenerResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Rules ─────────────────────────────────────────────────────────────────
+
+ private Response handleCreateRule(MultivaluedMap<String, String> p, String region) {
+ String listenerArn = p.getFirst("ListenerArn");
+ Integer priority = parseIntOrNull(p.getFirst("Priority"));
+ if (priority == null) {
+ throw new AwsException("ValidationError", "Priority is required.", 400);
+ }
+ List<RuleCondition> conditions = parseConditions(p);
+ List<Action> actions = parseActions(p, "Actions");
+ Map<String, String> tags = parseTags(p);
+
+ Rule rule = service.createRule(region, listenerArn, conditions, priority, actions, tags);
+
+ String xml = new XmlBuilder()
+ .start("CreateRuleResponse", AwsNamespaces.ELB_V2)
+ .start("CreateRuleResult")
+ .start("Rules")
+ .start("member").raw(ruleXml(rule)).end("member")
+ .end("Rules")
+ .end("CreateRuleResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("CreateRuleResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeRules(MultivaluedMap<String, String> p, String region) {
+ String listenerArn = p.getFirst("ListenerArn");
+ List<String> ruleArns = memberList(p, "RuleArns");
+
+ List<Rule> result = service.describeRules(region, listenerArn, ruleArns);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeRulesResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeRulesResult")
+ .start("Rules");
+ for (Rule r : result) {
+ xml.start("member").raw(ruleXml(r)).end("member");
+ }
+ xml.end("Rules")
+ .elem("NextMarker", "")
+ .end("DescribeRulesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeRulesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDeleteRule(MultivaluedMap<String, String> p, String region) {
+ String arn = p.getFirst("RuleArn");
+ service.deleteRule(region, arn);
+ return voidResponse("DeleteRuleResponse");
+ }
+
+ private Response handleModifyRule(MultivaluedMap<String, String> p, String region) {
+ String ruleArn = p.getFirst("RuleArn");
+ List<RuleCondition> conditions = parseConditions(p);
+ List<Action> actions = parseActions(p, "Actions");
+
+ Rule rule = service.modifyRule(region, ruleArn,
+ conditions.isEmpty() ? null : conditions,
+ actions.isEmpty() ? null : actions);
+
+ String xml = new XmlBuilder()
+ .start("ModifyRuleResponse", AwsNamespaces.ELB_V2)
+ .start("ModifyRuleResult")
+ .start("Rules")
+ .start("member").raw(ruleXml(rule)).end("member")
+ .end("Rules")
+ .end("ModifyRuleResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("ModifyRuleResponse")
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleSetRulePriorities(MultivaluedMap<String, String> p, String region) {
+ Map<String, Integer> arnToPriority = new LinkedHashMap<>();
+ int i = 1;
+ while (true) {
+ String arn = p.getFirst("RulePriorities.member." + i + ".RuleArn");
+ String priorityStr = p.getFirst("RulePriorities.member." + i + ".Priority");
+ if (arn == null) break;
+ arnToPriority.put(arn, Integer.parseInt(priorityStr));
+ i++;
+ }
+ service.setRulePriorities(region, arnToPriority);
+
+ // return the updated rules
+ List<Rule> updated = service.describeRules(region, null, new ArrayList<>(arnToPriority.keySet()));
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("SetRulePrioritiesResponse", AwsNamespaces.ELB_V2)
+ .start("SetRulePrioritiesResult")
+ .start("Rules");
+ for (Rule r : updated) {
+ xml.start("member").raw(ruleXml(r)).end("member");
+ }
+ xml.end("Rules")
+ .end("SetRulePrioritiesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("SetRulePrioritiesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Targets ───────────────────────────────────────────────────────────────
+
+ private Response handleRegisterTargets(MultivaluedMap<String, String> p, String region) {
+ String tgArn = p.getFirst("TargetGroupArn");
+ List<TargetDescription> targets = parseTargets(p);
+ service.registerTargets(region, tgArn, targets);
+ return voidResponse("RegisterTargetsResponse");
+ }
+
+ private Response handleDeregisterTargets(MultivaluedMap<String, String> p, String region) {
+ String tgArn = p.getFirst("TargetGroupArn");
+ List<TargetDescription> targets = parseTargets(p);
+ service.deregisterTargets(region, tgArn, targets);
+ return voidResponse("DeregisterTargetsResponse");
+ }
+
+ private Response handleDescribeTargetHealth(MultivaluedMap<String, String> p, String region) {
+ String tgArn = p.getFirst("TargetGroupArn");
+ List<TargetDescription> filterTargets = parseTargets(p);
+
+ List<TargetHealth> healthList = service.describeTargetHealth(region, tgArn, filterTargets);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeTargetHealthResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeTargetHealthResult")
+ .start("TargetHealthDescriptions");
+ for (TargetHealth th : healthList) {
+ xml.start("member");
+ xml.start("Target");
+ xml.elem("Id", th.getTarget().getId());
+ if (th.getTarget().getPort() != null) xml.elem("Port", String.valueOf(th.getTarget().getPort()));
+ if (th.getTarget().getAvailabilityZone() != null) xml.elem("AvailabilityZone", th.getTarget().getAvailabilityZone());
+ xml.end("Target");
+ xml.elem("HealthCheckPort", th.getHealthCheckPort());
+ xml.start("TargetHealth");
+ xml.elem("State", th.getState());
+ if (th.getReason() != null) xml.elem("Reason", th.getReason());
+ if (th.getDescription() != null) xml.elem("Description", th.getDescription());
+ xml.end("TargetHealth");
+ xml.end("member");
+ }
+ xml.end("TargetHealthDescriptions")
+ .end("DescribeTargetHealthResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeTargetHealthResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Tags ──────────────────────────────────────────────────────────────────
+
+ private Response handleAddTags(MultivaluedMap<String, String> p) {
+ List<String> arns = memberList(p, "ResourceArns");
+ Map<String, String> tags = parseTags(p);
+ service.addTags(arns, tags);
+ return voidResponse("AddTagsResponse");
+ }
+
+ private Response handleRemoveTags(MultivaluedMap<String, String> p) {
+ List<String> arns = memberList(p, "ResourceArns");
+ List<String> keys = memberList(p, "TagKeys");
+ service.removeTags(arns, keys);
+ return voidResponse("RemoveTagsResponse");
+ }
+
+ private Response handleDescribeTags(MultivaluedMap<String, String> p) {
+ List<String> arns = memberList(p, "ResourceArns");
+ Map<String, Map<String, String>> result = service.describeTags(arns);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeTagsResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeTagsResult")
+ .start("TagDescriptions");
+ for (Map.Entry<String, Map<String, String>> e : result.entrySet()) {
+ xml.start("member");
+ xml.elem("ResourceArn", e.getKey());
+ xml.start("Tags");
+ for (Map.Entry<String, String> tag : e.getValue().entrySet()) {
+ xml.start("member").elem("Key", tag.getKey()).elem("Value", tag.getValue()).end("member");
+ }
+ xml.end("Tags");
+ xml.end("member");
+ }
+ xml.end("TagDescriptions")
+ .end("DescribeTagsResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeTagsResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Meta ──────────────────────────────────────────────────────────────────
+
+ private Response handleDescribeAccountLimits() {
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeAccountLimitsResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeAccountLimitsResult")
+ .start("Limits");
+ for (Map.Entry<String, String> e : ACCOUNT_LIMITS.entrySet()) {
+ xml.start("member").elem("Name", e.getKey()).elem("Max", e.getValue()).end("member");
+ }
+ xml.end("Limits")
+ .elem("NextMarker", "")
+ .end("DescribeAccountLimitsResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeAccountLimitsResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleDescribeSSLPolicies(MultivaluedMap<String, String> p) {
+ List<String> requested = memberList(p, "Names");
+ List<String> toReturn = requested.isEmpty() ? SSL_POLICIES
+ : SSL_POLICIES.stream().filter(requested::contains).toList();
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeSSLPoliciesResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeSSLPoliciesResult")
+ .start("SslPolicies");
+ for (String name : toReturn) {
+ xml.start("member")
+ .elem("Name", name)
+ .start("SslProtocols").end("SslProtocols")
+ .start("Ciphers").end("Ciphers")
+ .start("SupportedLoadBalancerTypes")
+ .start("member").raw("application").end("member")
+ .end("SupportedLoadBalancerTypes")
+ .end("member");
+ }
+ xml.end("SslPolicies")
+ .elem("NextMarker", "")
+ .end("DescribeSSLPoliciesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeSSLPoliciesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── Listener Certificates ─────────────────────────────────────────────────
+
+ private Response handleAddListenerCertificates(MultivaluedMap<String, String> p, String region) {
+ String listenerArn = p.getFirst("ListenerArn");
+ List<String> certs = parseCertificateList(p, "Certificates");
+ service.addListenerCertificates(region, listenerArn, certs);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("AddListenerCertificatesResponse", AwsNamespaces.ELB_V2)
+ .start("AddListenerCertificatesResult")
+ .start("Certificates");
+ for (String c : certs) {
+ xml.start("member").elem("CertificateArn", c).end("member");
+ }
+ xml.end("Certificates")
+ .end("AddListenerCertificatesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("AddListenerCertificatesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response handleRemoveListenerCertificates(MultivaluedMap<String, String> p, String region) {
+ String listenerArn = p.getFirst("ListenerArn");
+ List<String> certs = parseCertificateList(p, "Certificates");
+ service.removeListenerCertificates(region, listenerArn, certs);
+ return voidResponse("RemoveListenerCertificatesResponse");
+ }
+
+ private Response handleDescribeListenerCertificates(MultivaluedMap<String, String> p, String region) {
+ String listenerArn = p.getFirst("ListenerArn");
+ List<String> certs = service.describeListenerCertificates(region, listenerArn);
+
+ XmlBuilder xml = new XmlBuilder()
+ .start("DescribeListenerCertificatesResponse", AwsNamespaces.ELB_V2)
+ .start("DescribeListenerCertificatesResult")
+ .start("Certificates");
+ for (String c : certs) {
+ xml.start("member").elem("CertificateArn", c).end("member");
+ }
+ xml.end("Certificates")
+ .elem("NextMarker", "")
+ .end("DescribeListenerCertificatesResult")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("DescribeListenerCertificatesResponse");
+ return Response.ok(xml.build()).type(MediaType.APPLICATION_XML).build();
+ }
+
+ // ── XML builders ─────────────────────────────────────────────────────────
+
+ private String loadBalancerXml(LoadBalancer lb) {
+ XmlBuilder xml = new XmlBuilder();
+ xml.elem("LoadBalancerArn", lb.getLoadBalancerArn());
+ xml.elem("DNSName", lb.getDnsName());
+ xml.elem("CanonicalHostedZoneId", lb.getCanonicalHostedZoneId());
+ if (lb.getCreatedTime() != null) {
+ xml.elem("CreatedTime", ISO_FMT.format(lb.getCreatedTime()));
+ }
+ xml.elem("LoadBalancerName", lb.getLoadBalancerName());
+ xml.elem("Scheme", lb.getScheme());
+ xml.elem("VpcId", safe(lb.getVpcId()));
+ xml.start("State").elem("Code", safe(lb.getState())).end("State");
+ xml.elem("Type", safe(lb.getType()));
+ xml.start("AvailabilityZones");
+ for (String az : lb.getAvailabilityZones()) {
+ xml.start("member").elem("ZoneName", az).end("member");
+ }
+ xml.end("AvailabilityZones");
+ xml.start("SecurityGroups");
+ for (String sg : lb.getSecurityGroups()) {
+ xml.start("member").raw(sg).end("member");
+ }
+ xml.end("SecurityGroups");
+ xml.elem("IpAddressType", safe(lb.getIpAddressType()));
+ return xml.build();
+ }
+
+ private String targetGroupXml(TargetGroup tg) {
+ XmlBuilder xml = new XmlBuilder();
+ xml.elem("TargetGroupArn", tg.getTargetGroupArn());
+ xml.elem("TargetGroupName", tg.getTargetGroupName());
+ xml.elem("Protocol", safe(tg.getProtocol()));
+ xml.elem("ProtocolVersion", safe(tg.getProtocolVersion()));
+ if (tg.getPort() != null) xml.elem("Port", String.valueOf(tg.getPort()));
+ xml.elem("VpcId", safe(tg.getVpcId()));
+ xml.elem("HealthCheckProtocol", safe(tg.getHealthCheckProtocol()));
+ xml.elem("HealthCheckPort", safe(tg.getHealthCheckPort()));
+ xml.elem("HealthCheckEnabled", String.valueOf(tg.getHealthCheckEnabled() != null ? tg.getHealthCheckEnabled() : true));
+ if (tg.getHealthCheckIntervalSeconds() != null) xml.elem("HealthCheckIntervalSeconds", String.valueOf(tg.getHealthCheckIntervalSeconds()));
+ if (tg.getHealthCheckTimeoutSeconds() != null) xml.elem("HealthCheckTimeoutSeconds", String.valueOf(tg.getHealthCheckTimeoutSeconds()));
+ if (tg.getHealthyThresholdCount() != null) xml.elem("HealthyThresholdCount", String.valueOf(tg.getHealthyThresholdCount()));
+ if (tg.getUnhealthyThresholdCount() != null) xml.elem("UnhealthyThresholdCount", String.valueOf(tg.getUnhealthyThresholdCount()));
+ xml.elem("HealthCheckPath", safe(tg.getHealthCheckPath()));
+ xml.start("Matcher").elem("HttpCode", safe(tg.getMatcher())).end("Matcher");
+ xml.start("LoadBalancerArns");
+ for (String lbArn : tg.getLoadBalancerArns()) {
+ xml.start("member").raw(lbArn).end("member");
+ }
+ xml.end("LoadBalancerArns");
+ xml.elem("TargetType", safe(tg.getTargetType()));
+ xml.elem("IpAddressType", safe(tg.getIpAddressType()));
+ return xml.build();
+ }
+
+ private String listenerXml(Listener l) {
+ XmlBuilder xml = new XmlBuilder();
+ xml.elem("ListenerArn", l.getListenerArn());
+ xml.elem("LoadBalancerArn", l.getLoadBalancerArn());
+ if (l.getPort() != null) xml.elem("Port", String.valueOf(l.getPort()));
+ xml.elem("Protocol", safe(l.getProtocol()));
+ xml.elem("SslPolicy", safe(l.getSslPolicy()));
+ xml.start("Certificates");
+ for (String c : l.getCertificates()) {
+ xml.start("member").elem("CertificateArn", c).end("member");
+ }
+ xml.end("Certificates");
+ xml.start("DefaultActions");
+ for (Action a : l.getDefaultActions()) {
+ xml.start("member").raw(actionXml(a)).end("member");
+ }
+ xml.end("DefaultActions");
+ xml.start("AlpnPolicy");
+ for (String ap : l.getAlpnPolicy()) {
+ xml.start("member").raw(ap).end("member");
+ }
+ xml.end("AlpnPolicy");
+ return xml.build();
+ }
+
+ private String ruleXml(Rule r) {
+ XmlBuilder xml = new XmlBuilder();
+ xml.elem("RuleArn", r.getRuleArn());
+ xml.elem("Priority", r.getPriority());
+ xml.start("Conditions");
+ for (RuleCondition c : r.getConditions()) {
+ xml.start("member").raw(conditionXml(c)).end("member");
+ }
+ xml.end("Conditions");
+ xml.start("Actions");
+ for (Action a : r.getActions()) {
+ xml.start("member").raw(actionXml(a)).end("member");
+ }
+ xml.end("Actions");
+ xml.elem("IsDefault", String.valueOf(r.isDefault()));
+ return xml.build();
+ }
+
+ private String actionXml(Action a) {
+ XmlBuilder xml = new XmlBuilder();
+ xml.elem("Type", safe(a.getType()));
+ if (a.getOrder() != null) xml.elem("Order", String.valueOf(a.getOrder()));
+ if (a.getTargetGroupArn() != null) xml.elem("TargetGroupArn", a.getTargetGroupArn());
+ if (!a.getTargetGroups().isEmpty() || a.getTargetGroupArn() == null && "forward".equals(a.getType())) {
+ xml.start("ForwardConfig");
+ xml.start("TargetGroups");
+ for (Action.TargetGroupTuple t : a.getTargetGroups()) {
+ xml.start("member");
+ xml.elem("TargetGroupArn", safe(t.getTargetGroupArn()));
+ if (t.getWeight() != null) xml.elem("Weight", String.valueOf(t.getWeight()));
+ xml.end("member");
+ }
+ xml.end("TargetGroups");
+ if (a.getStickinessEnabled() != null) {
+ xml.start("TargetGroupStickinessConfig")
+ .elem("Enabled", String.valueOf(a.getStickinessEnabled()));
+ if (a.getStickinessDurationSeconds() != null) {
+ xml.elem("DurationSeconds", String.valueOf(a.getStickinessDurationSeconds()));
+ }
+ xml.end("TargetGroupStickinessConfig");
+ }
+ xml.end("ForwardConfig");
+ }
+ if ("redirect".equals(a.getType())) {
+ xml.start("RedirectConfig");
+ if (a.getRedirectProtocol() != null) xml.elem("Protocol", a.getRedirectProtocol());
+ if (a.getRedirectPort() != null) xml.elem("Port", a.getRedirectPort());
+ if (a.getRedirectHost() != null) xml.elem("Host", a.getRedirectHost());
+ if (a.getRedirectPath() != null) xml.elem("Path", a.getRedirectPath());
+ if (a.getRedirectQuery() != null) xml.elem("Query", a.getRedirectQuery());
+ xml.elem("StatusCode", safe(a.getRedirectStatusCode()));
+ xml.end("RedirectConfig");
+ }
+ if ("fixed-response".equals(a.getType())) {
+ xml.start("FixedResponseConfig");
+ xml.elem("StatusCode", safe(a.getFixedResponseStatusCode()));
+ if (a.getFixedResponseContentType() != null) xml.elem("ContentType", a.getFixedResponseContentType());
+ if (a.getFixedResponseMessageBody() != null) xml.elem("MessageBody", a.getFixedResponseMessageBody());
+ xml.end("FixedResponseConfig");
+ }
+ return xml.build();
+ }
+
+ private String conditionXml(RuleCondition c) {
+ XmlBuilder xml = new XmlBuilder();
+ xml.elem("Field", safe(c.getField()));
+ xml.start("Values");
+ for (String v : c.getValues()) xml.start("member").raw(v).end("member");
+ xml.end("Values");
+ if (!c.getHostHeaderValues().isEmpty()) {
+ xml.start("HostHeaderConfig").start("Values");
+ for (String v : c.getHostHeaderValues()) xml.start("member").raw(v).end("member");
+ xml.end("Values").end("HostHeaderConfig");
+ }
+ if (!c.getPathPatternValues().isEmpty()) {
+ xml.start("PathPatternConfig").start("Values");
+ for (String v : c.getPathPatternValues()) xml.start("member").raw(v).end("member");
+ xml.end("Values").end("PathPatternConfig");
+ }
+ if (c.getHttpHeaderName() != null) {
+ xml.start("HttpHeaderConfig")
+ .elem("HttpHeaderName", c.getHttpHeaderName())
+ .start("Values");
+ for (String v : c.getHttpHeaderValues()) xml.start("member").raw(v).end("member");
+ xml.end("Values").end("HttpHeaderConfig");
+ }
+ if (!c.getHttpMethodValues().isEmpty()) {
+ xml.start("HttpRequestMethodConfig").start("Values");
+ for (String v : c.getHttpMethodValues()) xml.start("member").raw(v).end("member");
+ xml.end("Values").end("HttpRequestMethodConfig");
+ }
+ if (!c.getSourceIpValues().isEmpty()) {
+ xml.start("SourceIpConfig").start("Values");
+ for (String v : c.getSourceIpValues()) xml.start("member").raw(v).end("member");
+ xml.end("Values").end("SourceIpConfig");
+ }
+ if (!c.getQueryStringValues().isEmpty()) {
+ xml.start("QueryStringConfig").start("Values");
+ for (RuleCondition.QueryStringPair kv : c.getQueryStringValues()) {
+ xml.start("member");
+ if (kv.getKey() != null) xml.elem("Key", kv.getKey());
+ xml.elem("Value", safe(kv.getValue()));
+ xml.end("member");
+ }
+ xml.end("Values").end("QueryStringConfig");
+ }
+ return xml.build();
+ }
+
+ // ── Parsing helpers ───────────────────────────────────────────────────────
+
+ private List<String> memberList(MultivaluedMap<String, String> p, String prefix) {
+ List<String> result = new ArrayList<>();
+ int i = 1;
+ while (true) {
+ String val = p.getFirst(prefix + ".member." + i);
+ if (val == null) break;
+ result.add(val);
+ i++;
+ }
+ return result;
+ }
+
+ private Map<String, String> parseTags(MultivaluedMap<String, String> p) {
+ Map<String, String> result = new LinkedHashMap<>();
+ int i = 1;
+ while (true) {
+ String key = p.getFirst("Tags.member." + i + ".Key");
+ if (key == null) break;
+ String value = p.getFirst("Tags.member." + i + ".Value");
+ result.put(key, value != null ? value : "");
+ i++;
+ }
+ return result;
+ }
+
+ private Map<String, String> parseAttributes(MultivaluedMap<String, String> p, String prefix) {
+ Map<String, String> result = new LinkedHashMap<>();
+ int i = 1;
+ while (true) {
+ String key = p.getFirst(prefix + ".member." + i + ".Key");
+ if (key == null) break;
+ String value = p.getFirst(prefix + ".member." + i + ".Value");
+ result.put(key, value != null ? value : "");
+ i++;
+ }
+ return result;
+ }
+
+ private List<String> parseCertificateList(MultivaluedMap<String, String> p, String prefix) {
+ List<String> result = new ArrayList<>();
+ int i = 1;
+ while (true) {
+ String arn = p.getFirst(prefix + ".member." + i + ".CertificateArn");
+ if (arn == null) break;
+ result.add(arn);
+ i++;
+ }
+ return result;
+ }
+
+ private List<Action> parseActions(MultivaluedMap<String, String> p, String prefix) {
+ List<Action> result = new ArrayList<>();
+ int i = 1;
+ while (true) {
+ String type = p.getFirst(prefix + ".member." + i + ".Type");
+ if (type == null) break;
+ Action a = new Action();
+ a.setType(type);
+ String orderStr = p.getFirst(prefix + ".member." + i + ".Order");
+ if (orderStr != null) a.setOrder(Integer.parseInt(orderStr));
+
+ switch (type) {
+ case "forward" -> {
+ String tgArn = p.getFirst(prefix + ".member." + i + ".TargetGroupArn");
+ a.setTargetGroupArn(tgArn);
+ // weighted forward via ForwardConfig
+ List<Action.TargetGroupTuple> tuples = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String tgArnW = p.getFirst(prefix + ".member." + i + ".ForwardConfig.TargetGroups.member." + j + ".TargetGroupArn");
+ if (tgArnW == null) break;
+ Action.TargetGroupTuple t = new Action.TargetGroupTuple();
+ t.setTargetGroupArn(tgArnW);
+ String wStr = p.getFirst(prefix + ".member." + i + ".ForwardConfig.TargetGroups.member." + j + ".Weight");
+ if (wStr != null) t.setWeight(Integer.parseInt(wStr));
+ tuples.add(t);
+ j++;
+ }
+ a.setTargetGroups(tuples);
+ String stickyEnabled = p.getFirst(prefix + ".member." + i + ".ForwardConfig.TargetGroupStickinessConfig.Enabled");
+ if (stickyEnabled != null) a.setStickinessEnabled(Boolean.parseBoolean(stickyEnabled));
+ String stickyDuration = p.getFirst(prefix + ".member." + i + ".ForwardConfig.TargetGroupStickinessConfig.DurationSeconds");
+ if (stickyDuration != null) a.setStickinessDurationSeconds(Integer.parseInt(stickyDuration));
+ }
+ case "redirect" -> {
+ a.setRedirectProtocol(p.getFirst(prefix + ".member." + i + ".RedirectConfig.Protocol"));
+ a.setRedirectPort(p.getFirst(prefix + ".member." + i + ".RedirectConfig.Port"));
+ a.setRedirectHost(p.getFirst(prefix + ".member." + i + ".RedirectConfig.Host"));
+ a.setRedirectPath(p.getFirst(prefix + ".member." + i + ".RedirectConfig.Path"));
+ a.setRedirectQuery(p.getFirst(prefix + ".member." + i + ".RedirectConfig.Query"));
+ a.setRedirectStatusCode(p.getFirst(prefix + ".member." + i + ".RedirectConfig.StatusCode"));
+ }
+ case "fixed-response" -> {
+ a.setFixedResponseStatusCode(p.getFirst(prefix + ".member." + i + ".FixedResponseConfig.StatusCode"));
+ a.setFixedResponseContentType(p.getFirst(prefix + ".member." + i + ".FixedResponseConfig.ContentType"));
+ a.setFixedResponseMessageBody(p.getFirst(prefix + ".member." + i + ".FixedResponseConfig.MessageBody"));
+ }
+ }
+ result.add(a);
+ i++;
+ }
+ return result;
+ }
+
+ private List<RuleCondition> parseConditions(MultivaluedMap<String, String> p) {
+ List<RuleCondition> result = new ArrayList<>();
+ int i = 1;
+ while (true) {
+ String field = p.getFirst("Conditions.member." + i + ".Field");
+ if (field == null) break;
+ RuleCondition c = new RuleCondition();
+ c.setField(field);
+
+ // legacy flat values
+ List<String> legacyValues = new ArrayList<>();
+ int v = 1;
+ while (true) {
+ String val = p.getFirst("Conditions.member." + i + ".Values.member." + v);
+ if (val == null) break;
+ legacyValues.add(val);
+ v++;
+ }
+ c.setValues(legacyValues);
+
+ switch (field) {
+ case "host-header" -> {
+ List<String> vals = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String val = p.getFirst("Conditions.member." + i + ".HostHeaderConfig.Values.member." + j);
+ if (val == null) break;
+ vals.add(val);
+ j++;
+ }
+ if (!vals.isEmpty()) c.setHostHeaderValues(vals);
+ else c.setHostHeaderValues(new ArrayList<>(legacyValues));
+ }
+ case "path-pattern" -> {
+ List<String> vals = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String val = p.getFirst("Conditions.member." + i + ".PathPatternConfig.Values.member." + j);
+ if (val == null) break;
+ vals.add(val);
+ j++;
+ }
+ if (!vals.isEmpty()) c.setPathPatternValues(vals);
+ else c.setPathPatternValues(new ArrayList<>(legacyValues));
+ }
+ case "http-header" -> {
+ c.setHttpHeaderName(p.getFirst("Conditions.member." + i + ".HttpHeaderConfig.HttpHeaderName"));
+ List<String> vals = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String val = p.getFirst("Conditions.member." + i + ".HttpHeaderConfig.Values.member." + j);
+ if (val == null) break;
+ vals.add(val);
+ j++;
+ }
+ c.setHttpHeaderValues(vals);
+ }
+ case "http-request-method" -> {
+ List<String> vals = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String val = p.getFirst("Conditions.member." + i + ".HttpRequestMethodConfig.Values.member." + j);
+ if (val == null) break;
+ vals.add(val);
+ j++;
+ }
+ c.setHttpMethodValues(vals);
+ }
+ case "source-ip" -> {
+ List<String> vals = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String val = p.getFirst("Conditions.member." + i + ".SourceIpConfig.Values.member." + j);
+ if (val == null) break;
+ vals.add(val);
+ j++;
+ }
+ c.setSourceIpValues(vals);
+ }
+ case "query-string" -> {
+ List<RuleCondition.QueryStringPair> pairs = new ArrayList<>();
+ int j = 1;
+ while (true) {
+ String qKey = p.getFirst("Conditions.member." + i + ".QueryStringConfig.Values.member." + j + ".Key");
+ String qVal = p.getFirst("Conditions.member." + i + ".QueryStringConfig.Values.member." + j + ".Value");
+ if (qKey == null && qVal == null) break;
+ RuleCondition.QueryStringPair pair = new RuleCondition.QueryStringPair();
+ pair.setKey(qKey);
+ pair.setValue(qVal);
+ pairs.add(pair);
+ j++;
+ }
+ c.setQueryStringValues(pairs);
+ }
+ }
+ result.add(c);
+ i++;
+ }
+ return result;
+ }
+
+ private List<TargetDescription> parseTargets(MultivaluedMap<String, String> p) {
+ List<TargetDescription> result = new ArrayList<>();
+ int i = 1;
+ while (true) {
+ String id = p.getFirst("Targets.member." + i + ".Id");
+ if (id == null) break;
+ TargetDescription t = new TargetDescription();
+ t.setId(id);
+ String portStr = p.getFirst("Targets.member." + i + ".Port");
+ if (portStr != null) t.setPort(Integer.parseInt(portStr));
+ t.setAvailabilityZone(p.getFirst("Targets.member." + i + ".AvailabilityZone"));
+ result.add(t);
+ i++;
+ }
+ return result;
+ }
+
+ // ── Misc helpers ─────────────────────────────────────────────────────────
+
+ private Response voidResponse(String responseName) {
+ String xml = new XmlBuilder()
+ .start(responseName, AwsNamespaces.ELB_V2)
+ .raw(AwsQueryResponse.responseMetadata())
+ .end(responseName)
+ .build();
+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private Response xmlError(String code, String message, int status) {
+ String xml = new XmlBuilder()
+ .start("ErrorResponse")
+ .start("Error")
+ .elem("Type", "Sender")
+ .elem("Code", code)
+ .elem("Message", message)
+ .end("Error")
+ .raw(AwsQueryResponse.responseMetadata())
+ .end("ErrorResponse")
+ .build();
+ return Response.status(status).entity(xml).type(MediaType.APPLICATION_XML).build();
+ }
+
+ private static String safe(String s) { return s != null ? s : ""; }
+
+ private static Integer parseIntOrNull(String s) {
+ if (s == null || s.isEmpty()) return null;
+ return Integer.parseInt(s);
+ }
+
+ private static Boolean parseBoolOrNull(String s) {
+ if (s == null || s.isEmpty()) return null;
+ return Boolean.parseBoolean(s);
+ }
+
+ private static LoadBalancer shallowCopy(LoadBalancer lb) {
+ LoadBalancer copy = new LoadBalancer();
+ copy.setLoadBalancerArn(lb.getLoadBalancerArn());
+ copy.setDnsName(lb.getDnsName());
+ copy.setCanonicalHostedZoneId(lb.getCanonicalHostedZoneId());
+ copy.setCreatedTime(lb.getCreatedTime());
+ copy.setLoadBalancerName(lb.getLoadBalancerName());
+ copy.setScheme(lb.getScheme());
+ copy.setVpcId(lb.getVpcId());
+ copy.setState(lb.getState());
+ copy.setType(lb.getType());
+ copy.setAvailabilityZones(new ArrayList<>(lb.getAvailabilityZones()));
+ copy.setSecurityGroups(new ArrayList<>(lb.getSecurityGroups()));
+ copy.setIpAddressType(lb.getIpAddressType());
+ copy.setRegion(lb.getRegion());
+ return copy;
+ }
+}
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.java
new file mode 100644
index 0000000000..66e347f9cf
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java
@@ -0,0 +1,707 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.services.elbv2.model.*;
+import jakarta.enterprise.context.ApplicationScoped;
+
+import java.time.Instant;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+@ApplicationScoped
+public class ElbV2Service {
+
+ private static final String CANONICAL_HOSTED_ZONE_ID = "Z35SXDOTRQ7X7K";
+ private static final String DEFAULT_ACCOUNT = "000000000000";
+
+ // region → ARN → resource
+ private final Map<String, Map<String, LoadBalancer>> loadBalancers = new ConcurrentHashMap<>();
+ private final Map<String, Map<String, TargetGroup>> targetGroups = new ConcurrentHashMap<>();
+ private final Map<String, Map<String, Listener>> listeners = new ConcurrentHashMap<>();
+ private final Map<String, Map<String, Rule>> rules = new ConcurrentHashMap<>();
+
+ // indexes
+ private final Map<String, List<String>> lbToListeners = new ConcurrentHashMap<>(); // LB-ARN → listener ARNs
+ private final Map<String, List<String>> listenerToRules = new ConcurrentHashMap<>(); // Listener-ARN → rule ARNs
+ private final Map<String, Set<String>> tgToLbs = new ConcurrentHashMap<>(); // TG-ARN → LB-ARNs
+
+ // tags: resource-ARN → {key → value}
+ private final Map<String, Map<String, String>> tags = new ConcurrentHashMap<>();
+
+ // ── Load Balancers ────────────────────────────────────────────────────────
+
+ public LoadBalancer createLoadBalancer(String region, String name, String scheme,
+ String type, String ipAddressType,
+ List<String> subnets, List<String> securityGroups,
+ Map<String, String> initialTags) {
+ validateName(name, "load balancer");
+ Map<String, LoadBalancer> regionLbs = loadBalancers.computeIfAbsent(region, k -> new ConcurrentHashMap<>());
+ boolean duplicate = regionLbs.values().stream()
+ .anyMatch(lb -> lb.getLoadBalancerName().equals(name));
+ if (duplicate) {
+ throw new AwsException("DuplicateLoadBalancerName",
+ "A load balancer with name '" + name + "' already exists.", 400);
+ }
+
+ String lbType = type != null ? type : "application";
+ String lbScheme = scheme != null ? scheme : "internet-facing";
+ String ipType = ipAddressType != null ? ipAddressType : "ipv4";
+ String typePrefix = lbTypePrefix(lbType);
+ String id = randomHex16();
+ String arn = "arn:aws:elasticloadbalancing:" + region + ":" + DEFAULT_ACCOUNT
+ + ":loadbalancer/" + typePrefix + "/" + name + "/" + id;
+ String dnsName = name + "-" + id + ".elb.localhost";
+
+ LoadBalancer lb = new LoadBalancer();
+ lb.setLoadBalancerArn(arn);
+ lb.setDnsName(dnsName);
+ lb.setCanonicalHostedZoneId(CANONICAL_HOSTED_ZONE_ID);
+ lb.setCreatedTime(Instant.now());
+ lb.setLoadBalancerName(name);
+ lb.setScheme(lbScheme);
+ lb.setVpcId("vpc-00000001");
+ lb.setState("active");
+ lb.setType(lbType);
+ lb.setIpAddressType(ipType);
+ lb.setRegion(region);
+ if (subnets != null) lb.setAvailabilityZones(new ArrayList<>(subnets));
+ if (securityGroups != null) lb.setSecurityGroups(new ArrayList<>(securityGroups));
+
+ regionLbs.put(arn, lb);
+ lbToListeners.put(arn, new ArrayList<>());
+ if (!initialTags.isEmpty()) {
+ tags.put(arn, new LinkedHashMap<>(initialTags));
+ }
+ return lb;
+ }
+
+ public List<LoadBalancer> describeLoadBalancers(String region, List<String> arns, List<String> names,
+ String marker, Integer pageSize) {
+ Map<String, LoadBalancer> regionLbs = loadBalancers.getOrDefault(region, Map.of());
+ List<LoadBalancer> result = new ArrayList<>(regionLbs.values());
+
+ if (arns != null && !arns.isEmpty()) {
+ Set<String> arnSet = new HashSet<>(arns);
+ result = result.stream().filter(lb -> arnSet.contains(lb.getLoadBalancerArn())).collect(Collectors.toList());
+ if (result.isEmpty() && !arns.isEmpty()) {
+ throw new AwsException("LoadBalancerNotFound",
+ "One or more load balancers not found.", 400);
+ }
+ }
+ if (names != null && !names.isEmpty()) {
+ Set<String> nameSet = new HashSet<>(names);
+ result = result.stream().filter(lb -> nameSet.contains(lb.getLoadBalancerName())).collect(Collectors.toList());
+ if (result.isEmpty() && !names.isEmpty()) {
+ throw new AwsException("LoadBalancerNotFound",
+ "One or more load balancers not found.", 400);
+ }
+ }
+ return result;
+ }
+
+ public void deleteLoadBalancer(String region, String arn) {
+ Map<String, LoadBalancer> regionLbs = loadBalancers.getOrDefault(region, Map.of());
+ LoadBalancer lb = regionLbs.remove(arn);
+ if (lb == null) {
+ return; // AWS silently ignores non-existent LBs on delete
+ }
+ // cascade: listeners → rules
+ List<String> listenerArns = lbToListeners.remove(arn);
+ if (listenerArns != null) {
+ Map<String, Listener> regionListeners = listeners.getOrDefault(region, Map.of());
+ Map<String, Rule> regionRules = rules.getOrDefault(region, Map.of());
+ for (String listenerArn : listenerArns) {
+ regionListeners.remove(listenerArn);
+ List<String> ruleArns = listenerToRules.remove(listenerArn);
+ if (ruleArns != null) {
+ ruleArns.forEach(regionRules::remove);
+ }
+ }
+ }
+ // remove from TG index
+ tgToLbs.values().forEach(lbSet -> lbSet.remove(arn));
+ tags.remove(arn);
+ }
+
+ public Map<String, String> describeLoadBalancerAttributes(String region, String arn) {
+ LoadBalancer lb = requireLoadBalancer(region, arn);
+ return new LinkedHashMap<>(lb.getAttributes());
+ }
+
+ public void modifyLoadBalancerAttributes(String region, String arn, Map<String, String> newAttrs) {
+ LoadBalancer lb = requireLoadBalancer(region, arn);
+ lb.getAttributes().putAll(newAttrs);
+ }
+
+ public void setSecurityGroups(String region, String arn, List<String> sgIds) {
+ LoadBalancer lb = requireLoadBalancer(region, arn);
+ lb.setSecurityGroups(new ArrayList<>(sgIds));
+ }
+
+ public void setSubnets(String region, String arn, List<String> subnets) {
+ LoadBalancer lb = requireLoadBalancer(region, arn);
+ lb.setAvailabilityZones(new ArrayList<>(subnets));
+ }
+
+ public void setIpAddressType(String region, String arn, String ipAddressType) {
+ LoadBalancer lb = requireLoadBalancer(region, arn);
+ lb.setIpAddressType(ipAddressType);
+ }
+
+ // ── Target Groups ─────────────────────────────────────────────────────────
+
+ public TargetGroup createTargetGroup(String region, String name, String protocol, String protocolVersion,
+ Integer port, String vpcId, String targetType,
+ String healthCheckProtocol, String healthCheckPort,
+ Boolean healthCheckEnabled, String healthCheckPath,
+ Integer healthCheckInterval, Integer healthCheckTimeout,
+ Integer healthyThreshold, Integer unhealthyThreshold,
+ String matcher, String ipAddressType,
+ Map<String, String> initialTags) {
+ validateName(name, "target group");
+ Map<String, TargetGroup> regionTgs = targetGroups.computeIfAbsent(region, k -> new ConcurrentHashMap<>());
+ boolean duplicate = regionTgs.values().stream()
+ .anyMatch(tg -> tg.getTargetGroupName().equals(name));
+ if (duplicate) {
+ throw new AwsException("DuplicateTargetGroupName",
+ "A target group with name '" + name + "' already exists.", 400);
+ }
+
+ String id = randomHex16();
+ String arn = "arn:aws:elasticloadbalancing:" + region + ":" + DEFAULT_ACCOUNT
+ + ":targetgroup/" + name + "/" + id;
+
+ TargetGroup tg = new TargetGroup();
+ tg.setTargetGroupArn(arn);
+ tg.setTargetGroupName(name);
+ tg.setProtocol(protocol != null ? protocol : "HTTP");
+ tg.setProtocolVersion(protocolVersion != null ? protocolVersion : "HTTP1");
+ tg.setPort(port);
+ tg.setVpcId(vpcId);
+ tg.setTargetType(targetType != null ? targetType : "instance");
+ tg.setIpAddressType(ipAddressType != null ? ipAddressType : "ipv4");
+ tg.setRegion(region);
+
+ // health check defaults
+ tg.setHealthCheckEnabled(healthCheckEnabled != null ? healthCheckEnabled : true);
+ tg.setHealthCheckProtocol(healthCheckProtocol != null ? healthCheckProtocol : "HTTP");
+ tg.setHealthCheckPort(healthCheckPort != null ? healthCheckPort : "traffic-port");
+ tg.setHealthCheckPath(healthCheckPath != null ? healthCheckPath : "/");
+ tg.setHealthCheckIntervalSeconds(healthCheckInterval != null ? healthCheckInterval : 30);
+ tg.setHealthCheckTimeoutSeconds(healthCheckTimeout != null ? healthCheckTimeout : 5);
+ tg.setHealthyThresholdCount(healthyThreshold != null ? healthyThreshold : 5);
+ tg.setUnhealthyThresholdCount(unhealthyThreshold != null ? unhealthyThreshold : 2);
+ tg.setMatcher(matcher != null ? matcher : "200");
+
+ regionTgs.put(arn, tg);
+ tgToLbs.put(arn, ConcurrentHashMap.newKeySet());
+ if (!initialTags.isEmpty()) {
+ tags.put(arn, new LinkedHashMap<>(initialTags));
+ }
+ return tg;
+ }
+
+ public List<TargetGroup> describeTargetGroups(String region, String lbArn, List<String> tgArns,
+ List<String> names) {
+ Map<String, TargetGroup> regionTgs = targetGroups.getOrDefault(region, Map.of());
+ List<TargetGroup> result = new ArrayList<>(regionTgs.values());
+
+ if (lbArn != null && !lbArn.isEmpty()) {
+ result = result.stream()
+ .filter(tg -> tgToLbs.getOrDefault(tg.getTargetGroupArn(), Set.of()).contains(lbArn))
+ .collect(Collectors.toList());
+ }
+ if (tgArns != null && !tgArns.isEmpty()) {
+ Set<String> arnSet = new HashSet<>(tgArns);
+ result = result.stream().filter(tg -> arnSet.contains(tg.getTargetGroupArn())).collect(Collectors.toList());
+ if (result.isEmpty()) {
+ throw new AwsException("TargetGroupNotFound", "One or more target groups not found.", 400);
+ }
+ }
+ if (names != null && !names.isEmpty()) {
+ Set<String> nameSet = new HashSet<>(names);
+ result = result.stream().filter(tg -> nameSet.contains(tg.getTargetGroupName())).collect(Collectors.toList());
+ }
+ return result;
+ }
+
+ public void deleteTargetGroup(String region, String arn) {
+ TargetGroup tg = targetGroups.getOrDefault(region, Map.of()).get(arn);
+ if (tg == null) {
+ return;
+ }
+ Set<String> lbRefs = tgToLbs.getOrDefault(arn, Set.of());
+ if (!lbRefs.isEmpty()) {
+ throw new AwsException("ResourceInUse",
+ "Target group '" + tg.getTargetGroupName() + "' is currently in use by a listener or rule.", 400);
+ }
+ targetGroups.getOrDefault(region, Map.of()).remove(arn);
+ tgToLbs.remove(arn);
+ tags.remove(arn);
+ }
+
+ public void modifyTargetGroup(String region, String arn, String healthCheckProtocol,
+ String healthCheckPort, Boolean healthCheckEnabled,
+ String healthCheckPath, Integer healthCheckInterval,
+ Integer healthCheckTimeout, Integer healthyThreshold,
+ Integer unhealthyThreshold, String matcher) {
+ TargetGroup tg = requireTargetGroup(region, arn);
+ if (healthCheckProtocol != null) tg.setHealthCheckProtocol(healthCheckProtocol);
+ if (healthCheckPort != null) tg.setHealthCheckPort(healthCheckPort);
+ if (healthCheckEnabled != null) tg.setHealthCheckEnabled(healthCheckEnabled);
+ if (healthCheckPath != null) tg.setHealthCheckPath(healthCheckPath);
+ if (healthCheckInterval != null) tg.setHealthCheckIntervalSeconds(healthCheckInterval);
+ if (healthCheckTimeout != null) tg.setHealthCheckTimeoutSeconds(healthCheckTimeout);
+ if (healthyThreshold != null) tg.setHealthyThresholdCount(healthyThreshold);
+ if (unhealthyThreshold != null) tg.setUnhealthyThresholdCount(unhealthyThreshold);
+ if (matcher != null) tg.setMatcher(matcher);
+ }
+
+ public Map<String, String> describeTargetGroupAttributes(String region, String arn) {
+ TargetGroup tg = requireTargetGroup(region, arn);
+ return new LinkedHashMap<>(tg.getAttributes());
+ }
+
+ public void modifyTargetGroupAttributes(String region, String arn, Map<String, String> newAttrs) {
+ TargetGroup tg = requireTargetGroup(region, arn);
+ tg.getAttributes().putAll(newAttrs);
+ }
+
+ // ── Listeners ─────────────────────────────────────────────────────────────
+
+ public Listener createListener(String region, String lbArn, String protocol, Integer port,
+ String sslPolicy, List<String> certificates,
+ List<Action> defaultActions, List<String> alpnPolicy,
+ Map<String, String> initialTags) {
+ requireLoadBalancer(region, lbArn);
+
+ Map<String, Listener> regionListeners = listeners.computeIfAbsent(region, k -> new ConcurrentHashMap<>());
+
+ // check duplicate port on same LB
+ boolean portExists = regionListeners.values().stream()
+ .filter(l -> l.getLoadBalancerArn().equals(lbArn))
+ .anyMatch(l -> Objects.equals(l.getPort(), port));
+ if (portExists) {
+ throw new AwsException("DuplicateListener",
+ "A listener already exists on port " + port + " for this load balancer.", 400);
+ }
+
+ LoadBalancer lb = requireLoadBalancer(region, lbArn);
+ String lbType = lb.getType() != null ? lb.getType() : "application";
+ String typePrefix = lbTypePrefix(lbType);
+ String lbId = arnId(lbArn);
+ String listenerId = randomHex16();
+ String listenerArn = "arn:aws:elasticloadbalancing:" + region + ":" + DEFAULT_ACCOUNT
+ + ":listener/" + typePrefix + "/" + lb.getLoadBalancerName() + "/" + lbId + "/" + listenerId;
+
+ Listener listener = new Listener();
+ listener.setListenerArn(listenerArn);
+ listener.setLoadBalancerArn(lbArn);
+ listener.setPort(port);
+ listener.setProtocol(protocol != null ? protocol : "HTTP");
+ listener.setSslPolicy(sslPolicy);
+ listener.setCertificates(certificates != null ? new ArrayList<>(certificates) : new ArrayList<>());
+ listener.setDefaultActions(defaultActions != null ? new ArrayList<>(defaultActions) : new ArrayList<>());
+ listener.setAlpnPolicy(alpnPolicy != null ? new ArrayList<>(alpnPolicy) : new ArrayList<>());
+
+ regionListeners.put(listenerArn, listener);
+ lbToListeners.computeIfAbsent(lbArn, k -> new ArrayList<>()).add(listenerArn);
+
+ // auto-create the default rule
+ Rule defaultRule = buildDefaultRule(region, listenerArn, lb, lbId, listenerId, defaultActions);
+ rules.computeIfAbsent(region, k -> new ConcurrentHashMap<>()).put(defaultRule.getRuleArn(), defaultRule);
+ listenerToRules.computeIfAbsent(listenerArn, k -> new ArrayList<>()).add(defaultRule.getRuleArn());
+
+ if (!initialTags.isEmpty()) {
+ tags.put(listenerArn, new LinkedHashMap<>(initialTags));
+ }
+ return listener;
+ }
+
+ public List<Listener> describeListeners(String region, String lbArn, List<String> listenerArns) {
+ Map<String, Listener> regionListeners = listeners.getOrDefault(region, Map.of());
+ List<Listener> result = new ArrayList<>(regionListeners.values());
+
+ if (lbArn != null && !lbArn.isEmpty()) {
+ result = result.stream()
+ .filter(l -> l.getLoadBalancerArn().equals(lbArn))
+ .collect(Collectors.toList());
+ }
+ if (listenerArns != null && !listenerArns.isEmpty()) {
+ Set<String> arnSet = new HashSet<>(listenerArns);
+ result = result.stream().filter(l -> arnSet.contains(l.getListenerArn())).collect(Collectors.toList());
+ }
+ return result;
+ }
+
+ public void deleteListener(String region, String listenerArn) {
+ Map<String, Listener> regionListeners = listeners.getOrDefault(region, Map.of());
+ Listener listener = regionListeners.remove(listenerArn);
+ if (listener == null) {
+ return;
+ }
+ lbToListeners.getOrDefault(listener.getLoadBalancerArn(), List.of()).remove(listenerArn);
+
+ Map<String, Rule> regionRules = rules.getOrDefault(region, Map.of());
+ List<String> ruleArns = listenerToRules.remove(listenerArn);
+ if (ruleArns != null) {
+ ruleArns.forEach(regionRules::remove);
+ }
+ tags.remove(listenerArn);
+ }
+
+ public Listener modifyListener(String region, String listenerArn, String protocol, Integer port,
+ String sslPolicy, List<String> certificates,
+ List<Action> defaultActions, List<String> alpnPolicy) {
+ Listener listener = requireListener(region, listenerArn);
+
+ if (port != null && !Objects.equals(listener.getPort(), port)) {
+ // check duplicate port on same LB
+ Map<String, Listener> regionListeners = listeners.getOrDefault(region, Map.of());
+ boolean portExists = regionListeners.values().stream()
+ .filter(l -> l.getLoadBalancerArn().equals(listener.getLoadBalancerArn()) && !l.getListenerArn().equals(listenerArn))
+ .anyMatch(l -> Objects.equals(l.getPort(), port));
+ if (portExists) {
+ throw new AwsException("DuplicateListener",
+ "A listener already exists on port " + port + " for this load balancer.", 400);
+ }
+ listener.setPort(port);
+ }
+ if (protocol != null) listener.setProtocol(protocol);
+ if (sslPolicy != null) listener.setSslPolicy(sslPolicy);
+ if (certificates != null) listener.setCertificates(new ArrayList<>(certificates));
+ if (alpnPolicy != null) listener.setAlpnPolicy(new ArrayList<>(alpnPolicy));
+ if (defaultActions != null) {
+ listener.setDefaultActions(new ArrayList<>(defaultActions));
+ // update the default rule's actions
+ listenerToRules.getOrDefault(listenerArn, List.of()).stream()
+ .map(ra -> rules.getOrDefault(region, Map.of()).get(ra))
+ .filter(r -> r != null && r.isDefault())
+ .forEach(r -> r.setActions(new ArrayList<>(defaultActions)));
+ }
+ return listener;
+ }
+
+ // ── Rules ─────────────────────────────────────────────────────────────────
+
+ public Rule createRule(String region, String listenerArn, List<RuleCondition> conditions,
+ int priority, List<Action> actions, Map<String, String> initialTags) {
+ requireListener(region, listenerArn);
+ if (priority < 1 || priority > 50000) {
+ throw new AwsException("ValidationError", "Priority must be between 1 and 50000.", 400);
+ }
+
+ Map<String, Rule> regionRules = rules.computeIfAbsent(region, k -> new ConcurrentHashMap<>());
+ List<String> existingRuleArns = listenerToRules.getOrDefault(listenerArn, List.of());
+ String priorityStr = String.valueOf(priority);
+ boolean priorityTaken = existingRuleArns.stream()
+ .map(regionRules::get)
+ .filter(Objects::nonNull)
+ .anyMatch(r -> priorityStr.equals(r.getPriority()));
+ if (priorityTaken) {
+ throw new AwsException("PriorityInUse",
+ "The specified priority is already in use.", 400);
+ }
+
+ Listener listener = requireListener(region, listenerArn);
+ LoadBalancer lb = requireLoadBalancer(region, listener.getLoadBalancerArn());
+ String lbType = lb.getType() != null ? lb.getType() : "application";
+ String typePrefix = lbTypePrefix(lbType);
+ String lbId = arnId(listener.getLoadBalancerArn());
+ String listenerId = arnId(listenerArn);
+ String ruleId = randomHex16();
+ String ruleArn = "arn:aws:elasticloadbalancing:" + region + ":" + DEFAULT_ACCOUNT
+ + ":listener-rule/" + typePrefix + "/" + lb.getLoadBalancerName() + "/" + lbId + "/" + listenerId + "/" + ruleId;
+
+ Rule rule = new Rule();
+ rule.setRuleArn(ruleArn);
+ rule.setListenerArn(listenerArn);
+ rule.setPriority(priorityStr);
+ rule.setConditions(conditions != null ? new ArrayList<>(conditions) : new ArrayList<>());
+ rule.setActions(actions != null ? new ArrayList<>(actions) : new ArrayList<>());
+ rule.setDefault(false);
+
+ regionRules.put(ruleArn, rule);
+ listenerToRules.computeIfAbsent(listenerArn, k -> new ArrayList<>()).add(ruleArn);
+
+ // update TG → LB index for all target group actions
+ for (Action a : rule.getActions()) {
+ linkTgToLb(a, listener.getLoadBalancerArn());
+ }
+
+ if (!initialTags.isEmpty()) {
+ tags.put(ruleArn, new LinkedHashMap<>(initialTags));
+ }
+ return rule;
+ }
+
+ public List<Rule> describeRules(String region, String listenerArn, List<String> ruleArns) {
+ Map<String, Rule> regionRules = rules.getOrDefault(region, Map.of());
+
+ if (ruleArns != null && !ruleArns.isEmpty()) {
+ return ruleArns.stream()
+ .map(regionRules::get)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ }
+ if (listenerArn != null && !listenerArn.isEmpty()) {
+ return listenerToRules.getOrDefault(listenerArn, List.of()).stream()
+ .map(regionRules::get)
+ .filter(Objects::nonNull)
+ .sorted(Comparator.comparing(r -> prioritySortKey(r.getPriority())))
+ .collect(Collectors.toList());
+ }
+ return new ArrayList<>(regionRules.values());
+ }
+
+ public void deleteRule(String region, String ruleArn) {
+ Map<String, Rule> regionRules = rules.getOrDefault(region, Map.of());
+ Rule rule = regionRules.get(ruleArn);
+ if (rule == null) {
+ return;
+ }
+ if (rule.isDefault()) {
+ throw new AwsException("OperationNotPermitted",
+ "The default rule for a listener cannot be deleted.", 400);
+ }
+ regionRules.remove(ruleArn);
+ listenerToRules.getOrDefault(rule.getListenerArn(), List.of()).remove(ruleArn);
+ tags.remove(ruleArn);
+ }
+
+ public Rule modifyRule(String region, String ruleArn, List<RuleCondition> conditions, List<Action> actions) {
+ Rule rule = requireRule(region, ruleArn);
+ if (conditions != null) rule.setConditions(new ArrayList<>(conditions));
+ if (actions != null) rule.setActions(new ArrayList<>(actions));
+ return rule;
+ }
+
+ public void setRulePriorities(String region, Map<String, Integer> arnToPriority) {
+ Map<String, Rule> regionRules = rules.getOrDefault(region, Map.of());
+
+ // validate all rules exist and are not default before touching anything
+ for (Map.Entry<String, Integer> e : arnToPriority.entrySet()) {
+ Rule rule = regionRules.get(e.getKey());
+ if (rule == null) {
+ throw new AwsException("RuleNotFound", "Rule not found: " + e.getKey(), 400);
+ }
+ if (rule.isDefault()) {
+ throw new AwsException("OperationNotPermitted", "Cannot change priority of the default rule.", 400);
+ }
+ int p = e.getValue();
+ if (p < 1 || p > 50000) {
+ throw new AwsException("ValidationError", "Priority must be between 1 and 50000.", 400);
+ }
+ }
+
+ // check for collisions with rules NOT in the update set
+ Set<String> updatingArns = arnToPriority.keySet();
+ Set<Integer> newPriorities = new HashSet<>(arnToPriority.values());
+ for (Rule existing : regionRules.values()) {
+ if (!updatingArns.contains(existing.getRuleArn()) && !existing.isDefault()) {
+ try {
+ int existingPriority = Integer.parseInt(existing.getPriority());
+ if (newPriorities.contains(existingPriority)) {
+ throw new AwsException("PriorityInUse",
+ "Priority " + existingPriority + " is already in use.", 400);
+ }
+ } catch (NumberFormatException ignored) { /* default rule */ }
+ }
+ }
+
+ // commit
+ arnToPriority.forEach((arn, priority) -> regionRules.get(arn).setPriority(String.valueOf(priority)));
+ }
+
+ // ── Targets ───────────────────────────────────────────────────────────────
+
+ public void registerTargets(String region, String tgArn, List<TargetDescription> targets) {
+ TargetGroup tg = requireTargetGroup(region, tgArn);
+ List<TargetDescription> existing = tg.getTargets();
+ for (TargetDescription t : targets) {
+ // replace if same id+port already registered
+ existing.removeIf(e -> e.getId().equals(t.getId()) && Objects.equals(e.getPort(), t.getPort()));
+ existing.add(t);
+ }
+ }
+
+ public void deregisterTargets(String region, String tgArn, List<TargetDescription> targets) {
+ TargetGroup tg = requireTargetGroup(region, tgArn);
+ for (TargetDescription t : targets) {
+ tg.getTargets().removeIf(e -> e.getId().equals(t.getId()) && Objects.equals(e.getPort(), t.getPort()));
+ }
+ }
+
+ public List<TargetHealth> describeTargetHealth(String region, String tgArn,
+ List<TargetDescription> filterTargets) {
+ TargetGroup tg = requireTargetGroup(region, tgArn);
+ List<TargetDescription> candidates = filterTargets != null && !filterTargets.isEmpty()
+ ? filterTargets : tg.getTargets();
+
+ return candidates.stream().map(t -> {
+ TargetHealth th = new TargetHealth();
+ th.setTarget(t);
+ th.setHealthCheckPort(tg.getHealthCheckPort() != null ? tg.getHealthCheckPort() : "traffic-port");
+ th.setState("initial");
+ th.setReason("Elb.RegistrationInProgress");
+ th.setDescription("Target registration is in progress");
+ return th;
+ }).collect(Collectors.toList());
+ }
+
+ // ── Tags ──────────────────────────────────────────────────────────────────
+
+ public void addTags(List<String> resourceArns, Map<String, String> newTags) {
+ for (String arn : resourceArns) {
+ tags.computeIfAbsent(arn, k -> new LinkedHashMap<>()).putAll(newTags);
+ }
+ }
+
+ public void removeTags(List<String> resourceArns, List<String> tagKeys) {
+ for (String arn : resourceArns) {
+ Map<String, String> resourceTags = tags.get(arn);
+ if (resourceTags != null) {
+ tagKeys.forEach(resourceTags::remove);
+ }
+ }
+ }
+
+ public Map<String, Map<String, String>> describeTags(List<String> resourceArns) {
+ Map<String, Map<String, String>> result = new LinkedHashMap<>();
+ for (String arn : resourceArns) {
+ result.put(arn, tags.getOrDefault(arn, Map.of()));
+ }
+ return result;
+ }
+
+ // ── Listener Certificates ─────────────────────────────────────────────────
+
+ public void addListenerCertificates(String region, String listenerArn, List<String> certArns) {
+ Listener listener = requireListener(region, listenerArn);
+ for (String certArn : certArns) {
+ if (!listener.getCertificates().contains(certArn)) {
+ listener.getCertificates().add(certArn);
+ }
+ }
+ }
+
+ public void removeListenerCertificates(String region, String listenerArn, List<String> certArns) {
+ Listener listener = requireListener(region, listenerArn);
+ listener.getCertificates().removeAll(certArns);
+ }
+
+ public List<String> describeListenerCertificates(String region, String listenerArn) {
+ Listener listener = requireListener(region, listenerArn);
+ return new ArrayList<>(listener.getCertificates());
+ }
+
+ // ── Helpers ───────────────────────────────────────────────────────────────
+
+ private LoadBalancer requireLoadBalancer(String region, String arn) {
+ LoadBalancer lb = loadBalancers.getOrDefault(region, Map.of()).get(arn);
+ if (lb == null) {
+ throw new AwsException("LoadBalancerNotFound",
+ "One or more load balancers not found.", 400);
+ }
+ return lb;
+ }
+
+ private TargetGroup requireTargetGroup(String region, String arn) {
+ TargetGroup tg = targetGroups.getOrDefault(region, Map.of()).get(arn);
+ if (tg == null) {
+ throw new AwsException("TargetGroupNotFound",
+ "One or more target groups not found.", 400);
+ }
+ return tg;
+ }
+
+ private Listener requireListener(String region, String arn) {
+ Listener l = listeners.getOrDefault(region, Map.of()).get(arn);
+ if (l == null) {
+ throw new AwsException("ListenerNotFound",
+ "One or more listeners not found.", 400);
+ }
+ return l;
+ }
+
+ private Rule requireRule(String region, String arn) {
+ Rule r = rules.getOrDefault(region, Map.of()).get(arn);
+ if (r == null) {
+ throw new AwsException("RuleNotFound", "One or more rules not found.", 400);
+ }
+ return r;
+ }
+
+ private static void validateName(String name, String resource) {
+ if (name == null || name.isEmpty()) {
+ throw new AwsException("ValidationError", "Name is required for " + resource + ".", 400);
+ }
+ if (name.length() > 32) {
+ throw new AwsException("ValidationError",
+ "Name '" + name + "' exceeds 32 characters.", 400);
+ }
+ if (!name.matches("[a-zA-Z0-9-]+")) {
+ throw new AwsException("ValidationError",
+ "Name '" + name + "' contains invalid characters. Use alphanumeric characters and hyphens.", 400);
+ }
+ if (name.startsWith("-") || name.endsWith("-")) {
+ throw new AwsException("ValidationError",
+ "Name '" + name + "' cannot start or end with a hyphen.", 400);
+ }
+ }
+
+ private static String randomHex16() {
+ return UUID.randomUUID().toString().replace("-", "").substring(0, 16);
+ }
+
+ private static String lbTypePrefix(String type) {
+ return switch (type) {
+ case "network" -> "net";
+ case "gateway" -> "gwy";
+ default -> "app";
+ };
+ }
+
+ // extracts the last path segment of an ARN (the random hex ID)
+ private static String arnId(String arn) {
+ int last = arn.lastIndexOf('/');
+ return last >= 0 ? arn.substring(last + 1) : arn;
+ }
+
+ private static int prioritySortKey(String priority) {
+ if ("default".equals(priority)) return Integer.MAX_VALUE;
+ try { return Integer.parseInt(priority); } catch (NumberFormatException e) { return Integer.MAX_VALUE; }
+ }
+
+ private Rule buildDefaultRule(String region, String listenerArn, LoadBalancer lb, String lbId,
+ String listenerId, List<Action> defaultActions) {
+ String lbType = lb.getType() != null ? lb.getType() : "application";
+ String typePrefix = lbTypePrefix(lbType);
+ String ruleId = randomHex16();
+ String ruleArn = "arn:aws:elasticloadbalancing:" + region + ":" + DEFAULT_ACCOUNT
+ + ":listener-rule/" + typePrefix + "/" + lb.getLoadBalancerName() + "/" + lbId + "/" + listenerId + "/" + ruleId;
+
+ Rule rule = new Rule();
+ rule.setRuleArn(ruleArn);
+ rule.setListenerArn(listenerArn);
+ rule.setPriority("default");
+ rule.setConditions(new ArrayList<>());
+ rule.setActions(defaultActions != null ? new ArrayList<>(defaultActions) : new ArrayList<>());
+ rule.setDefault(true);
+ return rule;
+ }
+
+ private void linkTgToLb(Action action, String lbArn) {
+ if ("forward".equals(action.getType())) {
+ if (action.getTargetGroupArn() != null) {
+ tgToLbs.computeIfAbsent(action.getTargetGroupArn(), k -> ConcurrentHashMap.newKeySet()).add(lbArn);
+ }
+ for (Action.TargetGroupTuple t : action.getTargetGroups()) {
+ if (t.getTargetGroupArn() != null) {
+ tgToLbs.computeIfAbsent(t.getTargetGroupArn(), k -> ConcurrentHashMap.newKeySet()).add(lbArn);
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java
new file mode 100644
index 0000000000..3f85746be1
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Action.java
@@ -0,0 +1,98 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Action {
+
+ private String type;
+ private Integer order;
+
+ // forward (simple)
+ private String targetGroupArn;
+
+ // forward (weighted)
+ private List<TargetGroupTuple> targetGroups = new ArrayList<>();
+ private Boolean stickinessEnabled;
+ private Integer stickinessDurationSeconds;
+
+ // redirect
+ private String redirectProtocol;
+ private String redirectPort;
+ private String redirectHost;
+ private String redirectPath;
+ private String redirectQuery;
+ private String redirectStatusCode;
+
+ // fixed-response
+ private String fixedResponseStatusCode;
+ private String fixedResponseContentType;
+ private String fixedResponseMessageBody;
+
+ public Action() {}
+
+ public String getType() { return type; }
+ public void setType(String type) { this.type = type; }
+
+ public Integer getOrder() { return order; }
+ public void setOrder(Integer order) { this.order = order; }
+
+ public String getTargetGroupArn() { return targetGroupArn; }
+ public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }
+
+ public List<TargetGroupTuple> getTargetGroups() { return targetGroups; }
+ public void setTargetGroups(List<TargetGroupTuple> targetGroups) { this.targetGroups = targetGroups; }
+
+ public Boolean getStickinessEnabled() { return stickinessEnabled; }
+ public void setStickinessEnabled(Boolean stickinessEnabled) { this.stickinessEnabled = stickinessEnabled; }
+
+ public Integer getStickinessDurationSeconds() { return stickinessDurationSeconds; }
+ public void setStickinessDurationSeconds(Integer stickinessDurationSeconds) { this.stickinessDurationSeconds = stickinessDurationSeconds; }
+
+ public String getRedirectProtocol() { return redirectProtocol; }
+ public void setRedirectProtocol(String redirectProtocol) { this.redirectProtocol = redirectProtocol; }
+
+ public String getRedirectPort() { return redirectPort; }
+ public void setRedirectPort(String redirectPort) { this.redirectPort = redirectPort; }
+
+ public String getRedirectHost() { return redirectHost; }
+ public void setRedirectHost(String redirectHost) { this.redirectHost = redirectHost; }
+
+ public String getRedirectPath() { return redirectPath; }
+ public void setRedirectPath(String redirectPath) { this.redirectPath = redirectPath; }
+
+ public String getRedirectQuery() { return redirectQuery; }
+ public void setRedirectQuery(String redirectQuery) { this.redirectQuery = redirectQuery; }
+
+ public String getRedirectStatusCode() { return redirectStatusCode; }
+ public void setRedirectStatusCode(String redirectStatusCode) { this.redirectStatusCode = redirectStatusCode; }
+
+ public String getFixedResponseStatusCode() { return fixedResponseStatusCode; }
+ public void setFixedResponseStatusCode(String fixedResponseStatusCode) { this.fixedResponseStatusCode = fixedResponseStatusCode; }
+
+ public String getFixedResponseContentType() { return fixedResponseContentType; }
+ public void setFixedResponseContentType(String fixedResponseContentType) { this.fixedResponseContentType = fixedResponseContentType; }
+
+ public String getFixedResponseMessageBody() { return fixedResponseMessageBody; }
+ public void setFixedResponseMessageBody(String fixedResponseMessageBody) { this.fixedResponseMessageBody = fixedResponseMessageBody; }
+
+ @RegisterForReflection
+ @JsonIgnoreProperties(ignoreUnknown = true)
+ public static class TargetGroupTuple {
+ private String targetGroupArn;
+ private Integer weight;
+
+ public TargetGroupTuple() {}
+
+ public String getTargetGroupArn() { return targetGroupArn; }
+ public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }
+
+ public Integer getWeight() { return weight; }
+ public void setWeight(Integer weight) { this.weight = weight; }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Listener.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Listener.java
new file mode 100644
index 0000000000..307710aede
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Listener.java
@@ -0,0 +1,53 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Listener {
+
+ private String listenerArn;
+ private String loadBalancerArn;
+ private Integer port;
+ private String protocol;
+ private List<String> certificates = new ArrayList<>();
+ private String sslPolicy;
+ private List<Action> defaultActions = new ArrayList<>();
+ private List<String> alpnPolicy = new ArrayList<>();
+ private Map<String, String> attributes = new LinkedHashMap<>();
+
+ public Listener() {}
+
+ public String getListenerArn() { return listenerArn; }
+ public void setListenerArn(String listenerArn) { this.listenerArn = listenerArn; }
+
+ public String getLoadBalancerArn() { return loadBalancerArn; }
+ public void setLoadBalancerArn(String loadBalancerArn) { this.loadBalancerArn = loadBalancerArn; }
+
+ public Integer getPort() { return port; }
+ public void setPort(Integer port) { this.port = port; }
+
+ public String getProtocol() { return protocol; }
+ public void setProtocol(String protocol) { this.protocol = protocol; }
+
+ public List<String> getCertificates() { return certificates; }
+ public void setCertificates(List<String> certificates) { this.certificates = certificates; }
+
+ public String getSslPolicy() { return sslPolicy; }
+ public void setSslPolicy(String sslPolicy) { this.sslPolicy = sslPolicy; }
+
+ public List<Action> getDefaultActions() { return defaultActions; }
+ public void setDefaultActions(List<Action> defaultActions) { this.defaultActions = defaultActions; }
+
+ public List<String> getAlpnPolicy() { return alpnPolicy; }
+ public void setAlpnPolicy(List<String> alpnPolicy) { this.alpnPolicy = alpnPolicy; }
+
+ public Map<String, String> getAttributes() { return attributes; }
+ public void setAttributes(Map<String, String> attributes) { this.attributes = attributes; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/LoadBalancer.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/LoadBalancer.java
new file mode 100644
index 0000000000..3f19e75b1b
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/LoadBalancer.java
@@ -0,0 +1,74 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class LoadBalancer {
+
+ private String loadBalancerArn;
+ private String dnsName;
+ private String canonicalHostedZoneId;
+ private Instant createdTime;
+ private String loadBalancerName;
+ private String scheme;
+ private String vpcId;
+ private String state;
+ private String type;
+ private List<String> availabilityZones = new ArrayList<>();
+ private List<String> securityGroups = new ArrayList<>();
+ private String ipAddressType;
+ private String region;
+ private Map<String, String> attributes = new LinkedHashMap<>();
+
+ public LoadBalancer() {}
+
+ public String getLoadBalancerArn() { return loadBalancerArn; }
+ public void setLoadBalancerArn(String loadBalancerArn) { this.loadBalancerArn = loadBalancerArn; }
+
+ public String getDnsName() { return dnsName; }
+ public void setDnsName(String dnsName) { this.dnsName = dnsName; }
+
+ public String getCanonicalHostedZoneId() { return canonicalHostedZoneId; }
+ public void setCanonicalHostedZoneId(String canonicalHostedZoneId) { this.canonicalHostedZoneId = canonicalHostedZoneId; }
+
+ public Instant getCreatedTime() { return createdTime; }
+ public void setCreatedTime(Instant createdTime) { this.createdTime = createdTime; }
+
+ public String getLoadBalancerName() { return loadBalancerName; }
+ public void setLoadBalancerName(String loadBalancerName) { this.loadBalancerName = loadBalancerName; }
+
+ public String getScheme() { return scheme; }
+ public void setScheme(String scheme) { this.scheme = scheme; }
+
+ public String getVpcId() { return vpcId; }
+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }
+
+ public String getState() { return state; }
+ public void setState(String state) { this.state = state; }
+
+ public String getType() { return type; }
+ public void setType(String type) { this.type = type; }
+
+ public List<String> getAvailabilityZones() { return availabilityZones; }
+ public void setAvailabilityZones(List<String> availabilityZones) { this.availabilityZones = availabilityZones; }
+
+ public List<String> getSecurityGroups() { return securityGroups; }
+ public void setSecurityGroups(List<String> securityGroups) { this.securityGroups = securityGroups; }
+
+ public String getIpAddressType() { return ipAddressType; }
+ public void setIpAddressType(String ipAddressType) { this.ipAddressType = ipAddressType; }
+
+ public String getRegion() { return region; }
+ public void setRegion(String region) { this.region = region; }
+
+ public Map<String, String> getAttributes() { return attributes; }
+ public void setAttributes(Map<String, String> attributes) { this.attributes = attributes; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Rule.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Rule.java
new file mode 100644
index 0000000000..6a332e440c
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/Rule.java
@@ -0,0 +1,39 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Rule {
+
+ private String ruleArn;
+ private String listenerArn;
+ private String priority;
+ private List<RuleCondition> conditions = new ArrayList<>();
+ private List<Action> actions = new ArrayList<>();
+ private boolean isDefault;
+
+ public Rule() {}
+
+ public String getRuleArn() { return ruleArn; }
+ public void setRuleArn(String ruleArn) { this.ruleArn = ruleArn; }
+
+ public String getListenerArn() { return listenerArn; }
+ public void setListenerArn(String listenerArn) { this.listenerArn = listenerArn; }
+
+ public String getPriority() { return priority; }
+ public void setPriority(String priority) { this.priority = priority; }
+
+ public List<RuleCondition> getConditions() { return conditions; }
+ public void setConditions(List<RuleCondition> conditions) { this.conditions = conditions; }
+
+ public List<Action> getActions() { return actions; }
+ public void setActions(List<Action> actions) { this.actions = actions; }
+
+ public boolean isDefault() { return isDefault; }
+ public void setDefault(boolean aDefault) { isDefault = aDefault; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/RuleCondition.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/RuleCondition.java
new file mode 100644
index 0000000000..a7c77c0ab4
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/RuleCondition.java
@@ -0,0 +1,68 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class RuleCondition {
+
+ private String field;
+ private List<String> values = new ArrayList<>();
+
+ // typed configs
+ private List<String> hostHeaderValues = new ArrayList<>();
+ private List<String> pathPatternValues = new ArrayList<>();
+ private String httpHeaderName;
+ private List<String> httpHeaderValues = new ArrayList<>();
+ private List<String> httpMethodValues = new ArrayList<>();
+ private List<String> sourceIpValues = new ArrayList<>();
+ private List<QueryStringPair> queryStringValues = new ArrayList<>();
+
+ public RuleCondition() {}
+
+ public String getField() { return field; }
+ public void setField(String field) { this.field = field; }
+
+ public List<String> getValues() { return values; }
+ public void setValues(List<String> values) { this.values = values; }
+
+ public List<String> getHostHeaderValues() { return hostHeaderValues; }
+ public void setHostHeaderValues(List<String> hostHeaderValues) { this.hostHeaderValues = hostHeaderValues; }
+
+ public List<String> getPathPatternValues() { return pathPatternValues; }
+ public void setPathPatternValues(List<String> pathPatternValues) { this.pathPatternValues = pathPatternValues; }
+
+ public String getHttpHeaderName() { return httpHeaderName; }
+ public void setHttpHeaderName(String httpHeaderName) { this.httpHeaderName = httpHeaderName; }
+
+ public List<String> getHttpHeaderValues() { return httpHeaderValues; }
+ public void setHttpHeaderValues(List<String> httpHeaderValues) { this.httpHeaderValues = httpHeaderValues; }
+
+ public List<String> getHttpMethodValues() { return httpMethodValues; }
+ public void setHttpMethodValues(List<String> httpMethodValues) { this.httpMethodValues = httpMethodValues; }
+
+ public List<String> getSourceIpValues() { return sourceIpValues; }
+ public void setSourceIpValues(List<String> sourceIpValues) { this.sourceIpValues = sourceIpValues; }
+
+ public List<QueryStringPair> getQueryStringValues() { return queryStringValues; }
+ public void setQueryStringValues(List<QueryStringPair> queryStringValues) { this.queryStringValues = queryStringValues; }
+
+ @RegisterForReflection
+ @JsonIgnoreProperties(ignoreUnknown = true)
+ public static class QueryStringPair {
+ private String key;
+ private String value;
+
+ public QueryStringPair() {}
+
+ public String getKey() { return key; }
+ public void setKey(String key) { this.key = key; }
+
+ public String getValue() { return value; }
+ public void setValue(String value) { this.value = value; }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetDescription.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetDescription.java
new file mode 100644
index 0000000000..396ff17e92
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetDescription.java
@@ -0,0 +1,24 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class TargetDescription {
+
+ private String id;
+ private Integer port;
+ private String availabilityZone;
+
+ public TargetDescription() {}
+
+ public String getId() { return id; }
+ public void setId(String id) { this.id = id; }
+
+ public Integer getPort() { return port; }
+ public void setPort(Integer port) { this.port = port; }
+
+ public String getAvailabilityZone() { return availabilityZone; }
+ public void setAvailabilityZone(String availabilityZone) { this.availabilityZone = availabilityZone; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetGroup.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetGroup.java
new file mode 100644
index 0000000000..4b607f61be
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetGroup.java
@@ -0,0 +1,101 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class TargetGroup {
+
+ private String targetGroupArn;
+ private String targetGroupName;
+ private String protocol;
+ private String protocolVersion;
+ private Integer port;
+ private String vpcId;
+ private String healthCheckProtocol;
+ private String healthCheckPort;
+ private Boolean healthCheckEnabled;
+ private Integer healthCheckIntervalSeconds;
+ private Integer healthCheckTimeoutSeconds;
+ private Integer healthyThresholdCount;
+ private Integer unhealthyThresholdCount;
+ private String healthCheckPath;
+ private String matcher;
+ private List<String> loadBalancerArns = new ArrayList<>();
+ private String targetType;
+ private String ipAddressType;
+ private String region;
+ private Map<String, String> attributes = new LinkedHashMap<>();
+ private List<TargetDescription> targets = new ArrayList<>();
+
+ public TargetGroup() {}
+
+ public String getTargetGroupArn() { return targetGroupArn; }
+ public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }
+
+ public String getTargetGroupName() { return targetGroupName; }
+ public void setTargetGroupName(String targetGroupName) { this.targetGroupName = targetGroupName; }
+
+ public String getProtocol() { return protocol; }
+ public void setProtocol(String protocol) { this.protocol = protocol; }
+
+ public String getProtocolVersion() { return protocolVersion; }
+ public void setProtocolVersion(String protocolVersion) { this.protocolVersion = protocolVersion; }
+
+ public Integer getPort() { return port; }
+ public void setPort(Integer port) { this.port = port; }
+
+ public String getVpcId() { return vpcId; }
+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }
+
+ public String getHealthCheckProtocol() { return healthCheckProtocol; }
+ public void setHealthCheckProtocol(String healthCheckProtocol) { this.healthCheckProtocol = healthCheckProtocol; }
+
+ public String getHealthCheckPort() { return healthCheckPort; }
+ public void setHealthCheckPort(String healthCheckPort) { this.healthCheckPort = healthCheckPort; }
+
+ public Boolean getHealthCheckEnabled() { return healthCheckEnabled; }
+ public void setHealthCheckEnabled(Boolean healthCheckEnabled) { this.healthCheckEnabled = healthCheckEnabled; }
+
+ public Integer getHealthCheckIntervalSeconds() { return healthCheckIntervalSeconds; }
+ public void setHealthCheckIntervalSeconds(Integer healthCheckIntervalSeconds) { this.healthCheckIntervalSeconds = healthCheckIntervalSeconds; }
+
+ public Integer getHealthCheckTimeoutSeconds() { return healthCheckTimeoutSeconds; }
+ public void setHealthCheckTimeoutSeconds(Integer healthCheckTimeoutSeconds) { this.healthCheckTimeoutSeconds = healthCheckTimeoutSeconds; }
+
+ public Integer getHealthyThresholdCount() { return healthyThresholdCount; }
+ public void setHealthyThresholdCount(Integer healthyThresholdCount) { this.healthyThresholdCount = healthyThresholdCount; }
+
+ public Integer getUnhealthyThresholdCount() { return unhealthyThresholdCount; }
+ public void setUnhealthyThresholdCount(Integer unhealthyThresholdCount) { this.unhealthyThresholdCount = unhealthyThresholdCount; }
+
+ public String getHealthCheckPath() { return healthCheckPath; }
+ public void setHealthCheckPath(String healthCheckPath) { this.healthCheckPath = healthCheckPath; }
+
+ public String getMatcher() { return matcher; }
+ public void setMatcher(String matcher) { this.matcher = matcher; }
+
+ public List<String> getLoadBalancerArns() { return loadBalancerArns; }
+ public void setLoadBalancerArns(List<String> loadBalancerArns) { this.loadBalancerArns = loadBalancerArns; }
+
+ public String getTargetType() { return targetType; }
+ public void setTargetType(String targetType) { this.targetType = targetType; }
+
+ public String getIpAddressType() { return ipAddressType; }
+ public void setIpAddressType(String ipAddressType) { this.ipAddressType = ipAddressType; }
+
+ public String getRegion() { return region; }
+ public void setRegion(String region) { this.region = region; }
+
+ public Map<String, String> getAttributes() { return attributes; }
+ public void setAttributes(Map<String, String> attributes) { this.attributes = attributes; }
+
+ public List<TargetDescription> getTargets() { return targets; }
+ public void setTargets(List<TargetDescription> targets) { this.targets = targets; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetHealth.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetHealth.java
new file mode 100644
index 0000000000..6d5d0c7d98
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/model/TargetHealth.java
@@ -0,0 +1,32 @@
+package io.github.hectorvent.floci.services.elbv2.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class TargetHealth {
+
+ private TargetDescription target;
+ private String healthCheckPort;
+ private String state;
+ private String reason;
+ private String description;
+
+ public TargetHealth() {}
+
+ public TargetDescription getTarget() { return target; }
+ public void setTarget(TargetDescription target) { this.target = target; }
+
+ public String getHealthCheckPort() { return healthCheckPort; }
+ public void setHealthCheckPort(String healthCheckPort) { this.healthCheckPort = healthCheckPort; }
+
+ public String getState() { return state; }
+ public void setState(String state) { this.state = state; }
+
+ public String getReason() { return reason; }
+ public void setReason(String reason) { this.reason = reason; }
+
+ public String getDescription() { return description; }
+ public void setDescription(String description) { this.description = description; }
+}
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index f9019e18b1..1128a6f13b 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -217,3 +217,5 @@ floci:
api-server-max-port: 6599
data-path: ./data/eks
keep-running-on-shutdown: false
+ elbv2:
+ enabled: true
diff --git a/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java
index 1e6c576b85..2d41833f45 100644
--- a/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java
@@ -51,7 +51,8 @@ class HealthControllerIntegrationTest {
"tagging": "running",
"bedrock-runtime": "running",
"eks": "running",
- "pipes": "running"
+ "pipes": "running",
+ "elasticloadbalancing": "running"
},
"edition": "floci-always-free",
"version": "dev"
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java
new file mode 100644
index 0000000000..66f95db0f4
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java
@@ -0,0 +1,576 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+
+/**
+ * Integration tests for ELB v2 via the Query protocol (form-encoded POST, XML response).
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class ElbV2IntegrationTest {
+
+ private static final String AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20260427/us-east-1/elasticloadbalancing/aws4_request";
+
+ private static String lbArn;
+ private static String tgArn;
+ private static String listenerArn;
+ private static String ruleArn1;
+ private static String ruleArn2;
+
+ // ── Load Balancers ────────────────────────────────────────────────────────
+
+ @Test
+ @Order(1)
+ void createLoadBalancer() {
+ lbArn = given()
+ .formParam("Action", "CreateLoadBalancer")
+ .formParam("Name", "my-test-lb")
+ .formParam("Type", "application")
+ .formParam("Scheme", "internet-facing")
+ .formParam("IpAddressType", "ipv4")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .contentType("application/xml")
+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.LoadBalancerName",
+ equalTo("my-test-lb"))
+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.Type",
+ equalTo("application"))
+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.Scheme",
+ equalTo("internet-facing"))
+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.State.Code",
+ equalTo("provisioning"))
+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.DNSName",
+ containsString(".elb.localhost"))
+ .extract()
+ .path("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.LoadBalancerArn");
+ }
+
+ @Test
+ @Order(2)
+ void describeLoadBalancerByArn() {
+ given()
+ .formParam("Action", "DescribeLoadBalancers")
+ .formParam("LoadBalancerArns.member.1", lbArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers.member.LoadBalancerArn",
+ equalTo(lbArn))
+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers.member.State.Code",
+ equalTo("active"));
+ }
+
+ @Test
+ @Order(3)
+ void describeLoadBalancerByName() {
+ given()
+ .formParam("Action", "DescribeLoadBalancers")
+ .formParam("Names.member.1", "my-test-lb")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers.member.LoadBalancerName",
+ equalTo("my-test-lb"));
+ }
+
+ @Test
+ @Order(4)
+ void duplicateLoadBalancerNameThrows() {
+ given()
+ .formParam("Action", "CreateLoadBalancer")
+ .formParam("Name", "my-test-lb")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("DuplicateLoadBalancerName"));
+ }
+
+ @Test
+ @Order(5)
+ void modifyLoadBalancerAttributes() {
+ given()
+ .formParam("Action", "ModifyLoadBalancerAttributes")
+ .formParam("LoadBalancerArn", lbArn)
+ .formParam("Attributes.member.1.Key", "deletion_protection.enabled")
+ .formParam("Attributes.member.1.Value", "true")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("ModifyLoadBalancerAttributesResponse.ModifyLoadBalancerAttributesResult.Attributes.member.Key",
+ equalTo("deletion_protection.enabled"))
+ .body("ModifyLoadBalancerAttributesResponse.ModifyLoadBalancerAttributesResult.Attributes.member.Value",
+ equalTo("true"));
+ }
+
+ @Test
+ @Order(6)
+ void describeLoadBalancerAttributes() {
+ given()
+ .formParam("Action", "DescribeLoadBalancerAttributes")
+ .formParam("LoadBalancerArn", lbArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeLoadBalancerAttributesResponse.DescribeLoadBalancerAttributesResult.Attributes.member.Key",
+ equalTo("deletion_protection.enabled"));
+ }
+
+ // ── Target Groups ─────────────────────────────────────────────────────────
+
+ @Test
+ @Order(10)
+ void createTargetGroup() {
+ tgArn = given()
+ .formParam("Action", "CreateTargetGroup")
+ .formParam("Name", "my-test-tg")
+ .formParam("Protocol", "HTTP")
+ .formParam("Port", "80")
+ .formParam("VpcId", "vpc-00000001")
+ .formParam("TargetType", "ip")
+ .formParam("HealthCheckPath", "/health")
+ .formParam("HealthCheckIntervalSeconds", "15")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetGroupName",
+ equalTo("my-test-tg"))
+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.Protocol",
+ equalTo("HTTP"))
+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.Port",
+ equalTo("80"))
+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.HealthCheckPath",
+ equalTo("/health"))
+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.HealthCheckIntervalSeconds",
+ equalTo("15"))
+ .extract()
+ .path("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetGroupArn");
+ }
+
+ @Test
+ @Order(11)
+ void describeTargetGroups() {
+ given()
+ .formParam("Action", "DescribeTargetGroups")
+ .formParam("TargetGroupArns.member.1", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeTargetGroupsResponse.DescribeTargetGroupsResult.TargetGroups.member.TargetGroupArn",
+ equalTo(tgArn));
+ }
+
+ @Test
+ @Order(12)
+ void duplicateTargetGroupNameThrows() {
+ given()
+ .formParam("Action", "CreateTargetGroup")
+ .formParam("Name", "my-test-tg")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("DuplicateTargetGroupName"));
+ }
+
+ @Test
+ @Order(13)
+ void modifyTargetGroupAttributes() {
+ given()
+ .formParam("Action", "ModifyTargetGroupAttributes")
+ .formParam("TargetGroupArn", tgArn)
+ .formParam("Attributes.member.1.Key", "deregistration_delay.timeout_seconds")
+ .formParam("Attributes.member.1.Value", "60")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("ModifyTargetGroupAttributesResponse.ModifyTargetGroupAttributesResult.Attributes.member.Key",
+ equalTo("deregistration_delay.timeout_seconds"));
+ }
+
+ // ── Targets ───────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(20)
+ void registerTargets() {
+ given()
+ .formParam("Action", "RegisterTargets")
+ .formParam("TargetGroupArn", tgArn)
+ .formParam("Targets.member.1.Id", "10.0.0.1")
+ .formParam("Targets.member.1.Port", "80")
+ .formParam("Targets.member.2.Id", "10.0.0.2")
+ .formParam("Targets.member.2.Port", "80")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(21)
+ void describeTargetHealthReturnsInitial() {
+ given()
+ .formParam("Action", "DescribeTargetHealth")
+ .formParam("TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeTargetHealthResponse.DescribeTargetHealthResult.TargetHealthDescriptions.member[0].TargetHealth.State",
+ equalTo("initial"))
+ .body("DescribeTargetHealthResponse.DescribeTargetHealthResult.TargetHealthDescriptions.member[0].TargetHealth.Reason",
+ equalTo("Elb.RegistrationInProgress"));
+ }
+
+ // ── Listeners ─────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(30)
+ void createListener() {
+ listenerArn = given()
+ .formParam("Action", "CreateListener")
+ .formParam("LoadBalancerArn", lbArn)
+ .formParam("Protocol", "HTTP")
+ .formParam("Port", "80")
+ .formParam("DefaultActions.member.1.Type", "forward")
+ .formParam("DefaultActions.member.1.TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("CreateListenerResponse.CreateListenerResult.Listeners.member.Protocol",
+ equalTo("HTTP"))
+ .body("CreateListenerResponse.CreateListenerResult.Listeners.member.Port",
+ equalTo("80"))
+ .body("CreateListenerResponse.CreateListenerResult.Listeners.member.LoadBalancerArn",
+ equalTo(lbArn))
+ .extract()
+ .path("CreateListenerResponse.CreateListenerResult.Listeners.member.ListenerArn");
+ }
+
+ @Test
+ @Order(31)
+ void describeListeners() {
+ given()
+ .formParam("Action", "DescribeListeners")
+ .formParam("LoadBalancerArn", lbArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeListenersResponse.DescribeListenersResult.Listeners.member.ListenerArn",
+ equalTo(listenerArn));
+ }
+
+ @Test
+ @Order(32)
+ void duplicateListenerPortThrows() {
+ given()
+ .formParam("Action", "CreateListener")
+ .formParam("LoadBalancerArn", lbArn)
+ .formParam("Protocol", "HTTP")
+ .formParam("Port", "80")
+ .formParam("DefaultActions.member.1.Type", "forward")
+ .formParam("DefaultActions.member.1.TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("DuplicateListener"));
+ }
+
+ // ── Rules ─────────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(40)
+ void describeRulesIncludesDefaultRule() {
+ given()
+ .formParam("Action", "DescribeRules")
+ .formParam("ListenerArn", listenerArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeRulesResponse.DescribeRulesResult.Rules.member.IsDefault",
+ equalTo("true"))
+ .body("DescribeRulesResponse.DescribeRulesResult.Rules.member.Priority",
+ equalTo("default"));
+ }
+
+ @Test
+ @Order(41)
+ void createRuleWithPathPattern() {
+ ruleArn1 = given()
+ .formParam("Action", "CreateRule")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("Priority", "10")
+ .formParam("Conditions.member.1.Field", "path-pattern")
+ .formParam("Conditions.member.1.PathPatternConfig.Values.member.1", "/api/*")
+ .formParam("Actions.member.1.Type", "forward")
+ .formParam("Actions.member.1.TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("CreateRuleResponse.CreateRuleResult.Rules.member.Priority",
+ equalTo("10"))
+ .body("CreateRuleResponse.CreateRuleResult.Rules.member.IsDefault",
+ equalTo("false"))
+ .extract()
+ .path("CreateRuleResponse.CreateRuleResult.Rules.member.RuleArn");
+ }
+
+ @Test
+ @Order(42)
+ void createRuleWithHostHeader() {
+ ruleArn2 = given()
+ .formParam("Action", "CreateRule")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("Priority", "20")
+ .formParam("Conditions.member.1.Field", "host-header")
+ .formParam("Conditions.member.1.HostHeaderConfig.Values.member.1", "api.example.com")
+ .formParam("Actions.member.1.Type", "forward")
+ .formParam("Actions.member.1.TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("CreateRuleResponse.CreateRuleResult.Rules.member.Priority", equalTo("20"))
+ .extract()
+ .path("CreateRuleResponse.CreateRuleResult.Rules.member.RuleArn");
+ }
+
+ @Test
+ @Order(43)
+ void priorityInUseThrows() {
+ given()
+ .formParam("Action", "CreateRule")
+ .formParam("ListenerArn", listenerArn)
+ .formParam("Priority", "10")
+ .formParam("Conditions.member.1.Field", "path-pattern")
+ .formParam("Conditions.member.1.PathPatternConfig.Values.member.1", "/other/*")
+ .formParam("Actions.member.1.Type", "forward")
+ .formParam("Actions.member.1.TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("PriorityInUse"));
+ }
+
+ @Test
+ @Order(44)
+ void setRulePriorities() {
+ given()
+ .formParam("Action", "SetRulePriorities")
+ .formParam("RulePriorities.member.1.RuleArn", ruleArn1)
+ .formParam("RulePriorities.member.1.Priority", "100")
+ .formParam("RulePriorities.member.2.RuleArn", ruleArn2)
+ .formParam("RulePriorities.member.2.Priority", "200")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("SetRulePrioritiesResponse.SetRulePrioritiesResult.Rules.member[0].Priority",
+ anyOf(equalTo("100"), equalTo("200")));
+ }
+
+ @Test
+ @Order(45)
+ void deleteDefaultRuleThrows() {
+ // find the default rule ARN specifically
+ String defaultRuleArn = given()
+ .formParam("Action", "DescribeRules")
+ .formParam("ListenerArn", listenerArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .extract()
+ .path("DescribeRulesResponse.DescribeRulesResult.Rules.member.find { it.IsDefault == 'true' }.RuleArn");
+
+ given()
+ .formParam("Action", "DeleteRule")
+ .formParam("RuleArn", defaultRuleArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("OperationNotPermitted"));
+ }
+
+ // ── Tags ──────────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(50)
+ void tagsRoundtrip() {
+ given()
+ .formParam("Action", "AddTags")
+ .formParam("ResourceArns.member.1", lbArn)
+ .formParam("ResourceArns.member.2", tgArn)
+ .formParam("Tags.member.1.Key", "Environment")
+ .formParam("Tags.member.1.Value", "test")
+ .formParam("Tags.member.2.Key", "Team")
+ .formParam("Tags.member.2.Value", "platform")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .formParam("Action", "DescribeTags")
+ .formParam("ResourceArns.member.1", lbArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeTagsResponse.DescribeTagsResult.TagDescriptions.member.ResourceArn",
+ equalTo(lbArn))
+ .body("DescribeTagsResponse.DescribeTagsResult.TagDescriptions.member.Tags.member[0].Key",
+ anyOf(equalTo("Environment"), equalTo("Team")));
+
+ given()
+ .formParam("Action", "RemoveTags")
+ .formParam("ResourceArns.member.1", lbArn)
+ .formParam("TagKeys.member.1", "Environment")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ // ── Meta ──────────────────────────────────────────────────────────────────
+
+ @Test
+ @Order(60)
+ void describeSSLPolicies() {
+ given()
+ .formParam("Action", "DescribeSSLPolicies")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeSSLPoliciesResponse.DescribeSSLPoliciesResult.SslPolicies.member.size()",
+ greaterThanOrEqualTo(7))
+ .body("DescribeSSLPoliciesResponse.DescribeSSLPoliciesResult.SslPolicies.member.Name",
+ hasItem("ELBSecurityPolicy-2016-08"));
+ }
+
+ @Test
+ @Order(61)
+ void describeAccountLimits() {
+ given()
+ .formParam("Action", "DescribeAccountLimits")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeAccountLimitsResponse.DescribeAccountLimitsResult.Limits.member.Name",
+ hasItem("application-load-balancers"));
+ }
+
+ // ── Delete cascade ────────────────────────────────────────────────────────
+
+ @Test
+ @Order(70)
+ void deleteTargetGroupInUseThrows() {
+ given()
+ .formParam("Action", "DeleteTargetGroup")
+ .formParam("TargetGroupArn", tgArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ // TG still has loadBalancerArns from the listener
+ .statusCode(anyOf(equalTo(200), equalTo(400)));
+ }
+
+ @Test
+ @Order(71)
+ void deleteListenerThenDeleteTargetGroup() {
+ given()
+ .formParam("Action", "DeleteListener")
+ .formParam("ListenerArn", listenerArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .formParam("Action", "DescribeListeners")
+ .formParam("LoadBalancerArn", lbArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeListenersResponse.DescribeListenersResult.Listeners.member.size()", equalTo(0));
+ }
+
+ @Test
+ @Order(72)
+ void deleteLoadBalancerCascades() {
+ given()
+ .formParam("Action", "DeleteLoadBalancer")
+ .formParam("LoadBalancerArn", lbArn)
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .formParam("Action", "DescribeLoadBalancers")
+ .formParam("Names.member.1", "my-test-lb")
+ .header("Authorization", AUTH)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("ErrorResponse.Error.Code", equalTo("LoadBalancerNotFound"));
+ }
+}
diff --git a/src/test/resources/application.yml b/src/test/resources/application.yml
index 30c9e27fad..961f5f8f8f 100644
--- a/src/test/resources/application.yml
+++ b/src/test/resources/application.yml
@@ -147,3 +147,5 @@ floci:
mock: true
pipes:
enabled: true
+ elbv2:
+ enabled: true